--- before
+++ after
@@ -0,0 +1,5559 @@
+"""Deterministic variance analysis helpers for the Codex plugin."""
+
+from __future__ import annotations
+
+import argparse
+import calendar
+import itertools
+import json
+import logging
+import re
+import shutil
+import sys
+from dataclasses import dataclass
+from datetime import date, datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Iterable, Sequence
+
+import polars as pl
+from accounting_controls import (
+    default_accounting_review,
+    evaluate_accounting_readiness,
+    normalize_accounting_review,
+)
+from ibcs_titles import build_ibcs_title
+from legacy_adapter import (
+    cleanup_legacy_imports,
+    legacy_date_period_context,
+    run_legacy_variable_dimension_bridge,
+    run_legacy_variable_dimension_component_bridge,
+    run_legacy_variance,
+)
+from legacy_plotting import write_pvm_decomposition_ladder_png, write_waterfall_png
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+
+
+def _ensure_local_review_session_import() -> None:
+    """Use this plugin's review-session module in multi-plugin test runs."""
+
+    script_dir = str(SCRIPT_DIR)
+    if script_dir in sys.path:
+        sys.path.remove(script_dir)
+    sys.path.insert(0, script_dir)
+    module = sys.modules.get("review_session")
+    module_file = getattr(module, "__file__", None) if module is not None else None
+    if module_file and Path(module_file).resolve().is_relative_to(SCRIPT_DIR.resolve()):
+        return
+    if module is not None:
+        del sys.modules["review_session"]
+
+
+_ensure_local_review_session_import()
+from exploded_variance_bridge_chart import (
+    DEFAULT_CHILD_TOP_N as EXPLODED_BRIDGE_DEFAULT_CHILD_TOP_N,
+)
+from exploded_variance_bridge_chart import (
+    DEFAULT_MAX_DRILLDOWNS as EXPLODED_BRIDGE_DEFAULT_MAX_DRILLDOWNS,
+)
+from exploded_variance_bridge_chart import (
+    write_exploded_variance_bridge_artifacts,
+)
+from model_use import write_model_use_manifest
+from review_session import write_review_session_artifacts, write_run_intake
+from root_cause_bridge_chart import write_root_cause_bridge_png
+from root_cause_client_report import write_root_cause_client_report
+from total_by_dimension_bridge_chart import (
+    DEFAULT_TOP_N as TOTAL_BY_DIMENSION_DEFAULT_TOP_N,
+)
+from total_by_dimension_bridge_chart import (
+    write_total_by_dimension_bridge_artifacts,
+)
+
+PLUGIN_ROOT = Path(__file__).resolve().parents[1]
+VENDOR_ROOT = PLUGIN_ROOT / "vendor"
+REPO_ROOT = Path(__file__).resolve().parents[3]
+SHARED_VENDOR_ROOT = REPO_ROOT / "plugins" / "_shared" / "vendor"
+
+
+def is_vera_managed_host(plugin_root: Path | None = None) -> bool:
+    """Return whether this component is embedded in a Vera package.
+
+    Host detection is deterministic because it enforces a package-layout and
+    package-manifest security contract: an embedded Vera component must never
+    silently fall back to the standalone execution boundary.
+    """
+
+    root = (plugin_root or PLUGIN_ROOT).resolve()
+    layout_is_vera = (
+        root.name == "variance-analysis"
+        and root.parent.name == "modules"
+        and root.parent.parent.name == "vera"
+    )
+    host_manifest = root.parent.parent / ".codex-plugin" / "plugin.json"
+    manifest_is_vera = False
+    if host_manifest.is_file():
+        try:
+            manifest = json.loads(host_manifest.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            manifest = {}
+        manifest_is_vera = manifest.get("name") == "vera"
+    return layout_is_vera or manifest_is_vera
+
+
+def _ensure_shared_modules_path() -> None:
+    """Make shared plugin harness modules importable in repo and ZIP runs."""
+
+    shared_parent = SHARED_VENDOR_ROOT if SHARED_VENDOR_ROOT.exists() else VENDOR_ROOT
+    shared_text = str(shared_parent)
+    if shared_text in sys.path:
+        sys.path.remove(shared_text)
+    sys.path.insert(0, shared_text)
+    module_root = (shared_parent / "modules").resolve()
+    for name, module in list(sys.modules.items()):
+        if name == "modules" or name.startswith("modules."):
+            module_file = getattr(module, "__file__", None)
+            if not module_file or not Path(module_file).resolve().is_relative_to(
+                module_root
+            ):
+                del sys.modules[name]
+
+
+_ensure_shared_modules_path()
+from modules.chart_harness import (  # noqa: E402  # isort: skip
+    apply_recipe_filters,
+    apply_recipe_cohorts,
+    available_analysis_context,
+    default_scenario_comparison_pair,
+    PERIOD_GRAIN_MONTH,
+    PERIOD_GRAIN_QUARTER,
+    PERIOD_GRAIN_WEEK,
+    PERIOD_GRAIN_YEAR,
+    PERIOD_TYPE_CUSTOM,
+    PERIOD_TYPE_FISCAL,
+    PERIOD_TYPE_ROLLING,
+    PERIOD_TYPE_TO_DATE,
+    period_contract_options,
+    preserve_recipe_cohorts,
+    preserve_recipe_filters,
+    recipe_cohort_dimension_names,
+    recipe_cohort_source_dimensions,
+    scenario_column_kind,
+    write_prepared_data_manifest,
+)
+
+__all__ = [
+    "InspectionResult",
+    "VarianceRunResult",
+    "add_common_args",
+    "configure_logging",
+    "inspect_variance_inputs",
+    "is_vera_managed_host",
+    "run_variance_analysis",
+]
+
+LOGGER = logging.getLogger(__name__)
+LEGACY_RENDER_ERRORS = (
+    AttributeError,
+    IndexError,
+    ImportError,
+    KeyError,
+    ModuleNotFoundError,
+    NameError,
+    OSError,
+    RuntimeError,
+    TypeError,
+    ValueError,
+    pl.exceptions.PolarsError,
+)
+SCHEMA_VERSION = "1.0"
+ARTIFACT_MODE_DATA_ONLY = "data_only"
+ARTIFACT_MODE_DATA_AND_RENDER = "data_and_render"
+ARTIFACT_MODES = {
+    ARTIFACT_MODE_DATA_ONLY,
+    ARTIFACT_MODE_DATA_AND_RENDER,
+}
+VARIANCE_CHART_STANDARD_WATERFALL = "standard_variance_waterfall"
+VARIANCE_CHART_PVM_LADDER = "pvm_decomposition_ladder"
+VARIANCE_CHART_SMALL_MULTIPLES = "standard_variance_small_multiples"
+VARIANCE_CHART_TOTAL_BY_DIMENSION = "total_by_dimension_bridge"
+VARIANCE_CHART_EXPLODED_BRIDGE = "exploded_variance_bridge"
+VARIANCE_CHART_ROOT_CAUSE = "root_cause_total_bridge"
+TOTAL_DIMENSION = "__total"
+ROOT_CAUSE_BRIDGE_MEASURE_COLUMNS = {
+    "bridge_level",
+    "bridge_dimensions",
+    "variance_type",
+    "variance_amount",
+    "amount_baseline",
+    "amount_comparison",
+    "units_baseline",
+    "units_comparison",
+    "bridge_unique_value_weight",
+}
+ROOT_CAUSE_AUTO_DRILLDOWN_VALUES = {
+    "none",
+    "single_row",
+    "dominant_row",
+    "all_selected",
+}
+COMPARISON_BASIS_SCENARIO = "scenario"
+COMPARISON_BASIS_PERIOD = "period"
+COMPARISON_BASIS_VALUES = {COMPARISON_BASIS_SCENARIO, COMPARISON_BASIS_PERIOD}
+PERIOD_MODE_NOT_APPLICABLE = "not_applicable"
+PERIOD_MODE_CALENDAR = "calendar_period"
+PERIOD_MODE_YEAR_TO_DATE = "year_to_date"
+PERIOD_MODE_ROLLING = "rolling_period"
+PERIOD_MODE_CUSTOM = "custom"
+PERIOD_COMPARISON_MODE_VALUES = {
+    PERIOD_MODE_NOT_APPLICABLE,
+    PERIOD_MODE_CALENDAR,
+    PERIOD_MODE_YEAR_TO_DATE,
+    PERIOD_MODE_ROLLING,
+    PERIOD_MODE_CUSTOM,
+}
+SYNTHETIC_PERIOD_COLUMN = "__variance_period_bucket"
+DATE_WORK_COLUMN = "__variance_date"
+ROLLING_COMPARISON_PRIOR_YEAR = "prior_year"
+ROLLING_COMPARISON_PREVIOUS_WINDOW = "previous_window"
+ROLLING_COMPARISON_VALUES = {
+    ROLLING_COMPARISON_PRIOR_YEAR,
+    ROLLING_COMPARISON_PREVIOUS_WINDOW,
+}
+DATE_COLUMN_HINTS = (
+    "date",
+    "order date",
+    "orderdate",
+    "sales date",
+    "invoice date",
+    "transaction date",
+    "posting date",
+)
+DIMENSION_NAME_PRIORITY = (
+    "category",
+    "subcategory",
+    "productline",
+    "product line",
+    "region",
+    "country",
+    "group",
+    "segment",
+    "channel",
+    "brand",
+    "product",
+    "productname",
+    "product name",
+    "customer segment",
+)
+SMALL_MULTIPLES_DIMENSION_NAME_PRIORITY = (
+    "productline",
+    "product line",
+    "category",
+    "subcategory",
+    "region",
+    "country",
+    "market",
+    "territory",
+    "group",
+    "segment",
+    "customer segment",
+    "channel",
+    "brand",
+    "product",
+    "customer",
+    "productname",
+    "product name",
+)
+SMALL_MULTIPLES_GRANULAR_NAME_HINTS = (
+    "sku",
+    "item",
+    "productname",
+    "product name",
+    "customer",
+    "customer name",
+    "account",
+    "id",
+    "code",
+    "number",
+)
+SMALL_MULTIPLES_MAX_REASONABLE_CARDINALITY = 50
+SMALL_MULTIPLES_IDEAL_CARDINALITY = 12
+SMALL_MULTIPLES_MIN_DIMENSION_SCORE = 30.0
+SMALL_MULTIPLES_PANEL_LIMIT = 12
+SMALL_MULTIPLES_NULL_LABEL = "N/A"
+SMALL_MULTIPLES_OTHER_LABEL = "Others aggregated"
+SMALL_MULTIPLES_WORK_COLUMN = "__small_multiples_dimension_value"
+TOTAL_BY_DIMENSION_MIN_SCORE = 10.0
+TOTAL_BY_DIMENSION_MAX_REASONABLE_CARDINALITY = 250
+TOTAL_BY_DIMENSION_NAME_PRIORITY = (
+    "company",
+    "brand",
+    "region",
+    "market",
+    "country",
+    "channel",
+    "customer segment",
+    "segment",
+    "category",
+    "subcategory",
+    "productline",
+    "product line",
+    "retailer",
+)
+STANDARD_VARIANCE_COMPONENT_COLUMNS = (
+    ("Price", "price_variance"),
+    ("volume_or_units", "volume_variance"),
+    ("Mix", "mix_variance"),
+)
+TOLERANCE = 1e-9
+CALCULATION_GRAIN_NAME_PRIORITY = (
+    "sku",
+    "item",
+    "product",
+    "productname",
+    "product name",
+    "customer",
+    "customer name",
+    "account",
+)
+
+COLUMN_HINTS: dict[str, tuple[str, ...]] = {
+    "period_column": (
+        "period",
+        "month",
+        "year",
+        "fiscal period",
+        "date",
+        "time",
+    ),
+    "amount_column": (
+        "sales",
+        "revenue",
+        "turnover",
+        "amount",
+        "net sales",
+        "value",
+    ),
+    "units_column": (
+        "units",
+        "unit",
+        "qty",
+        "quantity",
+        "volume",
+        "pieces",
+    ),
+    "discount_column": (
+        "discount",
+        "rebate",
+        "promo",
+        "markdown",
+    ),
+    "cogs_column": (
+        "cogs",
+        "cost of goods",
+        "cost",
+        "costs",
+        "unit cost",
+    ),
+}
+
+
+@dataclass(frozen=True)
+class InspectionResult:
+    """Inspection payload and suggested recipe."""
+
+    payload: dict[str, Any]
+    recipe: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class VarianceRunResult:
+    """Variance output payloads returned after a deterministic run."""
+
+    frame: pl.DataFrame
+    audit: dict[str, Any]
+    summary_markdown: str
+    artifact_paths: list[str]
+
+
+def configure_logging(verbose: bool = False) -> None:
+    """Configure CLI logging."""
+
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(level=level, format="%(levelname)s: %(message)s")
+
+
+def add_common_args(parser: argparse.ArgumentParser) -> None:
+    """Add common plugin CLI arguments."""
+
+    parser.add_argument(
+        "--language",
+        default="en",
+        choices=["it", "en", "fr", "de", "es"],
+        help="Working/output language for Codex-facing summaries.",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Show debug logging.",
+    )
+    parser.add_argument(
+        "--artifact-mode",
+        choices=sorted(ARTIFACT_MODES),
+        default=ARTIFACT_MODE_DATA_AND_RENDER,
+        help=("Write chart data only or keep the legacy data-and-render behavior."),
+    )
+
+
+def utc_now() -> str:
+    """Return an ISO timestamp for audit outputs."""
+
+    return datetime.now(timezone.utc).isoformat()
+
+
+def get_schema_and_column_names(df: pl.DataFrame) -> tuple[list[str], dict[str, str]]:
+    """Return column names and JSON-safe schema."""
+
+    return list(df.schema.keys()), {
+        name: str(dtype) for name, dtype in df.schema.items()
+    }
+
+
+def _collect_csv_scan(path: Path, *, separator: str) -> pl.DataFrame:
+    """Read delimited input through a lazy scan and collect once."""
+
+    lf = pl.scan_csv(path, separator=separator, infer_schema_length=10000)
+    try:
+        return lf.collect(engine="streaming")
+    except pl.exceptions.PolarsError:
+        return lf.collect()
+
+
+def read_table(path: Path) -> pl.DataFrame:
+    """Read a supported CSV or Excel file."""
+
+    suffix = path.suffix.lower()
+    if suffix in {".csv", ".txt", ".tsv", ".psv"}:
+        separator = {
+            ".tsv": "\t",
+            ".psv": "|",
+        }.get(suffix, ",")
+        return _collect_csv_scan(path, separator=separator)
+    if suffix in {".xlsx", ".xlsm"}:
+        return pl.read_excel(path)
+    raise ValueError(
+        f"Unsupported input file type '{suffix}'. Use CSV, TSV, PSV, XLSX, or XLSM."
+    )
+
+
+def write_json(path: Path, payload: dict[str, Any]) -> None:
+    """Write a stable JSON file."""
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(json_safe(payload), ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+
+def warn_if_output_dir_has_existing_files(output_dir: Path, context: str) -> None:
+    """Log a warning when a run may mix with stale output files."""
+
+    if not output_dir.exists() or not output_dir.is_dir():
+        return
+    existing_files = sorted(
+        path.name for path in output_dir.iterdir() if path.is_file()
+    )
+    if not existing_files:
+        return
+    visible_files = ", ".join(existing_files[:8])
+    if len(existing_files) > 8:
+        visible_files = f"{visible_files}, ..."
+    LOGGER.warning(
+        "%s output directory already contains files; this run may overwrite "
+        "matching artifacts and leave unrelated stale artifacts in place: %s "
+        "(existing files: %s)",
+        context,
+        output_dir,
+        visible_files,
+    )
+
+
+def json_safe(value: Any) -> Any:
+    """Return a JSON-serializable representation of common analysis values."""
+
+    if isinstance(value, dict):
+        return {str(key): json_safe(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [json_safe(item) for item in value]
+    if isinstance(value, tuple):
+        return [json_safe(item) for item in value]
+    if isinstance(value, (datetime, date, Path)):
+        return str(value)
+    return value
+
+
+def load_json(path: Path) -> dict[str, Any]:
+    """Load a JSON object from disk."""
+
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError(f"Expected JSON object in recipe: {path}")
+    return payload
+
+
+def normalize_name(name: str) -> str:
+    """Normalize a column name for deterministic matching."""
+
+    return " ".join(name.replace("_", " ").replace("-", " ").lower().split())
+
+
+def compact_normalized_name(name: str) -> str:
+    """Return a compact normalized name for underscore/spacing-insensitive matching."""
+
+    return "".join(token for token in normalize_name(name).split())
+
+
+def first_matching_column(columns: Iterable[str], hints: Iterable[str]) -> str | None:
+    """Return the first column whose normalized name matches the hints."""
+
+    normalized_columns = [(column, normalize_name(column)) for column in columns]
+    normalized_hints = [normalize_name(hint) for hint in hints]
+    for hint in normalized_hints:
+        for column, normalized in normalized_columns:
+            if normalized == hint:
+                return column
+    for hint in normalized_hints:
+        for column, normalized in normalized_columns:
+            if hint in normalized:
+                return column
+    return None
+
+
+def is_numeric_dtype(dtype: pl.DataType) -> bool:
+    """Return whether a Polars dtype is numeric enough for variance math."""
+
+    return dtype.is_numeric()
+
+
+def is_temporal_dtype(dtype: pl.DataType) -> bool:
+    """Return whether a Polars dtype is temporal."""
+
+    return dtype.is_temporal()
+
+
+def suggested_date_column(df: pl.DataFrame, columns: list[str]) -> str | None:
+    """Return the best date column for rolling/YTD bucket preparation."""
+
+    hinted = first_matching_column(columns, DATE_COLUMN_HINTS)
+    if hinted and is_temporal_dtype(df.schema[hinted]):
+        return hinted
+    temporal_columns = [
+        column for column in columns if is_temporal_dtype(df.schema[column])
+    ]
+    if hinted:
+        return hinted
+    return temporal_columns[0] if temporal_columns else None
+
+
+def distinct_text_values(df: pl.DataFrame, column: str) -> list[str]:
+    """Return distinct non-empty text values preserving source labels."""
+
+    values = (
+        df.select(pl.col(column).cast(pl.Utf8).drop_nulls().unique().sort())
+        .to_series(0)
+        .to_list()
+    )
+    return [str(value).strip() for value in values if str(value).strip()]
+
+
+def is_scenario_comparison_column(df: pl.DataFrame, column: str | None) -> bool:
+    """Return whether a column contains an AC-vs-plan-like scenario comparison.
+
+    This deterministic rule is limited to exact IBCS scenario roles: Actual can
+    be compared with Plan, Forecast, or Budget. AC/PY alone remains a period
+    comparison, not a scenario comparison.
+    """
+
+    if not column or column not in df.schema:
+        return False
+    values = distinct_text_values(df, column)
+    if scenario_column_kind(column, values) != COMPARISON_BASIS_SCENARIO:
+        return False
+    baseline, comparison = default_scenario_comparison_pair(values)
+    return bool(baseline and comparison)
+
+
+def is_plan_actual_scenario_column(df: pl.DataFrame, column: str | None) -> bool:
+    """Return whether a column is a supported Actual-vs-scenario code column."""
+
+    return is_scenario_comparison_column(df, column)
+
+
+def plan_actual_scenario_column(df: pl.DataFrame, columns: Iterable[str]) -> str | None:
+    """Return the AC-vs-plan/forecast/budget scenario column when present."""
+
+    for column in columns:
+        if is_plan_actual_scenario_column(df, column):
+            return column
+    return None
+
+
+def ranked_dimension_candidates(candidates: list[str]) -> list[str]:
+    """Return dimension candidates with known business dimensions first."""
+
+    selected: list[str] = []
+    normalized = [(column, normalize_name(column)) for column in candidates]
+    for hint in DIMENSION_NAME_PRIORITY:
+        normalized_hint = normalize_name(hint)
+        for column, normalized_name in normalized:
+            if normalized_name == normalized_hint and column not in selected:
+                selected.append(column)
+    selected.extend(column for column in candidates if column not in selected)
+    return selected
+
+
+def dimension_priority_score(column: str, priority: tuple[str, ...]) -> float:
+    """Return a deterministic business-readability score for a dimension name."""
+
+    normalized_name = normalize_name(column)
+    compact_name = compact_normalized_name(column)
+    for index, hint in enumerate(priority):
+        normalized_hint = normalize_name(hint)
+        compact_hint = compact_normalized_name(hint)
+        base_score = max(12.0, 55.0 - (index * 3.0))
+        if normalized_name == normalized_hint or compact_name == compact_hint:
+            return base_score
+        if compact_hint in compact_name or compact_name in compact_hint:
+            return max(10.0, base_score - 8.0)
+    return 8.0
+
+
+def name_contains_hint(column: str, hint: str) -> bool:
+    """Return whether a normalized column name contains a safe name hint."""
+
+    normalized_name = normalize_name(column)
+    normalized_hint = normalize_name(hint)
+    compact_hint = compact_normalized_name(hint)
+    if len(compact_hint) <= 2:
+        return normalized_hint in normalized_name.split()
+    if normalized_hint in normalized_name:
+        return True
+    return compact_hint in compact_normalized_name(column)
+
+
+def cardinality_score(cardinality: int) -> float:
+    """Return a small-multiples score for the number of panels needed."""
+
+    if cardinality < 2:
+        return -100.0
+    if cardinality <= 4:
+        return 26.0
+    if cardinality <= SMALL_MULTIPLES_IDEAL_CARDINALITY:
+        return 32.0
+    if cardinality <= 24:
+        return 16.0
+    if cardinality <= SMALL_MULTIPLES_MAX_REASONABLE_CARDINALITY:
+        return 4.0
+    return -25.0
+
+
+def granularity_penalty(column: str, cardinality: int) -> float:
+    """Return penalty for columns that usually create noisy small multiples."""
+
+    normalized_name = normalize_name(column)
+    penalty = 0.0
+    if any(
+        name_contains_hint(normalized_name, hint)
+        for hint in SMALL_MULTIPLES_GRANULAR_NAME_HINTS
+    ):
+        penalty += 18.0
+    if cardinality > SMALL_MULTIPLES_IDEAL_CARDINALITY:
+        penalty += 8.0
+    if cardinality > SMALL_MULTIPLES_MAX_REASONABLE_CARDINALITY:
+        penalty += 20.0
+    return penalty
+
+
+def select_waterfall_small_multiples_dimension(
+    result: pl.DataFrame,
+    recipe: dict[str, Any],
+) -> dict[str, Any]:
+    """Choose a presentation dimension for standard-variance small multiples."""
+
+    options = recipe.get("options") or {}
+    mappings = recipe.get("mappings") or {}
+    dimensions = [
+        str(column)
+        for column in mappings.get("dimensions") or []
+        if str(column) in result.schema
+    ]
+    explicit_dimension = options.get("waterfall_small_multiples_dimension")
+    if explicit_dimension:
+        explicit_dimension = str(explicit_dimension)
+        return {
+            "status": (
+                "selected_explicit"
+                if explicit_dimension in result.schema
+                else "not_selected_missing_explicit_dimension"
+            ),
+            "dimension": (
+                explicit_dimension if explicit_dimension in result.schema else None
+            ),
+            "reason": "explicit_recipe_or_cli_dimension",
+            "candidates": [],
+        }
+    if not dimensions:
+        return {
+            "status": "not_selected_no_mapped_dimensions",
+            "dimension": None,
+            "reason": "standard_variance_has_no_reporting_dimension",
+            "candidates": [],
+        }
+
+    candidates: list[dict[str, Any]] = []
+    for dimension in dimensions:
+        grouped = (
+            result.group_by(dimension)
+            .agg(pl.col("total_delta").sum().alias("_delta"))
+            .with_columns(pl.col("_delta").abs().alias("_abs_delta"))
+            .sort("_abs_delta", descending=True)
+        )
+        cardinality = grouped.height
+        total_abs_delta = float(
+            grouped.select(pl.col("_abs_delta").sum()).item() or 0.0
+        )
+        top_abs_delta = float(grouped.select(pl.col("_abs_delta").max()).item() or 0.0)
+        non_zero_count = grouped.filter(pl.col("_abs_delta") > 0.000001).height
+        top_share = top_abs_delta / total_abs_delta if total_abs_delta else 0.0
+        name_score = dimension_priority_score(
+            dimension,
+            SMALL_MULTIPLES_DIMENSION_NAME_PRIORITY,
+        )
+        candidate_cardinality_score = cardinality_score(cardinality)
+        spread_score = min(14.0, float(non_zero_count) * 2.0)
+        if 0.25 <= top_share <= 0.85:
+            spread_score += 8.0
+        elif top_share > 0.95:
+            spread_score -= 4.0
+        penalty = granularity_penalty(dimension, cardinality)
+        score = name_score + candidate_cardinality_score + spread_score - penalty
+        candidates.append(
+            {
+                "dimension": dimension,
+                "score": round(score, 3),
+                "name_score": round(name_score, 3),
+                "cardinality_score": round(candidate_cardinality_score, 3),
+                "spread_score": round(spread_score, 3),
+                "granularity_penalty": round(penalty, 3),
+                "cardinality": cardinality,
+                "non_zero_members": non_zero_count,
+                "top_member_share_of_abs_delta": round(top_share, 6),
+            }
+        )
+    candidates.sort(
+        key=lambda item: (
+            float(item["score"]),
+            float(item["name_score"]),
+            -int(item["cardinality"]),
+        ),
+        reverse=True,
+    )
+    best = candidates[0]
+    if float(best["score"]) < SMALL_MULTIPLES_MIN_DIMENSION_SCORE:
+        return {
+            "status": "not_selected_no_clear_dimension",
+            "dimension": None,
+            "reason": "no_candidate_met_business_readability_threshold",
+            "candidates": candidates,
+        }
+    return {
+        "status": "selected_ranked_candidate",
+        "dimension": best["dimension"],
+        "reason": (
+            "highest score from business-readability, cardinality, and variance "
+            "spread heuristic"
+        ),
+        "candidates": candidates,
+    }
+
+
+def select_total_by_dimension_bridge_dimension(
+    result: pl.DataFrame,
+    recipe: dict[str, Any],
+) -> dict[str, Any]:
+    """Choose one fixed dimension for the total variance bridge."""
+
+    options = recipe.get("options") or {}
+    mappings = recipe.get("mappings") or {}
+    dimensions = [
+        str(column)
+        for column in mappings.get("dimensions") or []
+        if str(column) in result.schema
+    ]
+    explicit_dimension = options.get("total_by_dimension_bridge_dimension")
+    if explicit_dimension:
+        explicit_dimension = str(explicit_dimension)
+        return {
+            "status": (
+                "selected_explicit"
+                if explicit_dimension in result.schema
+                else "not_selected_missing_explicit_dimension"
+            ),
+            "dimension": (
+                explicit_dimension if explicit_dimension in result.schema else None
+            ),
+            "reason": "explicit_recipe_or_cli_dimension",
+            "candidates": [],
+        }
+    if not dimensions:
+        return {
+            "status": "not_selected_no_mapped_dimensions",
+            "dimension": None,
+            "reason": "total_by_dimension_bridge_requires_one_dimension",
+            "candidates": [],
+        }
+
+    candidates: list[dict[str, Any]] = []
+    for dimension in dimensions:
+        grouped = (
+            result.group_by(dimension)
+            .agg(pl.col("total_delta").sum().alias("_delta"))
+            .with_columns(pl.col("_delta").abs().alias("_abs_delta"))
+            .sort("_abs_delta", descending=True)
+        )
+        cardinality = grouped.height
+        total_abs_delta = float(
+            grouped.select(pl.col("_abs_delta").sum()).item() or 0.0
+        )
+        top_abs_delta = float(grouped.select(pl.col("_abs_delta").max()).item() or 0.0)
+        non_zero_count = grouped.filter(pl.col("_abs_delta") > TOLERANCE).height
+        top_share = top_abs_delta / total_abs_delta if total_abs_delta else 0.0
+        name_score = dimension_priority_score(
+            dimension,
+            TOTAL_BY_DIMENSION_NAME_PRIORITY,
+        )
+        if 2 <= cardinality <= 12:
+            cardinality_component = 28.0
+        elif cardinality <= 36:
+            cardinality_component = 18.0
+        elif cardinality <= TOTAL_BY_DIMENSION_MAX_REASONABLE_CARDINALITY:
+            cardinality_component = 8.0
+        else:
+            cardinality_component = -20.0
+        spread_score = min(16.0, float(non_zero_count) * 2.0)
+        if 0.2 <= top_share <= 0.9:
+            spread_score += 6.0
+        elif top_share > 0.98:
+            spread_score -= 6.0
+        penalty = granularity_penalty(dimension, cardinality)
+        score = name_score + cardinality_component + spread_score - penalty
+        candidates.append(
+            {
+                "dimension": dimension,
+                "score": round(score, 3),
+                "name_score": round(name_score, 3),
+                "cardinality_score": round(cardinality_component, 3),
+                "spread_score": round(spread_score, 3),
+                "granularity_penalty": round(penalty, 3),
+                "cardinality": cardinality,
+                "non_zero_members": non_zero_count,
+                "top_member_share_of_abs_delta": round(top_share, 6),
+            }
+        )
+    candidates.sort(
+        key=lambda item: (
+            float(item["score"]),
+            float(item["name_score"]),
+            -int(item["cardinality"]),
+        ),
+        reverse=True,
+    )
+    best = candidates[0]
+    if float(best["score"]) < TOTAL_BY_DIMENSION_MIN_SCORE:
+        fallback_dimension = dimensions[0]
+        return {
+            "status": "selected_fallback_first_dimension",
+            "dimension": fallback_dimension,
+            "reason": "no_candidate_met_threshold_but_single_dimension_view_is_lightweight",
+            "candidates": candidates,
+        }
+    return {
+        "status": "selected_ranked_candidate",
+        "dimension": best["dimension"],
+        "reason": (
+            "highest score from business-readability, cardinality, and total "
+            "variance spread heuristic"
+        ),
+        "candidates": candidates,
+    }
+
+
+def select_exploded_variance_bridge_dimensions(
+    result: pl.DataFrame,
+    recipe: dict[str, Any],
+    *,
+    fallback_parent_dimension: str | None = None,
+) -> dict[str, Any]:
+    """Choose parent and child dimensions for the exploded bridge."""
+
+    options = recipe.get("options") or {}
+    mappings = recipe.get("mappings") or {}
+    dimensions = [
+        str(column)
+        for column in mappings.get("dimensions") or []
+        if str(column) in result.schema
+    ]
+    if len(dimensions) < 2:
+        return {
+            "status": "not_selected_insufficient_dimensions",
+            "parent_dimension": None,
+            "child_dimension": None,
+            "reason": "exploded_variance_bridge_requires_two_dimensions",
+        }
+
+    explicit_parent = options.get("exploded_variance_bridge_parent_dimension")
+    parent_dimension = (
+        str(explicit_parent)
+        if explicit_parent
+        else fallback_parent_dimension
+        or options.get("total_by_dimension_bridge_dimension")
+    )
+    if parent_dimension:
+        parent_dimension = str(parent_dimension)
+        if parent_dimension not in result.schema:
+            return {
+                "status": "not_selected_missing_parent_dimension",
+                "parent_dimension": None,
+                "child_dimension": None,
+                "reason": "configured_parent_dimension_missing",
+            }
+    else:
+        parent_selection = select_total_by_dimension_bridge_dimension(result, recipe)
+        parent_dimension = parent_selection.get("dimension")
+        if not parent_dimension:
+            return {
+                "status": "not_selected_no_parent_dimension",
+                "parent_dimension": None,
+                "child_dimension": None,
+                "reason": parent_selection.get("reason"),
+                "parent_selection": parent_selection,
+            }
+
+    explicit_child = options.get("exploded_variance_bridge_child_dimension")
+    if explicit_child:
+        child_dimension = str(explicit_child)
+        if child_dimension not in result.schema:
+            return {
+                "status": "not_selected_missing_child_dimension",
+                "parent_dimension": parent_dimension,
+                "child_dimension": None,
+                "reason": "configured_child_dimension_missing",
+            }
+        if child_dimension == parent_dimension:
+            return {
+                "status": "not_selected_child_matches_parent",
+                "parent_dimension": parent_dimension,
+                "child_dimension": None,
+                "reason": "parent_and_child_dimensions_must_differ",
+            }
+        return {
+            "status": "selected_explicit",
+            "parent_dimension": parent_dimension,
+            "child_dimension": child_dimension,
+            "reason": "explicit_recipe_or_cli_dimensions",
+        }
+
+    for dimension in dimensions:
+        if dimension != parent_dimension:
+            return {
+                "status": "selected_parent_plus_next_dimension",
+                "parent_dimension": parent_dimension,
+                "child_dimension": dimension,
+                "reason": "parent_dimension_plus_first_other_mapped_dimension",
+            }
+    return {
+        "status": "not_selected_no_child_dimension",
+        "parent_dimension": parent_dimension,
+        "child_dimension": None,
+        "reason": "no_mapped_dimension_remaining_after_parent",
+    }
+
+
+def _numeric_column_sum(frame: pl.DataFrame, column: str) -> float:
+    """Return a stable numeric sum for a result column that may be absent."""
+
+    if frame.is_empty() or column not in frame.schema:
+        return 0.0
+    value = frame.select(pl.col(column).sum()).item()
+    return float(value or 0.0)
+
+
+def standard_variance_component_columns(
+    recipe: dict[str, Any],
+) -> list[tuple[str, str]]:
+    """Return standard variance components using the same labels as charts."""
+
+    if not recipe["mappings"].get("units_column"):
+        return [("Total variance", "total_delta")]
+    volume_label = "Units"
+    return [
+        (volume_label if label == "volume_or_units" else label, column)
+        for label, column in STANDARD_VARIANCE_COMPONENT_COLUMNS
+    ]
+
+
+def _small_multiples_panel_slices(
+    result: pl.DataFrame,
+    dimension: str,
+    *,
+    limit: int = SMALL_MULTIPLES_PANEL_LIMIT,
+) -> tuple[pl.DataFrame, list[dict[str, Any]], bool]:
+    """Return chart-aligned panel filters, including an Other member panel."""
+
+    working = result.with_columns(
+        pl.col(dimension)
+        .cast(pl.Utf8)
+        .fill_null(SMALL_MULTIPLES_NULL_LABEL)
+        .alias(SMALL_MULTIPLES_WORK_COLUMN)
+    )
+    ranked = (
+        working.group_by(SMALL_MULTIPLES_WORK_COLUMN)
+        .agg(pl.col("total_delta").abs().sum().alias("_abs_delta"))
+        .sort("_abs_delta", descending=True)
+    )
+    all_values = [str(value) for value in ranked[SMALL_MULTIPLES_WORK_COLUMN].to_list()]
+    selected_values = all_values[:limit]
+    include_other = len(all_values) > limit
+    if include_other:
+        selected_values = all_values[: max(1, limit - 1)]
+
+    panels = [
+        {
+            "panel_number": index + 1,
+            "dimension_value": value,
+            "panel_type": "member",
+            "selected_values": [value],
+        }
+        for index, value in enumerate(selected_values)
+    ]
+    if include_other:
+        panels.append(
+            {
+                "panel_number": len(panels) + 1,
+                "dimension_value": SMALL_MULTIPLES_OTHER_LABEL,
+                "panel_type": "other_members",
+                "selected_values": [
+                    value for value in all_values if value not in selected_values
+                ],
+            }
+        )
+    return working, panels, include_other
+
+
+def _small_multiples_panel_frame(
+    working: pl.DataFrame,
+    panel: dict[str, Any],
+) -> pl.DataFrame:
+    """Return the result rows included in one small-multiples panel."""
+
+    selected_values = [str(value) for value in panel["selected_values"]]
+    if panel["panel_type"] == "other_members":
+        return working.filter(
+            pl.col(SMALL_MULTIPLES_WORK_COLUMN).is_in(selected_values)
+        )
+    return working.filter(pl.col(SMALL_MULTIPLES_WORK_COLUMN) == selected_values[0])
+
+
+def _panel_component_values(
+    panel_frame: pl.DataFrame,
+    recipe: dict[str, Any],
+) -> tuple[list[dict[str, Any]], dict[str, float]]:
+    """Return component rows and aggregate totals for one panel."""
+
+    amount_baseline = _numeric_column_sum(panel_frame, "amount_baseline")
+    amount_comparison = _numeric_column_sum(panel_frame, "amount_comparison")
+    total_delta = _numeric_column_sum(panel_frame, "total_delta")
+    if recipe["mappings"].get("units_column"):
+        unit_mix_label = "Units & mix"
+        components = [
+            {
+                "variance_type": "Price",
+                "variance_amount": _numeric_column_sum(panel_frame, "price_variance"),
+                "is_residual_other": False,
+                "is_residual_balance": False,
+                "displayed_in_chart": True,
+            },
+            {
+                "variance_type": unit_mix_label,
+                "variance_amount": _numeric_column_sum(panel_frame, "volume_variance")
+                + _numeric_column_sum(panel_frame, "mix_variance"),
+                "is_residual_other": False,
+                "is_residual_balance": False,
+                "displayed_in_chart": True,
+            },
+        ]
+    else:
+        components = [
+            {
+                "variance_type": "Total variance",
+                "variance_amount": total_delta,
+                "is_residual_other": False,
+                "is_residual_balance": False,
+                "displayed_in_chart": True,
+            }
+        ]
+    component_sum = sum(item["variance_amount"] for item in components)
+    residual = total_delta - component_sum
+    components.append(
+        {
+            "variance_type": "Balance",
+            "variance_amount": residual,
+            "is_residual_other": True,
+            "is_residual_balance": True,
+            "displayed_in_chart": abs(residual) > TOLERANCE,
+        }
+    )
+    return components, {
+        "amount_baseline": amount_baseline,
+        "amount_comparison": amount_comparison,
+        "total_delta": total_delta,
+        "total_abs_delta": _numeric_column_sum(
+            panel_frame.with_columns(pl.col("total_delta").abs().alias("_abs_delta")),
+            "_abs_delta",
+        ),
+        "component_sum": component_sum,
+        "other_residual": residual,
+    }
+
+
+def _dominant_component(components: list[dict[str, Any]]) -> dict[str, Any]:
+    """Return the largest component by absolute amount."""
+
+    if not components:
+        return {"variance_type": "", "variance_amount": 0.0}
+    return max(components, key=lambda item: abs(float(item["variance_amount"] or 0.0)))
+
+
+def _output_language(value: object | None) -> str:
+    text = str(value or "en").strip().lower().replace("_", "-")
+    return "es" if text.split("-", 1)[0] == "es" else "en"
+
+
+def _small_multiples_summary_markdown(context: dict[str, Any]) -> str:
+    """Return a markdown chart-data block for Codex's business interpretation."""
+
+    if context.get("status") != "written":
+        return ""
+    spanish = _output_language(context.get("language")) == "es"
+    lines = [
+        "",
+        (
+            "## Múltiples gráficos de variaciones estándar"
+            if spanish
+            else "## Standard Variance Small Multiples"
+        ),
+        "",
+        f"- {'Dimensión' if spanish else 'Dimension'}: `{context.get('dimension')}`",
+        f"- {'Número de paneles' if spanish else 'Panel count'}: `{context.get('panel_count')}`",
+        f"- {'Panel de Otros' if spanish else 'Other member panel'}: `{context.get('has_other_member_panel')}`",
+        f"- {'Componente Saldo residual' if spanish else 'Any residual Balance component'}: `{context.get('has_residual_balance_component')}`",
+        f"- {'Archivos fuente' if spanish else 'Source files'}: `waterfall_small_multiples.png`, "
+        "`waterfall_small_multiples_summary.csv`, "
+        "`waterfall_small_multiples_context.json`",
+        "",
+        (
+            "Paneles principales por variación absoluta:"
+            if spanish
+            else "Top panels by absolute variance:"
+        ),
+    ]
+    for panel in context.get("panels", [])[:6]:
+        dominant = panel.get("dominant_component") or {}
+        lines.append(
+            "- "
+            f"{panel.get('dimension_value')}: total_delta="
+            f"{float(panel.get('total_delta') or 0.0):,.2f}; "
+            f"dominant={dominant.get('variance_type')} "
+            f"{float(dominant.get('variance_amount') or 0.0):,.2f}"
+        )
+    lines.extend(
+        [
+            "",
+            (
+                "Codex debe utilizar estos datos fuente para explicar si la variación estándar se concentra en elementos concretos o se distribuye por la dimensión seleccionada."
+                if spanish
+                else "Codex must use this source data when explaining whether the standard variance story is concentrated in specific dimension members or spread across the selected dimension."
+            ),
+        ]
+    )
+    return "\n".join(lines) + "\n"
+
+
+def write_waterfall_small_multiples_chart_data(
+    result: pl.DataFrame,
+    recipe: dict[str, Any],
+    output_dir: Path,
+) -> tuple[list[str], dict[str, Any], str]:
+    """Write data context for the standard-variance small-multiples chart."""
+
+    options = recipe.get("options") or {}
+    if not bool(options.get("waterfall_chart", True)):
+        return [], {"enabled": False, "status": "disabled_waterfall_chart"}, ""
+    if not bool(options.get("waterfall_small_multiples", False)):
+        return [], {"enabled": False, "status": "disabled_no_selected_dimension"}, ""
+    dimension = options.get("waterfall_small_multiples_dimension")
+    if not dimension or str(dimension) not in result.schema:
+        return (
+            [],
+            {
+                "enabled": True,
+                "status": "not_written_no_dimension",
+                "dimension": str(dimension or ""),
+            },
+            "",
+        )
+
+    dimension = str(dimension)
+    working, panel_specs, has_other_member_panel = _small_multiples_panel_slices(
+        result,
+        dimension,
+    )
+    if not panel_specs:
+        return (
+            [],
+            {
+                "enabled": True,
+                "status": "not_written_no_panel_values",
+                "dimension": dimension,
+            },
+            "",
+        )
+
+    rows: list[dict[str, Any]] = []
+    panels: list[dict[str, Any]] = []
+    total_abs_delta = _numeric_column_sum(
+        working.with_columns(pl.col("total_delta").abs().alias("_abs_delta")),
+        "_abs_delta",
+    )
+    has_residual_balance_component = False
+    for panel in panel_specs:
+        panel_frame = _small_multiples_panel_frame(working, panel)
+        components, totals = _panel_component_values(panel_frame, recipe)
+        dominant = _dominant_component(components)
+        has_residual_balance_component = (
+            has_residual_balance_component or abs(totals["other_residual"]) > TOLERANCE
+        )
+        included_member_count = len(panel["selected_values"])
+        panel_payload = {
+            "panel_number": panel["panel_number"],
+            "dimension": dimension,
+            "dimension_value": panel["dimension_value"],
+            "panel_type": panel["panel_type"],
+            "included_member_count": included_member_count,
+            "source_result_rows": panel_frame.height,
+            "amount_baseline": totals["amount_baseline"],
+            "amount_comparison": totals["amount_comparison"],
+            "total_delta": totals["total_delta"],
+            "total_abs_delta": totals["total_abs_delta"],
+            "share_of_all_panel_abs_delta": (
+                totals["total_abs_delta"] / total_abs_delta if total_abs_delta else 0.0
+            ),
+            "other_residual": totals["other_residual"],
+            "dominant_component": {
+                "variance_type": dominant.get("variance_type"),
+                "variance_amount": dominant.get("variance_amount"),
+            },
+            "components": components,
+        }
+        panels.append(panel_payload)
+        abs_component_total = sum(
+            abs(float(component["variance_amount"] or 0.0)) for component in components
+        )
+        for component in components:
+            amount = float(component["variance_amount"] or 0.0)
+            rows.append(
+                {
+                    "panel_number": panel["panel_number"],
+                    "dimension": dimension,
+                    "dimension_value": panel["dimension_value"],
+                    "panel_type": panel["panel_type"],
+                    "included_member_count": included_member_count,
+                    "source_result_rows": panel_frame.height,
+                    "amount_baseline": totals["amount_baseline"],
+                    "amount_comparison": totals["amount_comparison"],
+                    "total_delta": totals["total_delta"],
+                    "total_abs_delta": totals["total_abs_delta"],
+                    "share_of_all_panel_abs_delta": (
+                        totals["total_abs_delta"] / total_abs_delta
+                        if total_abs_delta
+                        else 0.0
+                    ),
+                    "variance_type": component["variance_type"],
+                    "variance_amount": amount,
+                    "share_of_panel_abs_components": (
+                        abs(amount) / abs_component_total
+                        if abs_component_total
+                        else 0.0
+                    ),
+                    "is_residual_other": component["is_residual_other"],
+                    "is_residual_balance": component.get(
+                        "is_residual_balance",
+                        False,
+                    ),
+                    "displayed_in_chart": component["displayed_in_chart"],
+                }
+            )
+
+    panels.sort(key=lambda item: abs(float(item["total_delta"] or 0.0)), reverse=True)
+    summary_path = output_dir / "waterfall_small_multiples_summary.csv"
+    context_path = output_dir / "waterfall_small_multiples_context.json"
+    pl.DataFrame(rows).write_csv(summary_path)
+    context = {
+        "analysis_type": "standard_variance_small_multiples",
+        "status": "written",
+        "language": _output_language(recipe.get("language")),
+        "dimension": dimension,
+        "panel_limit": SMALL_MULTIPLES_PANEL_LIMIT,
+        "panel_count": len(panel_specs),
+        "has_other_member_panel": has_other_member_panel,
+        "has_residual_other_component": has_residual_balance_component,
+        "has_residual_balance_component": has_residual_balance_component,
+        "chart_component_mode": "legacy_price_units_mix_balance",
+        "chart_artifact": "waterfall_small_multiples.png",
+        "summary_csv": summary_path.name,
+        "context_json": context_path.name,
+        "selection": options.get("waterfall_small_multiples_dimension_selection"),
+        **_title_contract_payload(
+            recipe,
+            chart_kind="standard_small_multiples",
+            dimension=str(dimension),
+        ),
+        "codex_interpretation_contract": {
+            "must_review_when_written": True,
+            "required_points": [
+                "Use panel labels and values to explain concentration or spread by dimension member.",
+                "Explain the dominant variance type within the largest panels.",
+                "Call out the Others aggregated member panel when it exists.",
+                "Call out residual Balance components when they are material.",
+                "Do not treat panel members as additional bridge rows; each panel repeats the same standard variance bridge.",
+            ],
+        },
+        "panels": panels,
+    }
+    write_json(context_path, context)
+    audit = {
+        "enabled": True,
+        "status": "written",
+        "dimension": dimension,
+        "summary_csv": summary_path.name,
+        "context_json": context_path.name,
+        "panel_count": len(panel_specs),
+        "has_other_member_panel": has_other_member_panel,
+        "has_residual_other_component": has_residual_balance_component,
+        "has_residual_balance_component": has_residual_balance_component,
+        "chart_component_mode": "legacy_price_units_mix_balance",
+    }
+    return (
+        [str(summary_path), str(context_path)],
+        audit,
+        _small_multiples_summary_markdown(context),
+    )
+
+
+def suggested_calculation_grain(
+    candidates: list[str], dimensions: list[str]
+) -> list[str]:
+    """Return lower-level PVM grain when product or customer columns exist."""
+
+    selected: list[str] = []
+    normalized = [(column, normalize_name(column)) for column in candidates]
+    for hint in CALCULATION_GRAIN_NAME_PRIORITY:
+        normalized_hint = normalize_name(hint)
+        for column, normalized_name in normalized:
+            if normalized_name == normalized_hint and column not in selected:
+                selected.append(column)
+    return selected or dimensions
+
+
+def infer_mappings(df: pl.DataFrame) -> dict[str, Any]:
+    """Infer a suggested recipe mapping from column names and dtypes."""
+
+    columns, _schema = get_schema_and_column_names(df)
+    mapping: dict[str, Any] = {}
+    for key, hints in COLUMN_HINTS.items():
+        mapping[key] = first_matching_column(columns, hints)
+    mapping["date_column"] = suggested_date_column(df, columns)
+    mapping["period_column"] = (
+        plan_actual_scenario_column(df, columns) or mapping["period_column"]
+    )
+
+    schema = df.schema
+    period_col = mapping["period_column"]
+    metric_cols = {
+        value
+        for value in (
+            mapping["amount_column"],
+            mapping["units_column"],
+            mapping["discount_column"],
+            mapping["cogs_column"],
+            mapping["date_column"],
+            period_col,
+        )
+        if value
+    }
+    dimension_candidates = [
+        column
+        for column in columns
+        if column not in metric_cols
+        and not is_numeric_dtype(schema[column])
+        and not is_temporal_dtype(schema[column])
+    ]
+    if not dimension_candidates:
+        dimension_candidates = [
+            column
+            for column in columns
+            if column not in metric_cols and column != period_col
+        ][:2]
+    dimensions = ranked_dimension_candidates(dimension_candidates)[:4]
+    mapping["dimensions"] = dimensions
+    mapping["calculation_grain"] = suggested_calculation_grain(
+        dimension_candidates, dimensions
+    )
+    return mapping
+
+
+def period_values(df: pl.DataFrame, period_col: str | None) -> list[str]:
+    """Return sorted non-null period values as strings."""
+
+    if not period_col or period_col not in df.schema:
+        return []
+    values = (
+        df.select(pl.col(period_col).cast(pl.Utf8).drop_nulls().unique().sort())
+        .to_series(0)
+        .to_list()
+    )
+    return [str(value) for value in values]
+
+
+def suggested_period_pair(
+    df: pl.DataFrame, period_col: str | None, periods: list[str]
+) -> tuple[str | None, str | None]:
+    """Return suggested baseline and comparison period values."""
+
+    if is_scenario_comparison_column(df, period_col):
+        return default_scenario_comparison_pair(periods)
+    return (
+        periods[0] if len(periods) >= 1 else None,
+        periods[1] if len(periods) >= 2 else None,
+    )
+
+
+def suggested_comparison_options(
+    df: pl.DataFrame, period_col: str | None
+) -> dict[str, str]:
+    """Return advisory comparison metadata for Codex intake and review."""
+
+    if is_scenario_comparison_column(df, period_col):
+        return {
+            "comparison_basis": COMPARISON_BASIS_SCENARIO,
+            "period_comparison_mode": PERIOD_MODE_NOT_APPLICABLE,
+        }
+    return {
+        "comparison_basis": COMPARISON_BASIS_PERIOD,
+        "period_comparison_mode": PERIOD_MODE_CALENDAR,
+    }
+
+
+def legacy_period_mode_from_period_type(period_type: str) -> str:
+    """Return the legacy variance period mode for a normalized period type."""
+
+    if period_type == PERIOD_TYPE_ROLLING:
+        return PERIOD_MODE_ROLLING
+    if period_type in {PERIOD_TYPE_TO_DATE, PERIOD_TYPE_FISCAL}:
+        return PERIOD_MODE_YEAR_TO_DATE
+    if period_type == PERIOD_TYPE_CUSTOM:
+        return PERIOD_MODE_CUSTOM
+    return PERIOD_MODE_CALENDAR
+
+
+def build_recipe(
+    source_path: Path,
+    df: pl.DataFrame,
+    *,
+    language: str,
+    existing_recipe: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Build a suggested or merged variance recipe."""
+
+    mapping = infer_mappings(df)
+    periods = period_values(df, mapping["period_column"])
+    baseline_period, comparison_period = suggested_period_pair(
+        df, mapping["period_column"], periods
+    )
+    suggested_small_multiples_dimension = (
+        mapping["dimensions"][0] if len(mapping["dimensions"]) == 1 else None
+    )
+    suggested_comparison = suggested_comparison_options(df, mapping["period_column"])
+    suggested_period_contract = period_contract_options(
+        suggested_comparison,
+        default_type=(
+            PERIOD_TYPE_CUSTOM
+            if suggested_comparison["comparison_basis"] == COMPARISON_BASIS_SCENARIO
+            else "calendar"
+        ),
+    )
+    suggested = {
+        "schema_version": SCHEMA_VERSION,
+        "language": language,
+        "source_file": str(source_path),
+        "accounting_review": default_accounting_review(),
+        "mappings": {
+            "period_column": mapping["period_column"],
+            "baseline_period": baseline_period,
+            "comparison_period": comparison_period,
+            "amount_column": mapping["amount_column"],
+            "units_column": mapping["units_column"],
+            "discount_column": mapping["discount_column"],
+            "cogs_column": mapping["cogs_column"],
+            "date_column": mapping["date_column"],
+            "dimensions": mapping["dimensions"],
+            "calculation_grain": mapping["calculation_grain"],
+        },
+        "options": {
+            **suggested_comparison,
+            **suggested_period_contract,
+            "currency": "EUR",
+            "unit_label": "units",
+            "root_cause_bridge": True,
+            "root_cause_bridge_alternative_result": 1,
+            "root_cause_bridge_drilldown_rows": [],
+            "root_cause_bridge_drilldown_all": False,
+            "root_cause_bridge_move_rows": {},
+            "root_cause_bridge_alternative_sweep": True,
+            "root_cause_bridge_alternative_sweep_start": 1,
+            "root_cause_bridge_alternative_sweep_end": 10,
+            "root_cause_bridge_auto_drilldown": "all_selected",
+            "root_cause_bridge_auto_drilldown_min_share": 0.75,
+            "root_cause_component_bridge": False,
+            "root_cause_component_bridge_alternative_result": 1,
+            "waterfall_chart": True,
+            "pvm_decomposition_ladder": True,
+            "waterfall_small_multiples": bool(mapping["dimensions"]),
+            "waterfall_small_multiples_dimension": suggested_small_multiples_dimension,
+            "total_by_dimension_bridge": bool(mapping["dimensions"]),
+            "total_by_dimension_bridge_dimension": None,
+            "total_by_dimension_bridge_top_n": TOTAL_BY_DIMENSION_DEFAULT_TOP_N,
+            "exploded_variance_bridge": len(mapping["dimensions"]) >= 2,
+            "exploded_variance_bridge_parent_dimension": None,
+            "exploded_variance_bridge_child_dimension": None,
+            "exploded_variance_bridge_parent_top_n": TOTAL_BY_DIMENSION_DEFAULT_TOP_N,
+            "exploded_variance_bridge_child_top_n": EXPLODED_BRIDGE_DEFAULT_CHILD_TOP_N,
+            "exploded_variance_bridge_max_drilldowns": (
+                EXPLODED_BRIDGE_DEFAULT_MAX_DRILLDOWNS
+            ),
+        },
+    }
+    if not existing_recipe:
+        return suggested
+
+    merged = dict(suggested)
+    merged.update(
+        {k: v for k, v in existing_recipe.items() if k not in {"mappings", "options"}}
+    )
+    merged["mappings"] = {
+        **suggested["mappings"],
+        **existing_recipe.get("mappings", {}),
+    }
+    merged["options"] = {**suggested["options"], **existing_recipe.get("options", {})}
+    merged["accounting_review"] = normalize_accounting_review(
+        existing_recipe.get("accounting_review")
+    )
+    return merged
+
+
+def _source_reference(
+    input_path: Path,
+    client_engagement: dict[str, Any] | None,
+) -> str:
+    """Return an unmanaged path or a portable managed-run source reference."""
+
+    if client_engagement is None:
+        return input_path.as_posix()
+    run_root = Path(str(client_engagement["run_root"])).resolve(strict=True)
+    try:
+        return input_path.resolve(strict=True).relative_to(run_root).as_posix()
+    except ValueError as exc:
+        raise ValueError("Variance input is outside the managed run.") from exc
+
+
+def inspect_variance_inputs(
+    input_path: Path,
+    output_dir: Path,
+    recipe_path: Path | None = None,
+    *,
+    language: str = "en",
+    client_engagement: dict[str, Any] | None = None,
+) -> InspectionResult:
+    """Inspect a variance input file and write inspection and recipe JSON."""
+
+    if is_vera_managed_host() and client_engagement is None:
+        raise ValueError(
+            "The Vera-packaged variance inspector requires --client-engagement."
+        )
+    df = read_table(input_path)
+    columns, schema = get_schema_and_column_names(df)
+    existing_recipe = load_json(recipe_path) if recipe_path else None
+    recipe = build_recipe(
+        input_path, df, language=language, existing_recipe=existing_recipe
+    )
+    mappings = recipe["mappings"]
+    candidate_columns = list(
+        dict.fromkeys(
+            value
+            for value in (
+                mappings.get("period_column"),
+                mappings.get("amount_column"),
+                mappings.get("units_column"),
+                mappings.get("discount_column"),
+                mappings.get("cogs_column"),
+                mappings.get("date_column"),
+                *(mappings.get("dimensions") or []),
+                *(mappings.get("calculation_grain") or []),
+            )
+            if isinstance(value, str) and value in columns
+        )
+    )
+    source_file = _source_reference(input_path, client_engagement)
+    if client_engagement is not None:
+        recipe["source_file"] = source_file
+    payload = {
+        "schema_version": SCHEMA_VERSION,
+        **(
+            {"path_reference": "run_root_relative"}
+            if client_engagement is not None
+            else {}
+        ),
+        "generated_at": utc_now(),
+        "language": language,
+        "source_file": source_file,
+        "row_count": df.height,
+        "columns": [{"name": column, "dtype": schema[column]} for column in columns],
+        "available_analysis_context": available_analysis_context(df),
+        "period_values": period_values(df, mappings.get("period_column")),
+        "suggested_mappings": mappings,
+        "sampled_columns": candidate_columns,
+        "omitted_sample_columns": [
+            column for column in columns if column not in candidate_columns
+        ],
+        "sample_row_limit": 10,
+        "sample_behavior": "first_rows_candidate_columns_only",
+        "sample_rows": df.select(candidate_columns).head(10).to_dicts(),
+        "warnings": inspection_warnings(df, mappings),
+    }
+    warn_if_output_dir_has_existing_files(output_dir, "Inspection")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    write_json(output_dir / "inspection.json", payload)
+    write_json(output_dir / "suggested_recipe.json", recipe)
+    return InspectionResult(payload=payload, recipe=recipe)
+
+
+def inspection_warnings(df: pl.DataFrame, mappings: dict[str, Any]) -> list[str]:
+    """Return deterministic warnings about missing or incomplete mappings."""
+
+    warnings: list[str] = []
+    required = {
+        "period_column": "Period column is required.",
+        "baseline_period": "Baseline period is required.",
+        "comparison_period": "Comparison period is required.",
+        "amount_column": "Amount/sales column is required.",
+    }
+    for key, message in required.items():
+        if not mappings.get(key):
+            warnings.append(message)
+    columns, _schema = get_schema_and_column_names(df)
+    for key in (
+        "period_column",
+        "amount_column",
+        "units_column",
+        "discount_column",
+        "cogs_column",
+        "date_column",
+    ):
+        value = mappings.get(key)
+        if value and value not in columns:
+            warnings.append(f"Mapped {key} does not exist in input columns: {value}")
+    for dimension in mappings.get("dimensions") or []:
+        if dimension not in columns:
+            warnings.append(
+                f"Mapped dimension does not exist in input columns: {dimension}"
+            )
+    return warnings
+
+
+def parsed_date_expression(column: str) -> pl.Expr:
+    """Return a date expression for common sales-export date representations."""
+
+    text = pl.col(column).cast(pl.Utf8)
+    return pl.coalesce(
+        [
+            text.str.to_datetime("%Y-%m-%d %H:%M:%S%.f", strict=False).dt.date(),
+            text.str.to_datetime("%Y-%m-%dT%H:%M:%S%.f", strict=False).dt.date(),
+            text.str.strptime(pl.Date, "%Y-%m-%d", strict=False),
+            text.str.strptime(pl.Date, "%Y/%m/%d", strict=False),
+            text.str.strptime(pl.Date, "%d/%m/%Y", strict=False),
+            text.str.strptime(pl.Date, "%m/%d/%Y", strict=False),
+            text.str.strptime(pl.Date, "%Y-%m", strict=False),
+            text.str.strptime(pl.Date, "%b-%Y", strict=False),
+        ]
+    )
+
+
+def as_date(value: Any) -> date:
+    """Return a Python date from legacy or Polars date values."""
+
+    if isinstance(value, datetime):
+        return value.date()
+    if isinstance(value, date):
+        return value
+    raise ValueError(f"Expected a date value, got {value!r}")
+
+
+def add_months(value: date, months: int) -> date:
+    """Shift a date by whole months, preserving the closest valid day."""
+
+    month_index = value.month - 1 + months
+    year = value.year + month_index // 12
+    month = month_index % 12 + 1
+    day = min(value.day, calendar.monthrange(year, month)[1])
+    return date(year, month, day)
+
+
+def fiscal_year_start_for(value: date, fiscal_start_month: int) -> date:
+    """Return the fiscal/calendar year start for a cutoff date."""
+
+    year = value.year if value.month >= fiscal_start_month else value.year - 1
+    return date(year, fiscal_start_month, 1)
+
+
+def int_option(options: dict[str, Any], key: str, default: int) -> int:
+    """Return a positive integer option with a conservative fallback."""
+
+    try:
+        value = int(options.get(key, default))
+    except (TypeError, ValueError):
+        value = default
+    return value if value > 0 else default
+
+
+def rolling_window_length_options(
+    options: dict[str, Any], period_grain: str
+) -> dict[str, int]:
+    """Return a rolling window length from explicit options or period grain.
+
+    This rule is deterministic because the grain-to-window mapping is mechanical:
+    week=7 days, month=1 month, quarter=3 months, year=12 months.
+    """
+
+    if options.get("rolling_window_days") is not None:
+        return {"days": int_option(options, "rolling_window_days", 7)}
+    if options.get("rolling_window_months") is not None:
+        return {"months": int_option(options, "rolling_window_months", 12)}
+    if period_grain == PERIOD_GRAIN_WEEK:
+        return {"days": 7}
+    if period_grain == PERIOD_GRAIN_MONTH:
+        return {"months": 1}
+    if period_grain == PERIOD_GRAIN_QUARTER:
+        return {"months": 3}
+    if period_grain == PERIOD_GRAIN_YEAR:
+        return {"months": 12}
+    return {"months": 12}
+
+
+def bounded_int_option(
+    options: dict[str, Any], key: str, default: int, *, minimum: int, maximum: int
+) -> int:
+    """Return an integer option clamped to an inclusive range."""
+
+    value = int_option(options, key, default)
+    return min(max(value, minimum), maximum)
+
+
+def bounded_float_option(
+    options: dict[str, Any], key: str, default: float, *, minimum: float, maximum: float
+) -> float:
+    """Return a float option clamped to an inclusive range."""
+
+    try:
+        value = float(options.get(key, default))
+    except (TypeError, ValueError):
+        value = default
+    return min(max(value, minimum), maximum)
+
+
+def positive_int_list_option(options: dict[str, Any], key: str) -> list[int]:
+    """Return unique positive integers from an option list."""
+
+    raw_value = options.get(key, [])
+    if raw_value is None:
+        return []
+    values = raw_value if isinstance(raw_value, list) else [raw_value]
+    result: list[int] = []
+    for value in values:
+        try:
+            parsed = int(value)
+        except (TypeError, ValueError):
+            continue
+        if parsed > 0 and parsed not in result:
+            result.append(parsed)
+    return result
+
+
+def move_rows_option(options: dict[str, Any], key: str) -> dict[str, list[int]]:
+    """Return normalized legacy move-row mappings with string keys."""
+
+    raw_value = options.get(key, {})
+    if not isinstance(raw_value, dict):
+        return {}
+    result: dict[str, list[int]] = {}
+    for main_row, drilldown_rows in raw_value.items():
+        try:
+            parsed_main = int(main_row)
+        except (TypeError, ValueError):
+            continue
+        if parsed_main <= 0:
+            continue
+        values = (
+            drilldown_rows if isinstance(drilldown_rows, list) else [drilldown_rows]
+        )
+        parsed_rows: list[int] = []
+        for row in values:
+            try:
+                parsed_row = int(row)
+            except (TypeError, ValueError):
+                continue
+            if parsed_row > 0 and parsed_row not in parsed_rows:
+                parsed_rows.append(parsed_row)
+        if parsed_rows:
+            result[str(parsed_main)] = parsed_rows
+    return result
+
+
+def root_cause_auto_drilldown_option(options: dict[str, Any]) -> str:
+    """Return a supported automatic root-cause drilldown mode."""
+
+    mode = (
+        str(options.get("root_cause_bridge_auto_drilldown") or "none")
+        .strip()
+        .lower()
+        .replace("-", "_")
+    )
+    return mode if mode in ROOT_CAUSE_AUTO_DRILLDOWN_VALUES else "none"
+
+
+def between_dates(column: str, start: date, end: date) -> pl.Expr:
+    """Return an inclusive date-window predicate."""
+
+    return (pl.col(column) >= pl.lit(start)) & (pl.col(column) <= pl.lit(end))
+
+
+def period_window_metadata(
+    *,
+    mode: str,
+    date_column: str,
+    baseline_label: str,
+    baseline_start: date,
+    baseline_end: date,
+    comparison_label: str,
+    comparison_start: date,
+    comparison_end: date,
+    legacy_context: dict[str, Any],
+    extra: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Build an auditable period-window payload for the used recipe."""
+
+    payload = {
+        "mode": mode,
+        "date_column": date_column,
+        "source": "legacy_date_period_context",
+        "most_recent_date": as_date(legacy_context["most_recent_date"]),
+        "least_recent_date": as_date(legacy_context["least_recent_date"]),
+        "period_length_months": legacy_context["period_length_months"],
+        "baseline": {
+            "label": baseline_label,
+            "start_date": baseline_start,
+            "end_date": baseline_end,
+        },
+        "comparison": {
+            "label": comparison_label,
+            "start_date": comparison_start,
+            "end_date": comparison_end,
+        },
+    }
+    if extra:
+        payload.update(extra)
+    return payload
+
+
+def prepare_period_comparison_buckets(
+    df: pl.DataFrame,
+    recipe: dict[str, Any],
+) -> tuple[pl.DataFrame, dict[str, Any]]:
+    """Create legacy-backed YTD/rolling buckets before variance arithmetic.
+
+    This deterministic step is justified because date-window boundaries are
+    mechanically verifiable and must be reproducible for audit review.
+    """
+
+    options = dict(recipe.get("options") or {})
+    normalized_period_contract = period_contract_options(options)
+    if options.get("period_type") and options.get("period_comparison_mode") in {
+        None,
+        PERIOD_MODE_CALENDAR,
+    }:
+        mode = legacy_period_mode_from_period_type(
+            str(normalized_period_contract["period_type"])
+        )
+    elif options.get("period_comparison_mode"):
+        mode = str(options.get("period_comparison_mode"))
+        if mode not in PERIOD_COMPARISON_MODE_VALUES:
+            mode = legacy_period_mode_from_period_type(
+                str(normalized_period_contract["period_type"])
+            )
+    else:
+        mode = legacy_period_mode_from_period_type(
+            str(normalized_period_contract["period_type"])
+        )
+    if mode not in {PERIOD_MODE_YEAR_TO_DATE, PERIOD_MODE_ROLLING}:
+        return df, recipe
+
+    mappings = dict(recipe["mappings"])
+    date_column = mappings.get("date_column") or mappings.get("period_column")
+    if not date_column or date_column not in df.schema:
+        raise ValueError(
+            "A date_column mapping is required for year-to-date or rolling periods."
+        )
+
+    prepared = df.with_columns(
+        parsed_date_expression(date_column).alias(DATE_WORK_COLUMN)
+    )
+    valid_date_rows = prepared.filter(pl.col(DATE_WORK_COLUMN).is_not_null())
+    if valid_date_rows.is_empty():
+        raise ValueError(
+            f"Could not parse any dates from mapped date column: {date_column}"
+        )
+
+    legacy_context = legacy_date_period_context(valid_date_rows, DATE_WORK_COLUMN)
+    comparison_end = as_date(legacy_context["most_recent_date"])
+    period_specific_options: dict[str, Any] = {}
+
+    if mode == PERIOD_MODE_YEAR_TO_DATE:
+        fiscal_start_month = int_option(options, "fiscal_start_month", 1)
+        if fiscal_start_month > 12:
+            fiscal_start_month = 1
+        comparison_start = fiscal_year_start_for(comparison_end, fiscal_start_month)
+        baseline_start = add_months(comparison_start, -12)
+        baseline_end = add_months(comparison_end, -12)
+        baseline_label = str(legacy_context["ytd_baseline_label"])
+        comparison_label = str(legacy_context["ytd_label"])
+        period_window = period_window_metadata(
+            mode=mode,
+            date_column=date_column,
+            baseline_label=baseline_label,
+            baseline_start=baseline_start,
+            baseline_end=baseline_end,
+            comparison_label=comparison_label,
+            comparison_start=comparison_start,
+            comparison_end=comparison_end,
+            legacy_context=legacy_context,
+            extra={"fiscal_start_month": fiscal_start_month},
+        )
+    else:
+        window_length = rolling_window_length_options(
+            options, str(normalized_period_contract["period_grain"])
+        )
+        rolling_comparison = str(
+            options.get("rolling_comparison") or ROLLING_COMPARISON_PRIOR_YEAR
+        )
+        if rolling_comparison not in ROLLING_COMPARISON_VALUES:
+            rolling_comparison = ROLLING_COMPARISON_PRIOR_YEAR
+        if "days" in window_length:
+            window_days = window_length["days"]
+            comparison_start = comparison_end - timedelta(days=window_days - 1)
+            if rolling_comparison == ROLLING_COMPARISON_PREVIOUS_WINDOW:
+                baseline_end = comparison_start - timedelta(days=1)
+                baseline_start = baseline_end - timedelta(days=window_days - 1)
+                baseline_label = (
+                    f"previous_{window_days}d_"
+                    f"{baseline_start.isoformat()}_{baseline_end.isoformat()}"
+                )
+            else:
+                baseline_end = add_months(comparison_end, -12)
+                baseline_start = baseline_end - timedelta(days=window_days - 1)
+                baseline_label = (
+                    f"prior_year_{window_days}d_"
+                    f"{baseline_start.isoformat()}_{baseline_end.isoformat()}"
+                )
+            comparison_label = (
+                f"rolling_{window_days}d_"
+                f"{comparison_start.isoformat()}_{comparison_end.isoformat()}"
+            )
+            rolling_extra = {
+                "rolling_window_days": window_days,
+                "rolling_comparison": rolling_comparison,
+            }
+        else:
+            window_months = window_length["months"]
+            comparison_start = add_months(comparison_end, -(window_months - 1)).replace(
+                day=1
+            )
+            if rolling_comparison == ROLLING_COMPARISON_PREVIOUS_WINDOW:
+                baseline_start = add_months(comparison_start, -window_months)
+                baseline_end = comparison_start - timedelta(days=1)
+                baseline_label = (
+                    f"previous_{window_months}m_"
+                    f"{baseline_start.isoformat()}_{baseline_end.isoformat()}"
+                )
+            else:
+                baseline_start = add_months(comparison_start, -12)
+                baseline_end = add_months(comparison_end, -12)
+                baseline_label = str(legacy_context["rolling_baseline_label"])
+            comparison_label = str(legacy_context["rolling_label"])
+            rolling_extra = {
+                "rolling_window_months": window_months,
+                "rolling_comparison": rolling_comparison,
+            }
+        period_specific_options = rolling_extra
+        period_window = period_window_metadata(
+            mode=mode,
+            date_column=date_column,
+            baseline_label=baseline_label,
+            baseline_start=baseline_start,
+            baseline_end=baseline_end,
+            comparison_label=comparison_label,
+            comparison_start=comparison_start,
+            comparison_end=comparison_end,
+            legacy_context=legacy_context,
+            extra=rolling_extra,
+        )
+
+    prepared = prepared.with_columns(
+        pl.when(between_dates(DATE_WORK_COLUMN, baseline_start, baseline_end))
+        .then(pl.lit(baseline_label))
+        .when(between_dates(DATE_WORK_COLUMN, comparison_start, comparison_end))
+        .then(pl.lit(comparison_label))
+        .otherwise(None)
+        .alias(SYNTHETIC_PERIOD_COLUMN)
+    ).drop(DATE_WORK_COLUMN)
+
+    bucket_counts = {
+        row[SYNTHETIC_PERIOD_COLUMN]: row["len"]
+        for row in prepared.group_by(SYNTHETIC_PERIOD_COLUMN)
+        .len()
+        .filter(pl.col(SYNTHETIC_PERIOD_COLUMN).is_not_null())
+        .to_dicts()
+    }
+    if not bucket_counts.get(baseline_label) or not bucket_counts.get(comparison_label):
+        raise ValueError(
+            "Prepared period windows do not contain both baseline and comparison rows."
+        )
+
+    mappings.update(
+        {
+            "period_column": SYNTHETIC_PERIOD_COLUMN,
+            "baseline_period": baseline_label,
+            "comparison_period": comparison_label,
+        }
+    )
+    options.update(
+        {
+            "comparison_basis": COMPARISON_BASIS_PERIOD,
+            "period_comparison_mode": mode,
+            "period_type": normalized_period_contract["period_type"],
+            "period_grain": normalized_period_contract["period_grain"],
+            "fiscal_start_month": (
+                fiscal_start_month
+                if mode == PERIOD_MODE_YEAR_TO_DATE
+                else normalized_period_contract["fiscal_start_month"]
+            ),
+            "period_window": {
+                **period_window,
+                "row_counts": bucket_counts,
+            },
+            **period_specific_options,
+        }
+    )
+    updated_recipe = {**recipe, "mappings": mappings, "options": options}
+    return prepared, updated_recipe
+
+
+def validate_recipe(df: pl.DataFrame, recipe: dict[str, Any]) -> dict[str, Any]:
+    """Validate and normalize the recipe used for deterministic calculations."""
+
+    mappings = dict(recipe.get("mappings") or {})
+    options = dict(recipe.get("options") or {})
+    columns, schema = get_schema_and_column_names(df)
+    required_keys = (
+        "period_column",
+        "baseline_period",
+        "comparison_period",
+        "amount_column",
+    )
+    missing = [key for key in required_keys if not mappings.get(key)]
+    if missing:
+        raise ValueError(f"Missing required recipe mappings: {', '.join(missing)}")
+    for key in (
+        "period_column",
+        "amount_column",
+        "units_column",
+        "discount_column",
+        "cogs_column",
+        "date_column",
+    ):
+        column = mappings.get(key)
+        if column and column not in columns:
+            raise ValueError(
+                f"Recipe mapping '{key}' references missing column '{column}'"
+            )
+    for key in ("amount_column", "units_column", "discount_column", "cogs_column"):
+        column = mappings.get(key)
+        if column and not is_numeric_dtype(df.schema[column]):
+            raise ValueError(
+                f"Recipe mapping '{key}' must be numeric: {column} ({schema[column]})"
+            )
+    dimensions = mappings.get("dimensions") or []
+    if not isinstance(dimensions, list):
+        raise ValueError("Recipe mapping 'dimensions' must be a list of column names.")
+    cohort_source_dimensions = recipe_cohort_source_dimensions(recipe)
+    missing_cohort_sources = [
+        column for column in cohort_source_dimensions if column not in columns
+    ]
+    if missing_cohort_sources:
+        raise ValueError(
+            "Recipe cohort source columns are missing: "
+            + ", ".join(missing_cohort_sources)
+        )
+    cohort_dimension_names = recipe_cohort_dimension_names(recipe)
+    missing_dimensions = [
+        column
+        for column in dimensions
+        if column not in columns and column not in cohort_dimension_names
+    ]
+    if missing_dimensions:
+        raise ValueError(
+            "Recipe dimensions reference missing columns: "
+            + ", ".join(missing_dimensions)
+        )
+    calculation_grain = mappings.get("calculation_grain")
+    if calculation_grain is None:
+        calculation_grain = dimensions
+    if not isinstance(calculation_grain, list):
+        raise ValueError(
+            "Recipe mapping 'calculation_grain' must be a list of column names."
+        )
+    missing_grain = [
+        column
+        for column in calculation_grain
+        if column not in columns and column not in cohort_dimension_names
+    ]
+    if missing_grain:
+        raise ValueError(
+            "Recipe calculation_grain references missing columns: "
+            + ", ".join(missing_grain)
+        )
+    mappings["dimensions"] = dimensions
+    mappings["calculation_grain"] = calculation_grain
+    default_comparison_options = suggested_comparison_options(
+        df, mappings.get("period_column")
+    )
+    comparison_basis = str(
+        options.get("comparison_basis")
+        or default_comparison_options["comparison_basis"]
+    )
+    if comparison_basis not in COMPARISON_BASIS_VALUES:
+        comparison_basis = default_comparison_options["comparison_basis"]
+    default_period_mode = default_comparison_options["period_comparison_mode"]
+    normalized_period_contract = period_contract_options(
+        options,
+        default_type=(
+            PERIOD_TYPE_CUSTOM
+            if comparison_basis == COMPARISON_BASIS_SCENARIO
+            else "calendar"
+        ),
+    )
+    requested_period_mode = options.get("period_comparison_mode")
+    if options.get("period_type") and requested_period_mode in {
+        None,
+        PERIOD_MODE_CALENDAR,
+    }:
+        period_comparison_mode = legacy_period_mode_from_period_type(
+            str(normalized_period_contract["period_type"])
+        )
+    elif requested_period_mode:
+        period_comparison_mode = str(requested_period_mode)
+    elif options.get("period_type") or options.get("fiscal_start_month"):
+        period_comparison_mode = legacy_period_mode_from_period_type(
+            str(normalized_period_contract["period_type"])
+        )
+    else:
+        period_comparison_mode = default_period_mode
+    if period_comparison_mode not in PERIOD_COMPARISON_MODE_VALUES:
+        period_comparison_mode = legacy_period_mode_from_period_type(
+            str(normalized_period_contract["period_type"])
+        )
+    if (
+        comparison_basis == COMPARISON_BASIS_PERIOD
+        and period_comparison_mode == PERIOD_MODE_NOT_APPLICABLE
+    ):
+        period_comparison_mode = PERIOD_MODE_CALENDAR
+    root_cause_enabled = bool(options.get("root_cause_bridge", True))
+    root_cause_auto_drilldown = root_cause_auto_drilldown_option(options)
+    if root_cause_enabled and root_cause_auto_drilldown == "none":
+        root_cause_auto_drilldown = "all_selected"
+    default_waterfall_small_multiples = bool(dimensions)
+    waterfall_small_multiples = bool(
+        options.get("waterfall_small_multiples", default_waterfall_small_multiples)
+    )
+    waterfall_small_multiples_dimension = options.get(
+        "waterfall_small_multiples_dimension"
+    )
+    total_by_dimension_bridge = bool(
+        options.get("total_by_dimension_bridge", bool(dimensions))
+    )
+    total_by_dimension_bridge_dimension = options.get(
+        "total_by_dimension_bridge_dimension"
+    )
+    exploded_variance_bridge = bool(
+        options.get("exploded_variance_bridge", len(dimensions) >= 2)
+    )
+    exploded_variance_bridge_parent_dimension = options.get(
+        "exploded_variance_bridge_parent_dimension"
+    )
+    exploded_variance_bridge_child_dimension = options.get(
+        "exploded_variance_bridge_child_dimension"
+    )
+
+    normalized = dict(recipe)
+    normalized["schema_version"] = recipe.get("schema_version") or SCHEMA_VERSION
+    normalized["mappings"] = mappings
+    period_window = options.get("period_window")
+    normalized["options"] = {
+        "comparison_basis": comparison_basis,
+        "period_comparison_mode": period_comparison_mode,
+        "period_type": normalized_period_contract["period_type"],
+        "period_grain": normalized_period_contract["period_grain"],
+        "fiscal_start_month": normalized_period_contract["fiscal_start_month"],
+        "period_window": period_window if isinstance(period_window, dict) else {},
+        "currency": str(options.get("currency") or "EUR"),
+        "unit_label": options.get("unit_label") or "units",
+        "root_cause_bridge": root_cause_enabled,
+        "root_cause_bridge_alternative_result": bounded_int_option(
+            options,
+            "root_cause_bridge_alternative_result",
+            1,
+            minimum=1,
+            maximum=10,
+        ),
+        "root_cause_bridge_drilldown_rows": positive_int_list_option(
+            options,
+            "root_cause_bridge_drilldown_rows",
+        ),
+        "root_cause_bridge_drilldown_all": bool(
+            options.get("root_cause_bridge_drilldown_all", False)
+        ),
+        "root_cause_bridge_move_rows": move_rows_option(
+            options,
+            "root_cause_bridge_move_rows",
+        ),
+        "root_cause_bridge_alternative_sweep": (
+            root_cause_enabled
+            and bool(options.get("root_cause_bridge_alternative_sweep", True))
+        ),
+        "root_cause_bridge_alternative_sweep_start": bounded_int_option(
+            options,
+            "root_cause_bridge_alternative_sweep_start",
+            1,
+            minimum=1,
+            maximum=10,
+        ),
+        "root_cause_bridge_alternative_sweep_end": bounded_int_option(
+            options,
+            "root_cause_bridge_alternative_sweep_end",
+            10,
+            minimum=1,
+            maximum=10,
+        ),
+        "root_cause_bridge_auto_drilldown": root_cause_auto_drilldown,
+        "root_cause_bridge_auto_drilldown_min_share": bounded_float_option(
+            options,
+            "root_cause_bridge_auto_drilldown_min_share",
+            0.75,
+            minimum=0.0,
+            maximum=1.0,
+        ),
+        "root_cause_component_bridge": root_cause_enabled
+        and bool(options.get("root_cause_component_bridge", False)),
+        "root_cause_component_bridge_alternative_result": bounded_int_option(
+            options,
+            "root_cause_component_bridge_alternative_result",
+            1,
+            minimum=1,
+            maximum=10,
+        ),
+        "waterfall_chart": bool(options.get("waterfall_chart", True)),
+        "pvm_decomposition_ladder": bool(options.get("pvm_decomposition_ladder", True)),
+        "waterfall_small_multiples": waterfall_small_multiples,
+        "waterfall_small_multiples_dimension": waterfall_small_multiples_dimension,
+        "total_by_dimension_bridge": total_by_dimension_bridge,
+        "total_by_dimension_bridge_dimension": total_by_dimension_bridge_dimension,
+        "total_by_dimension_bridge_top_n": bounded_int_option(
+            options,
+            "total_by_dimension_bridge_top_n",
+            TOTAL_BY_DIMENSION_DEFAULT_TOP_N,
+            minimum=1,
+            maximum=50,
+        ),
+        "exploded_variance_bridge": exploded_variance_bridge,
+        "exploded_variance_bridge_parent_dimension": (
+            exploded_variance_bridge_parent_dimension
+        ),
+        "exploded_variance_bridge_child_dimension": (
+            exploded_variance_bridge_child_dimension
+        ),
+        "exploded_variance_bridge_parent_top_n": bounded_int_option(
+            options,
+            "exploded_variance_bridge_parent_top_n",
+            TOTAL_BY_DIMENSION_DEFAULT_TOP_N,
+            minimum=1,
+            maximum=20,
+        ),
+        "exploded_variance_bridge_child_top_n": bounded_int_option(
+            options,
+            "exploded_variance_bridge_child_top_n",
+            EXPLODED_BRIDGE_DEFAULT_CHILD_TOP_N,
+            minimum=1,
+            maximum=8,
+        ),
+        "exploded_variance_bridge_max_drilldowns": bounded_int_option(
+            options,
+            "exploded_variance_bridge_max_drilldowns",
+            EXPLODED_BRIDGE_DEFAULT_MAX_DRILLDOWNS,
+            minimum=1,
+            maximum=EXPLODED_BRIDGE_DEFAULT_MAX_DRILLDOWNS,
+        ),
+    }
+    if options.get("reporting_entity_label"):
+        normalized["options"]["reporting_entity_label"] = str(
+            options["reporting_entity_label"]
+        )
+    for key in (
+        "cohorts",
+        "cohort_definition",
+        "cohort_contract",
+        "derived_dimensions",
+        "like_for_like",
+        "cohort_current_period",
+        "cohort_previous_period",
+        "current_period_label",
+        "previous_period_label",
+        "recipe_cohort_audit",
+    ):
+        if key in options:
+            normalized["options"][key] = options[key]
+    sweep_start = normalized["options"]["root_cause_bridge_alternative_sweep_start"]
+    sweep_end = normalized["options"]["root_cause_bridge_alternative_sweep_end"]
+    if sweep_end < sweep_start:
+        normalized["options"]["root_cause_bridge_alternative_sweep_start"] = sweep_end
+        normalized["options"]["root_cause_bridge_alternative_sweep_end"] = sweep_start
+    waterfall_dimension = normalized["options"]["waterfall_small_multiples_dimension"]
+    if waterfall_dimension:
+        waterfall_dimension = str(waterfall_dimension)
+        if (
+            waterfall_dimension not in columns
+            and waterfall_dimension not in cohort_dimension_names
+        ):
+            raise ValueError(
+                "Recipe option 'waterfall_small_multiples_dimension' references "
+                f"missing column: {waterfall_dimension}"
+            )
+        normalized["options"][
+            "waterfall_small_multiples_dimension"
+        ] = waterfall_dimension
+    total_bridge_dimension = normalized["options"][
+        "total_by_dimension_bridge_dimension"
+    ]
+    if total_bridge_dimension:
+        total_bridge_dimension = str(total_bridge_dimension)
+        if (
+            total_bridge_dimension not in columns
+            and total_bridge_dimension not in cohort_dimension_names
+        ):
+            raise ValueError(
+                "Recipe option 'total_by_dimension_bridge_dimension' references "
+                f"missing column: {total_bridge_dimension}"
+            )
+        normalized["options"][
+            "total_by_dimension_bridge_dimension"
+        ] = total_bridge_dimension
+    for option_key, role in (
+        ("exploded_variance_bridge_parent_dimension", "parent"),
+        ("exploded_variance_bridge_child_dimension", "child"),
+    ):
+        configured_dimension = normalized["options"][option_key]
+        if not configured_dimension:
+            continue
+        configured_dimension = str(configured_dimension)
+        if (
+            configured_dimension not in columns
+            and configured_dimension not in cohort_dimension_names
+        ):
+            raise ValueError(
+                f"Recipe option '{option_key}' references missing {role} "
+                f"column: {configured_dimension}"
+            )
+        normalized["options"][option_key] = configured_dimension
+    if (
+        normalized["options"].get("exploded_variance_bridge_parent_dimension")
+        and normalized["options"].get("exploded_variance_bridge_child_dimension")
+        and normalized["options"]["exploded_variance_bridge_parent_dimension"]
+        == normalized["options"]["exploded_variance_bridge_child_dimension"]
+    ):
+        raise ValueError(
+            "Recipe options 'exploded_variance_bridge_parent_dimension' and "
+            "'exploded_variance_bridge_child_dimension' must differ."
+        )
+    if (
+        period_comparison_mode == PERIOD_MODE_ROLLING
+        or options.get("rolling_window_days") is not None
+        or options.get("rolling_window_months") is not None
+    ):
+        rolling_window = rolling_window_length_options(
+            options, str(normalized_period_contract["period_grain"])
+        )
+        if "days" in rolling_window:
+            normalized["options"]["rolling_window_days"] = rolling_window["days"]
+            normalized["options"].pop("rolling_window_months", None)
+        else:
+            normalized["options"]["rolling_window_months"] = rolling_window["months"]
+            normalized["options"].pop("rolling_window_days", None)
+    if options.get("rolling_comparison") is not None:
+        normalized["options"]["rolling_comparison"] = str(
+            options.get("rolling_comparison")
+        )
+    if options.get("fiscal_start_month") is not None:
+        normalized["options"]["fiscal_start_month"] = normalized_period_contract[
+            "fiscal_start_month"
+        ]
+    return normalized
+
+
+def add_total_dimension(
+    df: pl.DataFrame, dimensions: list[str]
+) -> tuple[pl.DataFrame, list[str]]:
+    """Add a deterministic total dimension when no dimensions are mapped."""
+
+    if dimensions:
+        return df, dimensions
+    return df.with_columns(pl.lit("Total").alias(TOTAL_DIMENSION)), [TOTAL_DIMENSION]
+
+
+def aggregate_period(
+    df: pl.DataFrame,
+    dimensions: list[str],
+    period_col: str,
+    period_value: str,
+    value_columns: list[str],
+    suffix: str,
+) -> pl.DataFrame:
+    """Aggregate one period snapshot and suffix value columns."""
+
+    filtered = df.filter(pl.col(period_col).cast(pl.Utf8) == str(period_value))
+    if filtered.is_empty():
+        raise ValueError(f"No rows found for period '{period_value}'.")
+    grouped = (
+        filtered.lazy()
+        .with_columns(
+            [
+                pl.col(column).fill_null("").cast(pl.Utf8).alias(column)
+                for column in dimensions
+            ]
+        )
+        .group_by(dimensions)
+        .agg(
+            [
+                pl.col(column).sum().alias(f"{column}_{suffix}")
+                for column in value_columns
+            ]
+        )
+        .collect()
+    )
+    return grouped
+
+
+def joined_period_frame(
+    df: pl.DataFrame,
+    recipe: dict[str, Any],
+    dimensions: list[str],
+) -> tuple[pl.DataFrame, dict[str, str]]:
+    """Return a full outer joined baseline/comparison frame."""
+
+    mappings = recipe["mappings"]
+    period_col = mappings["period_column"]
+    baseline_period = str(mappings["baseline_period"])
+    comparison_period = str(mappings["comparison_period"])
+    amount_col = mappings["amount_column"]
+    optional_cols = [
+        mappings.get("units_column"),
+        mappings.get("discount_column"),
+        mappings.get("cogs_column"),
+    ]
+    value_columns = [amount_col] + [column for column in optional_cols if column]
+    value_columns = list(dict.fromkeys(value_columns))
+    baseline = aggregate_period(
+        df, dimensions, period_col, baseline_period, value_columns, "baseline"
+    )
+    comparison = aggregate_period(
+        df, dimensions, period_col, comparison_period, value_columns, "comparison"
+    )
+    joined = baseline.join(comparison, on=dimensions, how="full", coalesce=True)
+    fill_columns = [
+        f"{column}_{suffix}"
+        for column in value_columns
+        for suffix in ("baseline", "comparison")
+    ]
+    joined = joined.with_columns(
+        [pl.col(column).fill_null(0).alias(column) for column in fill_columns]
+    )
+    names = {
+        "amount0": f"{amount_col}_baseline",
+        "amount1": f"{amount_col}_comparison",
+    }
+    for key, source_key in (
+        ("units", "units_column"),
+        ("discount", "discount_column"),
+        ("cogs", "cogs_column"),
+    ):
+        column = mappings.get(source_key)
+        if column:
+            names[f"{key}0"] = f"{column}_baseline"
+            names[f"{key}1"] = f"{column}_comparison"
+    return joined, names
+
+
+def optional_col(names: dict[str, str], key: str) -> pl.Expr:
+    """Return an optional numeric expression, defaulting to zero."""
+
+    column = names.get(key)
+    if column:
+        return pl.col(column)
+    return pl.lit(0.0)
+
+
+def safe_ratio(numerator: pl.Expr, denominator: pl.Expr) -> pl.Expr:
+    """Return numerator / denominator, using zero when denominator is zero."""
+
+    return pl.when(denominator == 0).then(0.0).otherwise(numerator / denominator)
+
+
+def ordered_unique(values: Iterable[str]) -> list[str]:
+    """Return values once, preserving their first-seen order."""
+
+    return list(dict.fromkeys(values))
+
+
+def calculation_grain_for(
+    recipe: dict[str, Any], report_dimensions: list[str]
+) -> list[str]:
+    """Return the bottom-up grain used for legacy-compatible variance math."""
+
+    mappings = recipe["mappings"]
+    grain = list(mappings.get("calculation_grain") or report_dimensions)
+    return ordered_unique([*report_dimensions, *grain])
+
+
+def changed_mask(amount0: pl.Expr, amount1: pl.Expr) -> pl.Expr:
+    """Return rows present in both periods for legacy price-volume-mix allocation."""
+
+    return (amount0 > 0) & (amount1 > 0)
+
+
+def new_or_lost_contribution(
+    amount0: pl.Expr, amount1: pl.Expr, contribution: pl.Expr
+) -> pl.Expr:
+    """Put new/lost rows entirely into the volume-style contribution."""
+
+    return (
+        pl.when(amount0 == 0)
+        .then(contribution)
+        .when(amount1 == 0)
+        .then(contribution)
+        .otherwise(0.0)
+    )
+
+
+def legacy_price_component(
+    amount0: pl.Expr, amount1: pl.Expr, units0: pl.Expr, units1: pl.Expr
+) -> pl.Expr:
+    """Legacy price effect from variance_formulas.calculate_residual_variance."""
+
+    price0 = safe_ratio(amount0, units0)
+    price1 = safe_ratio(amount1, units1)
+    units_change = units1 - units0
+    price_change = price1 - price0
+    return (
+        pl.when(changed_mask(amount0, amount1))
+        .then(price_change * (units0 + units_change / 2))
+        .otherwise(0.0)
+    )
+
+
+def legacy_volume_component(
+    amount0: pl.Expr, amount1: pl.Expr, units0: pl.Expr, units1: pl.Expr
+) -> pl.Expr:
+    """Legacy volume effect with new/lost rows treated as volume variance."""
+
+    price0 = safe_ratio(amount0, units0)
+    price1 = safe_ratio(amount1, units1)
+    units_change = units1 - units0
+    price_change = price1 - price0
+    total_delta = amount1 - amount0
+    changed_volume = units_change * (price0 + price_change / 2)
+    return (
+        pl.when(changed_mask(amount0, amount1))
+        .then(changed_volume)
+        .otherwise(total_delta)
+    )
+
+
+def numeric_sum_expressions(
+    df: pl.DataFrame, group_columns: list[str]
+) -> list[pl.Expr]:
+    """Return sum expressions for numeric non-grouping columns."""
+
+    return [
+        pl.col(column).sum().alias(column)
+        for column, dtype in df.schema.items()
+        if column not in group_columns and dtype.is_numeric()
+    ]
+
+
+def add_report_total_dimension(
+    df: pl.DataFrame, report_dimensions: list[str]
+) -> tuple[pl.DataFrame, list[str]]:
+    """Add a total reporting dimension when the user asks for total output."""
+
+    if report_dimensions:
+        return df, report_dimensions
+    return df.with_columns(pl.lit("Total").alias(TOTAL_DIMENSION)), [TOTAL_DIMENSION]
+
+
+def calculate_variance_frame(
+    df: pl.DataFrame,
+    recipe: dict[str, Any],
+    dimensions: list[str],
+) -> pl.DataFrame:
+    """Calculate deterministic variance output using legacy bottom-up price-volume-mix."""
+
+    reporting_dimensions = list(dimensions)
+    leaf_dimensions = calculation_grain_for(recipe, reporting_dimensions)
+    working_df, grouping_dimensions = add_total_dimension(df, leaf_dimensions)
+    wide, names = joined_period_frame(working_df, recipe, grouping_dimensions)
+    amount0 = pl.col(names["amount0"])
+    amount1 = pl.col(names["amount1"])
+    units0 = optional_col(names, "units0")
+    units1 = optional_col(names, "units1")
+    discount0 = optional_col(names, "discount0")
+    discount1 = optional_col(names, "discount1")
+    cogs0 = optional_col(names, "cogs0")
+    cogs1 = optional_col(names, "cogs1")
+    has_units = "units0" in names and "units1" in names
+    has_discount = "discount0" in names and "discount1" in names
+    has_cogs = "cogs0" in names and "cogs1" in names
+
+    result = wide.with_columns(
+        (amount1 - amount0).alias("total_delta"),
+        pl.when(amount0 == 0)
+        .then(None)
+        .otherwise((amount1 - amount0) / amount0 * 100)
+        .alias("amount_pct_change"),
+        amount0.alias("_legacy_amount0"),
+        amount1.alias("_legacy_amount1"),
+    )
+    if has_units:
+        price0 = safe_ratio(amount0, units0)
+        price1 = safe_ratio(amount1, units1)
+        changed = changed_mask(amount0, amount1)
+        result = result.with_columns(
+            price0.alias("price_baseline"),
+            price1.alias("price_comparison"),
+            legacy_price_component(amount0, amount1, units0, units1).alias(
+                "price_variance"
+            ),
+            legacy_volume_component(amount0, amount1, units0, units1).alias(
+                "volume_variance"
+            ),
+            pl.when(changed)
+            .then(amount0)
+            .otherwise(0.0)
+            .alias("_legacy_changed_amount0"),
+            pl.when(changed)
+            .then(amount1)
+            .otherwise(0.0)
+            .alias("_legacy_changed_amount1"),
+            pl.when(changed)
+            .then(units0)
+            .otherwise(0.0)
+            .alias("_legacy_changed_units0"),
+            pl.when(changed)
+            .then(units1)
+            .otherwise(0.0)
+            .alias("_legacy_changed_units1"),
+            units0.alias("_legacy_units0"),
+            units1.alias("_legacy_units1"),
+            new_or_lost_contribution(amount0, amount1, amount1 - amount0).alias(
+                "_legacy_new_lost_volume"
+            ),
+        )
+        result = result.with_columns(
+            pl.col("volume_variance").alias("_legacy_bottom_up_volume"),
+            pl.lit(0.0).alias("mix_variance"),
+        )
+    if has_discount:
+        net0 = amount0 - discount0
+        net1 = amount1 - discount1
+        result = result.with_columns(
+            net0.alias("net_baseline"),
+            net1.alias("net_comparison"),
+            (net1 - net0).alias("net_delta"),
+            pl.when(net0 == 0)
+            .then(None)
+            .otherwise((net1 - net0) / net0 * 100)
+            .alias("net_pct_change"),
+            (-(discount1 - discount0)).alias("discount_variance"),
+            discount0.alias("_legacy_discount0"),
+            discount1.alias("_legacy_discount1"),
+        )
+    if has_cogs:
+        margin0 = amount0 - discount0 - cogs0
+        margin1 = amount1 - discount1 - cogs1
+        result = result.with_columns(
+            (cogs1 - cogs0).alias("cogs_delta"),
+            (-(cogs1 - cogs0)).alias("cogs_variance"),
+            cogs0.alias("_legacy_cogs0"),
+            cogs1.alias("_legacy_cogs1"),
+            margin0.alias("margin_baseline"),
+            margin1.alias("margin_comparison"),
+            (margin1 - margin0).alias("margin_delta"),
+            pl.when(margin0 == 0)
+            .then(None)
+            .otherwise((margin1 - margin0) / margin0 * 100)
+            .alias("margin_pct_change"),
+        )
+        if has_units:
+            changed = changed_mask(amount0, amount1)
+            price0 = safe_ratio(amount0, units0)
+            price1 = safe_ratio(amount1, units1)
+            discount_per_unit0 = safe_ratio(discount0, units0)
+            discount_per_unit1 = safe_ratio(discount1, units1)
+            cogs_per_unit0 = safe_ratio(cogs0, units0)
+            cogs_per_unit1 = safe_ratio(cogs1, units1)
+            cost_per_unit0 = discount_per_unit0 + cogs_per_unit0
+            cost_per_unit1 = discount_per_unit1 + cogs_per_unit1
+            units_change = units1 - units0
+            price_change = price1 - price0
+            discount_change = discount_per_unit1 - discount_per_unit0
+            cogs_change = cogs_per_unit1 - cogs_per_unit0
+            cost_change = cost_per_unit1 - cost_per_unit0
+            changed_weight = units0 + units_change / 2
+            margin_volume = units_change * (
+                price0 - cost_per_unit0 + price_change / 2 - cost_change / 2
+            )
+            result = result.with_columns(
+                pl.when(changed)
+                .then(price_change * (units0 + units_change / 2))
+                .otherwise(0.0)
+                .alias("margin_price_variance"),
+                pl.when(changed)
+                .then(-discount_change * changed_weight)
+                .otherwise(0.0)
+                .alias("discount_variance"),
+                pl.when(changed)
+                .then(-cogs_change * changed_weight)
+                .otherwise(0.0)
+                .alias("cogs_variance"),
+                pl.when(changed)
+                .then(margin_volume)
+                .otherwise(margin1 - margin0)
+                .alias("margin_volume_variance"),
+                pl.when(changed)
+                .then(discount0)
+                .otherwise(0.0)
+                .alias("_legacy_changed_discount0"),
+                pl.when(changed)
+                .then(discount1)
+                .otherwise(0.0)
+                .alias("_legacy_changed_discount1"),
+                pl.when(changed)
+                .then(cogs0)
+                .otherwise(0.0)
+                .alias("_legacy_changed_cogs0"),
+                pl.when(changed)
+                .then(cogs1)
+                .otherwise(0.0)
+                .alias("_legacy_changed_cogs1"),
+                new_or_lost_contribution(amount0, amount1, margin1 - margin0).alias(
+                    "_legacy_new_lost_margin_volume"
+                ),
+            )
+            result = result.with_columns(
+                pl.col("margin_volume_variance").alias(
+                    "_legacy_bottom_up_margin_volume"
+                ),
+                pl.lit(0.0).alias("margin_mix_variance"),
+            )
+            result = result.with_columns(
+                (
+                    pl.col("margin_delta")
+                    - pl.col("margin_price_variance")
+                    - pl.col("margin_volume_variance")
+                    - pl.col("margin_mix_variance")
+                ).alias("margin_component_reconciliation_delta")
+            )
+    result = aggregate_legacy_components(
+        result,
+        reporting_dimensions,
+        has_units=has_units,
+        has_discount=has_discount,
+        has_cogs=has_cogs,
+    )
+    if TOTAL_DIMENSION in result.schema:
+        result = result.rename({TOTAL_DIMENSION: "segment"})
+    internal_columns = [
+        column for column in result.columns if column.startswith("_legacy_")
+    ]
+    if internal_columns:
+        result = result.drop(internal_columns)
+    return result.sort(
+        "total_delta",
+        descending=True,
+    )
+
+
+def aggregate_legacy_components(
+    leaf: pl.DataFrame,
+    report_dimensions: list[str],
+    *,
+    has_units: bool,
+    has_discount: bool,
+    has_cogs: bool,
+) -> pl.DataFrame:
+    """Aggregate bottom-up leaf calculations and recompute pure mix effects."""
+
+    report_df, grouping_dimensions = add_report_total_dimension(leaf, report_dimensions)
+    grouped = (
+        report_df.lazy()
+        .group_by(grouping_dimensions)
+        .agg(numeric_sum_expressions(report_df, grouping_dimensions))
+        .collect()
+    )
+    amount0 = pl.col("_legacy_amount0")
+    amount1 = pl.col("_legacy_amount1")
+    grouped = grouped.with_columns(
+        pl.when(amount0 == 0)
+        .then(None)
+        .otherwise((amount1 - amount0) / amount0 * 100)
+        .alias("amount_pct_change")
+    )
+    if has_units:
+        changed_amount0 = pl.col("_legacy_changed_amount0")
+        changed_amount1 = pl.col("_legacy_changed_amount1")
+        changed_units0 = pl.col("_legacy_changed_units0")
+        changed_units1 = pl.col("_legacy_changed_units1")
+        pure_changed_volume = legacy_volume_component(
+            changed_amount0, changed_amount1, changed_units0, changed_units1
+        )
+        grouped = grouped.with_columns(
+            safe_ratio(amount0, pl.col("_legacy_units0")).alias("price_baseline"),
+            safe_ratio(amount1, pl.col("_legacy_units1")).alias("price_comparison"),
+            (pure_changed_volume + pl.col("_legacy_new_lost_volume")).alias(
+                "volume_variance"
+            ),
+        )
+        grouped = grouped.with_columns(
+            (pl.col("_legacy_bottom_up_volume") - pl.col("volume_variance")).alias(
+                "mix_variance"
+            ),
+        )
+        grouped = grouped.with_columns(
+            (
+                pl.col("total_delta")
+                - pl.col("price_variance")
+                - pl.col("volume_variance")
+                - pl.col("mix_variance")
+            ).alias("component_reconciliation_delta"),
+        )
+    if has_discount:
+        net0 = amount0 - pl.col("_legacy_discount0")
+        net1 = amount1 - pl.col("_legacy_discount1")
+        if "discount_variance" in grouped.schema:
+            grouped = grouped.with_columns(
+                net0.alias("net_baseline"),
+                net1.alias("net_comparison"),
+                (net1 - net0).alias("net_delta"),
+                pl.when(net0 == 0)
+                .then(None)
+                .otherwise((net1 - net0) / net0 * 100)
+                .alias("net_pct_change"),
+            )
+    if has_cogs:
+        discount0 = (
+            pl.col("_legacy_discount0")
+            if "_legacy_discount0" in grouped.schema
+            else pl.lit(0.0)
+        )
+        discount1 = (
+            pl.col("_legacy_discount1")
+            if "_legacy_discount1" in grouped.schema
+            else pl.lit(0.0)
+        )
+        cogs0 = pl.col("_legacy_cogs0")
+        cogs1 = pl.col("_legacy_cogs1")
+        margin0 = amount0 - discount0 - cogs0
+        margin1 = amount1 - discount1 - cogs1
+        grouped = grouped.with_columns(
+            margin0.alias("margin_baseline"),
+            margin1.alias("margin_comparison"),
+            (margin1 - margin0).alias("margin_delta"),
+            pl.when(margin0 == 0)
+            .then(None)
+            .otherwise((margin1 - margin0) / margin0 * 100)
+            .alias("margin_pct_change"),
+        )
+        if has_units:
+            changed_amount0 = pl.col("_legacy_changed_amount0")
+            changed_amount1 = pl.col("_legacy_changed_amount1")
+            changed_units0 = pl.col("_legacy_changed_units0")
+            changed_units1 = pl.col("_legacy_changed_units1")
+            changed_discount0 = pl.col("_legacy_changed_discount0")
+            changed_discount1 = pl.col("_legacy_changed_discount1")
+            changed_cogs0 = pl.col("_legacy_changed_cogs0")
+            changed_cogs1 = pl.col("_legacy_changed_cogs1")
+            price0 = safe_ratio(changed_amount0, changed_units0)
+            price1 = safe_ratio(changed_amount1, changed_units1)
+            cost0 = safe_ratio(changed_discount0 + changed_cogs0, changed_units0)
+            cost1 = safe_ratio(changed_discount1 + changed_cogs1, changed_units1)
+            units_change = changed_units1 - changed_units0
+            price_change = price1 - price0
+            cost_change = cost1 - cost0
+            pure_margin_volume = units_change * (
+                price0 - cost0 + price_change / 2 - cost_change / 2
+            )
+            grouped = grouped.with_columns(
+                (pure_margin_volume + pl.col("_legacy_new_lost_margin_volume")).alias(
+                    "margin_volume_variance"
+                )
+            )
+            grouped = grouped.with_columns(
+                (
+                    pl.col("_legacy_bottom_up_margin_volume")
+                    - pl.col("margin_volume_variance")
+                ).alias("margin_mix_variance"),
+            )
+            margin_component_sum = (
+                pl.col("margin_price_variance")
+                + pl.col("margin_volume_variance")
+                + pl.col("margin_mix_variance")
+            )
+            if "discount_variance" in grouped.schema:
+                margin_component_sum = margin_component_sum + pl.col(
+                    "discount_variance"
+                )
+            if "cogs_variance" in grouped.schema:
+                margin_component_sum = margin_component_sum + pl.col("cogs_variance")
+            grouped = grouped.with_columns(
+                (pl.col("margin_delta") - margin_component_sum).alias(
+                    "margin_component_reconciliation_delta"
+                )
+            )
+    return grouped
+
+
+def bridge_dimension_sets(dimensions: list[str], enabled: bool) -> list[list[str]]:
+    """Return dimension combinations for root-cause variance output."""
+
+    if not enabled or len(dimensions) < 2:
+        return []
+    return [
+        list(combo)
+        for size in range(1, len(dimensions) + 1)
+        for combo in itertools.combinations(dimensions, size)
+    ]
+
+
+def write_outputs(
+    result: pl.DataFrame,
+    audit: dict[str, Any],
+    summary: str,
+    output_dir: Path,
+    *,
+    artifact_paths: list[str],
+) -> None:
+    """Write deterministic variance outputs."""
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    result.write_csv(output_dir / "variance_results.csv")
+    # Legacy component columns remain available for audit, but an amount-only
+    # workbook must not present them as measured price/volume/mix effects.
+    hidden_components = (
+        [
+            name
+            for name in (
+                "price_baseline",
+                "price_comparison",
+                "price_variance",
+                "volume_variance",
+                "mix_variance",
+            )
+            if name in result.schema
+        ]
+        if not audit["recipe"]["mappings"]["units_column"]
+        else []
+    )
+    try:
+        result.write_excel(
+            output_dir / "variance_results.xlsx",
+            autofit=True,
+            freeze_panes=(1, 1),
+            hide_gridlines=True,
+            hidden_columns=hidden_components,
+            header_format={
+                "bold": True,
+                "font_color": "#FFFFFF",
+                "bg_color": "#183B56",
+            },
+        )
+        audit["outputs"]["variance_results.xlsx"] = "written"
+    except (ImportError, ModuleNotFoundError, OSError, ValueError) as exc:
+        audit["outputs"]["variance_results.xlsx"] = f"not_written: {exc}"
+    write_json(output_dir / "variance_audit.json", audit)
+    (output_dir / "variance_summary.md").write_text(summary, encoding="utf-8")
+    audit["outputs"]["variance_results.csv"] = "written"
+    audit["outputs"]["variance_audit.json"] = "written"
+    audit["outputs"]["variance_summary.md"] = "written"
+    for path in artifact_paths:
+        audit["outputs"][Path(path).name] = "written"
+    write_json(output_dir / "variance_audit.json", audit)
+
+
+def _relative_artifact_path(path: Path, base: Path) -> str:
+    """Return a stable artifact path relative to ``base`` when possible."""
+
+    try:
+        return path.relative_to(base).as_posix()
+    except ValueError:
+        return path.as_posix()
+
+
+def _artifact_kind(path: Path) -> str:
+    """Return the artifact group for a generated file."""
+
+    suffix = path.suffix.lower()
+    if suffix in {".png", ".html", ".htm"}:
+        return "charts"
+    if suffix in {".csv", ".xlsx"}:
+        return "tables"
+    if suffix == ".json":
+        return "contexts"
+    if suffix == ".md":
+        return "briefs"
+    if suffix == ".docx":
+        return "reports"
+    return "files"
+
+
+def _chart_type_from_name(name: str) -> str:
+    """Return a stable chart type from a generated PNG name."""
+
+    stem = Path(name).stem
+    if stem == "waterfall":
+        return "standard_variance_waterfall"
+    if stem == "waterfall_small_multiples":
+        return "standard_variance_small_multiples"
+    if stem == "total_by_dimension_bridge":
+        return "total_by_dimension_bridge"
+    if stem == "exploded_variance_bridge":
+        return "exploded_variance_bridge"
+    if stem == "pvm_decomposition_ladder":
+        return "pvm_decomposition_ladder"
+    if stem.startswith("root_cause_client_report_"):
+        return "client_report_chart"
+    if stem.startswith("root_cause_component_bridge"):
+        return "root_cause_component_bridge"
+    if stem.startswith("root_cause_total_bridge"):
+        return "root_cause_total_bridge"
+    if "drilldown" in stem:
+        return "root_cause_drilldown"
+    if stem.startswith("root_cause_bridge_alt_"):
+        return "root_cause_alternative_bridge"
+    if stem.startswith("root_cause_bridge"):
+        return "root_cause_bridge"
+    return "chart"
+
+
+def _root_cause_bridge_variant(stem: str) -> str | None:
+    """Return the formal root-cause bridge variant for a generated artifact."""
+
+    if stem.startswith("root_cause_bridge_alt_") and "drilldown" in stem:
+        return "alternative_drilldown"
+    if stem.startswith("root_cause_bridge_alt_"):
+        return "alternative_sequence"
+    if stem == "root_cause_component_bridge":
+        return "component_sequence"
+    if stem == "root_cause_total_bridge":
+        return "main_sequence"
+    if "drilldown" in stem:
+        return "drilldown"
+    if stem == "root_cause_bridge_moved_rows":
+        return "moved_rows"
+    if stem == "root_cause_bridge":
+        return "main_sequence"
+    return None
+
+
+def _root_cause_alternative_result(stem: str) -> int | None:
+    """Return the legacy alternative number embedded in a root-cause artifact."""
+
+    prefix = "root_cause_bridge_alt_"
+    if not stem.startswith(prefix):
+        return None
+    candidate = stem.removeprefix(prefix).split("_", 1)[0]
+    return int(candidate) if candidate.isdecimal() else None
+
+
+def _root_cause_drilldown_row(stem: str) -> int | None:
+    """Return the parent row number embedded in a root-cause drilldown artifact."""
+
+    marker = "_drilldown_row_"
+    if marker not in stem:
+        return None
+    candidate = stem.split(marker, 1)[1].split("_", 1)[0]
+    return int(candidate) if candidate.isdecimal() else None
+
+
+def _root_cause_parent_artifact_id(stem: str) -> str | None:
+    """Return the parent sequence artifact id for a root-cause drilldown."""
+
+    drilldown_row = _root_cause_drilldown_row(stem)
+    if drilldown_row is None:
+        return None
+    alternative_result = _root_cause_alternative_result(stem)
+    if alternative_result is not None:
+        return f"root_cause_bridge_alt_{alternative_result}"
+    if stem.startswith("root_cause_total_bridge_drilldown_row_"):
+        return "root_cause_total_bridge"
+    if stem.startswith("root_cause_bridge_drilldown_row_"):
+        return "root_cause_bridge"
+    return None
+
+
+def _root_cause_bridge_frame_identity(source: Path) -> dict[str, Any]:
+    """Return the analytical row sequence behind a root-cause bridge artifact."""
+
+    bridge_path = source.with_suffix(".csv")
+    if not bridge_path.exists():
+        return {}
+    try:
+        frame = _collect_csv_scan(bridge_path, separator=",")
+    except (OSError, pl.exceptions.PolarsError):
+        return {}
+    dimensions = _root_cause_dimension_columns(frame)
+    sequence: list[dict[str, Any]] = []
+    for index, row in enumerate(frame.to_dicts(), start=1):
+        filters = {
+            dimension: row.get(dimension)
+            for dimension in dimensions
+            if row.get(dimension) not in (None, "", "All")
+        }
+        sequence.append(
+            {
+                "row_number": index,
+                "bridge_level": row.get("bridge_level"),
+                "bridge_dimensions": row.get("bridge_dimensions"),
+                "filters": filters,
+                "variance_type": row.get("variance_type"),
+                "variance_amount": float(row.get("variance_amount") or 0.0),
+            }
+        )
+    variant = _root_cause_bridge_variant(source.stem)
+    alternative_result = _root_cause_alternative_result(source.stem)
+    drilldown_row = _root_cause_drilldown_row(source.stem)
+    identity = {
+        "root_cause_bridge_variant": _root_cause_bridge_variant(source.stem),
+        "alternative_result": alternative_result,
+        "drilldown_row": drilldown_row,
+        "root_cause_sequence": sequence,
+    }
+    parent_artifact_id = _root_cause_parent_artifact_id(source.stem)
+    if parent_artifact_id is not None:
+        identity["parent_artifact_id"] = parent_artifact_id
+        identity["parent_row_number"] = drilldown_row
+    if variant == "alternative_drilldown":
+        identity["child_artifact_type"] = "alternative_drilldown"
+        identity["parent_capability_id"] = "variance.root_cause_alternative_sweep"
+        identity["parent_child_type"] = "alternative_sequence"
+        identity["parent_alternative_result"] = alternative_result
+    return identity
+
+
+def _total_by_dimension_bridge_frame_identity(source: Path) -> dict[str, Any]:
+    """Return the analytical row sequence behind a total-by-dimension chart."""
+
+    bridge_path = source.with_suffix(".csv")
+    if not bridge_path.exists():
+        return {}
+    try:
+        frame = _collect_csv_scan(bridge_path, separator=",")
+    except (OSError, pl.exceptions.PolarsError):
+        return {}
+    if frame.is_empty() or "dimension_value" not in frame.columns:
+        return {}
+    first_dimension = (
+        str(frame["dimension"][0]) if "dimension" in frame.columns else None
+    )
+    sequence: list[dict[str, Any]] = []
+    for row in frame.to_dicts():
+        sequence.append(
+            {
+                "row_number": row.get("row_number"),
+                "dimension_value": row.get("dimension_value"),
+                "row_type": row.get("row_type"),
+                "amount_baseline": float(row.get("amount_baseline") or 0.0),
+                "amount_comparison": float(row.get("amount_comparison") or 0.0),
+                "total_delta": float(row.get("total_delta") or 0.0),
+                "percent_delta": (
+                    float(row["percent_delta"])
+                    if row.get("percent_delta") is not None
+                    else None
+                ),
+            }
+        )
+    identity: dict[str, Any] = {
+        "total_by_dimension_bridge_dimension": first_dimension,
+        "total_by_dimension_sequence": sequence,
+    }
+    return identity
+
+
+def _exploded_variance_bridge_identity(source: Path) -> dict[str, Any]:
+    """Return the native parent/child bridge identity from its spec sidecar."""
+
+    spec_path = source.with_name("exploded_variance_bridge_spec.json")
+    if not spec_path.exists():
+        return {}
+    try:
+        payload = load_json(spec_path)
+    except (OSError, json.JSONDecodeError):
+        return {}
+    selection = payload.get("selection") or {}
+    parent = payload.get("parent") or {}
+    children = payload.get("children") or []
+    return {
+        "exploded_variance_bridge_parent_dimension": selection.get("parent_dimension"),
+        "exploded_variance_bridge_child_dimension": selection.get("child_dimension"),
+        "exploded_variance_bridge_max_drilldowns": selection.get("max_drilldowns"),
+        "exploded_variance_bridge_parent_rows": parent.get("rows") or [],
+        "exploded_variance_bridge_drilldowns": [
+            {
+                "drilldown_id": child.get("drilldown_id"),
+                "parent_row_number": child.get("parent_row_number"),
+                "parent_dimension_value": child.get("parent_dimension_value"),
+                "child_dimension": child.get("child_dimension"),
+                "rows": child.get("rows") or [],
+            }
+            for child in children
+        ],
+    }
+
+
+def _movement_driver_dimension(
+    chart_type: str,
+    recipe: dict[str, Any],
+) -> str | list[str] | None:
+    """Return the deterministic driver dimension represented by a variance chart."""
+
+    mappings = recipe.get("mappings") or {}
+    options = recipe.get("options") or {}
+    if chart_type == "standard_variance_waterfall":
+        return "variance_component"
+    if chart_type == "standard_variance_small_multiples":
+        return options.get("waterfall_small_multiples_dimension")
+    if chart_type == "total_by_dimension_bridge":
+        return options.get("total_by_dimension_bridge_dimension")
+    if chart_type == "exploded_variance_bridge":
+        return [
+            value
+            for value in [
+                options.get("exploded_variance_bridge_parent_dimension"),
+                options.get("exploded_variance_bridge_child_dimension"),
+            ]
+            if value
+        ]
+    if chart_type == "pvm_decomposition_ladder":
+        return "pvm_component"
+    if chart_type.startswith("root_cause"):
+        dimensions = mappings.get("dimensions") or []
+        return [str(value) for value in dimensions] if dimensions else "root_cause"
+    return None
+
+
+def _normalize_artifact_mode(artifact_mode: str) -> str:
+    """Return a supported artifact mode or raise for invalid contract input."""
+
+    normalized = str(artifact_mode or ARTIFACT_MODE_DATA_AND_RENDER).strip().lower()
+    if normalized not in ARTIFACT_MODES:
+        allowed = ", ".join(sorted(ARTIFACT_MODES))
+        raise ValueError(f"Unsupported artifact_mode {artifact_mode!r}; use {allowed}.")
+    return normalized
+
+
+def _variance_data_chart_enabled(
+    chart_type: str,
+    available_chart_types: Sequence[str],
+) -> bool:
+    return chart_type in set(available_chart_types)
+
+
+def _variance_chart_selected(
+    chart_type: str,
+    artifact_mode: str,
+    available_chart_types: Sequence[str],
+) -> bool:
+    if chart_type not in set(available_chart_types):
+        return False
+    return artifact_mode != ARTIFACT_MODE_DATA_ONLY
+
+
+def _data_written_chart_audit(
+    *,
+    chart_type: str,
+    artifact_name: str,
+    source_functions: Sequence[str],
+) -> dict[str, Any]:
+    return {
+        "status": "data_written",
+        "artifact": artifact_name,
+        "rendered": False,
+        "source_functions": list(source_functions),
+        "chart_type": chart_type,
+    }
+
+
+def _skipped_chart_audit(chart_type: str, reason: str) -> dict[str, Any]:
+    return {
+        "status": "skipped",
+        "chart_type": chart_type,
+        "reason": reason,
+    }
+
+
+def _comparison_payload(recipe: dict[str, Any]) -> dict[str, Any]:
+    """Return comparison metadata for reporting agents."""
+
+    mappings = recipe.get("mappings") or {}
+    options = recipe.get("options") or {}
+    return {
+        "baseline": mappings.get("baseline_period"),
+        "comparison": mappings.get("comparison_period"),
+        "basis": options.get("comparison_basis"),
+        "mode": options.get("period_comparison_mode"),
+        "period_window": options.get("period_window"),
+    }
+
+
+def _title_contract_payload(
+    recipe: dict[str, Any],
+    *,
+    chart_kind: str,
+    dimension: str | None = None,
+) -> dict[str, Any]:
+    """Return the visible three-row title contract for a variance chart."""
+
+    title = build_ibcs_title(recipe, chart_kind=chart_kind, dimension=dimension)
+    return {
+        "chart_title_lines": title.lines(),
+        "title_contract": {
+            "who": title.who,
+            "what": title.what,
+            "when": title.when,
+        },
+    }
+
+
+def _standard_variance_context(
+    result: pl.DataFrame,
+    recipe: dict[str, Any],
+    output_dir: Path,
+) -> dict[str, Any]:
+    """Return data context behind the standard variance chart."""
+
+    components = [
+        {
+            "variance_type": label,
+            "variance_amount": _numeric_column_sum(result, column),
+            "source_column": column,
+            "is_residual_other": False,
+        }
+        for label, column in standard_variance_component_columns(recipe)
+    ]
+    total_delta = _numeric_column_sum(result, "total_delta")
+    component_sum = sum(float(item["variance_amount"] or 0.0) for item in components)
+    residual = total_delta - component_sum
+    components.append(
+        {
+            "variance_type": "Other",
+            "variance_amount": residual,
+            "source_column": "component_reconciliation_delta",
+            "is_residual_other": True,
+        }
+    )
+    dominant = _dominant_component(components)
+    mappings = recipe.get("mappings") or {}
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "chart_id": "standard_variance_waterfall",
+        "chart_family": "variance_analysis",
+        "chart_type": "standard_variance_waterfall",
+        "chart_path": (
+            "charts/waterfall.png" if (output_dir / "waterfall.png").exists() else None
+        ),
+        "metric": mappings.get("amount_column"),
+        "pvm_available": bool(mappings.get("units_column")),
+        "unit": (recipe.get("options") or {}).get("currency") or "EUR",
+        "comparison": _comparison_payload(recipe),
+        "recipe_filters": (recipe.get("options") or {}).get("recipe_filter_audit"),
+        "recipe_cohorts": (recipe.get("options") or {}).get("recipe_cohort_audit"),
+        "dimensions": mappings.get("dimensions") or [],
+        "calculation_grain": mappings.get("calculation_grain") or [],
+        **_title_contract_payload(recipe, chart_kind="standard_variance"),
+        "totals": {
+            "amount_baseline": _numeric_column_sum(result, "amount_baseline"),
+            "amount_comparison": _numeric_column_sum(result, "amount_comparison"),
+            "total_delta": total_delta,
+            "component_sum": component_sum,
+            "other_residual": residual,
+        },
+        "components": components,
+        "dominant_component": {
+            "variance_type": dominant.get("variance_type"),
+            "variance_amount": dominant.get("variance_amount"),
+        },
+        "top_rows_by_abs_delta": top_driver_rows(result, limit=10),
+        "codex_interpretation_contract": {
+            "must_review_when_written": True,
+            "required_points": [
+                "Explain the dominant standard variance component.",
+                "State whether Other/residual is material.",
+                "Use small-multiples context when available before claiming concentration or spread.",
+                "Distinguish deterministic variance facts from business interpretation.",
+            ],
+        },
+    }
+
+
+def _pvm_ladder_levels(
+    result: pl.DataFrame,
+    recipe: dict[str, Any],
+) -> list[dict[str, Any]]:
+    """Return the structured chart data behind the PVM decomposition ladder."""
+
+    total_delta = _numeric_column_sum(result, "total_delta")
+    price = _numeric_column_sum(result, "price_variance")
+    volume = _numeric_column_sum(result, "volume_variance")
+    mix = _numeric_column_sum(result, "mix_variance")
+    residual = total_delta - price - volume - mix
+    unit_label = "Units" if recipe["mappings"].get("units_column") else "Volume"
+    return [
+        {
+            "level": 1,
+            "calculation": f"Price & {unit_label.lower()} & mix",
+            "components": [
+                {
+                    "variance_type": f"Price & {unit_label.lower()} & mix",
+                    "variance_amount": total_delta,
+                    "source_columns": ["total_delta"],
+                    "is_residual_other": False,
+                }
+            ],
+        },
+        {
+            "level": 2,
+            "calculation": f"Price, {unit_label.lower()} & mix",
+            "components": [
+                {
+                    "variance_type": "Price",
+                    "variance_amount": price,
+                    "source_columns": ["price_variance"],
+                    "is_residual_other": False,
+                },
+                {
+                    "variance_type": f"{unit_label} & mix",
+                    "variance_amount": total_delta - price,
+                    "source_columns": [
+                        "volume_variance",
+                        "mix_variance",
+                        "component_reconciliation_delta",
+                    ],
+                    "is_residual_other": False,
+                },
+            ],
+        },
+        {
+            "level": 3,
+            "calculation": f"Price, {unit_label.lower()}, mix",
+            "components": [
+                {
+                    "variance_type": "Price",
+                    "variance_amount": price,
+                    "source_columns": ["price_variance"],
+                    "is_residual_other": False,
+                },
+                {
+                    "variance_type": unit_label,
+                    "variance_amount": volume,
+                    "source_columns": ["volume_variance"],
+                    "is_residual_other": False,
+                },
+                {
+                    "variance_type": "Mix",
+                    "variance_amount": mix,
+                    "source_columns": ["mix_variance"],
+                    "is_residual_other": False,
+                },
+                {
+                    "variance_type": "Other",
+                    "variance_amount": residual,
+                    "source_columns": ["component_reconciliation_delta"],
+                    "is_residual_other": True,
+                },
+            ],
+        },
+    ]
+
+
+def _pvm_decomposition_ladder_context(
+    result: pl.DataFrame,
+    recipe: dict[str, Any],
+    output_dir: Path,
+) -> dict[str, Any]:
+    """Return model-facing context for the PVM decomposition ladder."""
+
+    levels = _pvm_ladder_levels(result, recipe)
+    totals = {
+        "amount_baseline": _numeric_column_sum(result, "amount_baseline"),
+        "amount_comparison": _numeric_column_sum(result, "amount_comparison"),
+        "total_delta": _numeric_column_sum(result, "total_delta"),
+        "price_variance": _numeric_column_sum(result, "price_variance"),
+        "volume_variance": _numeric_column_sum(result, "volume_variance"),
+        "mix_variance": _numeric_column_sum(result, "mix_variance"),
+        "component_reconciliation_delta": _numeric_column_sum(
+            result, "component_reconciliation_delta"
+        ),
+    }
+    baseline_total = float(totals["amount_baseline"] or 0.0)
+    totals["delta_percent"] = (
+        (float(totals["total_delta"] or 0.0) / baseline_total) * 100
+        if abs(baseline_total) > TOLERANCE
+        else None
+    )
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "chart_id": "pvm_decomposition_ladder",
+        "chart_family": "variance_analysis",
+        "chart_type": "pvm_decomposition_ladder",
+        "chart_path": (
+            "charts/pvm_decomposition_ladder.png"
+            if (output_dir / "pvm_decomposition_ladder.png").exists()
+            else None
+        ),
+        "metric": (recipe.get("mappings") or {}).get("amount_column"),
+        "unit": (recipe.get("options") or {}).get("currency") or "EUR",
+        "comparison": _comparison_payload(recipe),
+        **_title_contract_payload(recipe, chart_kind="pvm_decomposition_ladder"),
+        "levels": levels,
+        "totals": totals,
+        "codex_interpretation_contract": {
+            "must_review_when_written": True,
+            "purpose": (
+                "Compare the same total variance under progressively richer "
+                "Price / Units / Mix decompositions before deciding which "
+                "breakdown is useful for the client story."
+            ),
+            "required_points": [
+                "State whether the one-line total variance hides offsetting components.",
+                "Explain what changes when Price is separated from Units & Mix.",
+                "Explain what changes when Units and Mix are separated.",
+                "Mention Other only when the reconciliation residual is material.",
+            ],
+        },
+    }
+
+
+def write_pvm_decomposition_ladder_chart_data(
+    result: pl.DataFrame,
+    recipe: dict[str, Any],
+    output_dir: Path,
+) -> tuple[list[str], dict[str, Any], str]:
+    """Write CSV and JSON data for the PVM decomposition ladder."""
+
+    if not bool(recipe.get("options", {}).get("pvm_decomposition_ladder", True)):
+        return [], {"status": "disabled"}, ""
+    if not recipe.get("mappings", {}).get("units_column"):
+        return (
+            [],
+            {
+                "status": "not_written_missing_units",
+                "reason": "PVM decomposition ladder requires a units column.",
+            },
+            "",
+        )
+    context = _pvm_decomposition_ladder_context(result, recipe, output_dir)
+    context_path = output_dir / "pvm_decomposition_ladder_context.json"
+    write_json(context_path, context)
+    rows = []
+    for level in context["levels"]:
+        for component in level["components"]:
+            rows.append(
+                {
+                    "level": level["level"],
+                    "calculation": level["calculation"],
+                    "variance_type": component["variance_type"],
+                    "variance_amount": component["variance_amount"],
+                    "is_residual_other": component["is_residual_other"],
+                    "source_columns": " | ".join(component["source_columns"]),
+                }
+            )
+    table_path = output_dir / "pvm_decomposition_ladder.csv"
+    pl.DataFrame(rows).write_csv(table_path)
+    spanish = _output_language(recipe.get("language")) == "es"
+    summary = [
+        "",
+        (
+            "## Escalera de descomposición PVM"
+            if spanish
+            else "## PVM Decomposition Ladder"
+        ),
+        "",
+        (
+            "Este gráfico compara la misma variación total en tres niveles de cálculo: Precio/Unidades/Mix combinados, Precio más Unidades y Mix, y Precio/Unidades/Mix por separado."
+            if spanish
+            else "This chart compares the same total variance at three calculation depths: combined Price/Units/Mix, Price plus Units & Mix, and Price/Units/Mix separately."
+        ),
+        "",
+    ]
+    for level in context["levels"]:
+        components = ", ".join(
+            f"{item['variance_type']} `{float(item['variance_amount']):,.2f}`"
+            for item in level["components"]
+            if abs(float(item["variance_amount"] or 0.0)) > TOLERANCE
+        )
+        summary.append(
+            f"- {'Nivel' if spanish else 'Level'} {level['level']} "
+            f"`{level['calculation']}`: {components}"
+        )
+    return (
+        [str(table_path), str(context_path)],
+        {
+            "status": "written",
+            "table": table_path.name,
+            "context": context_path.name,
+            "level_count": len(context["levels"]),
+            "component_row_count": len(rows),
+        },
+        "\n".join(summary) + "\n",
+    )
+
+
+def _load_optional_json(path: Path) -> dict[str, Any] | None:
+    """Load a JSON file when present and valid."""
+
+    if not path.exists():
+        return None
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def max_abs(df: pl.DataFrame, column: str) -> float | None:
+    """Return the maximum absolute value for a column when it exists."""
+
+    if column not in df.schema or df.is_empty():
+        return None
+    value = df.select(pl.col(column).abs().max()).item()
+    return float(value) if value is not None else None
+
+
+def build_audit(
+    input_path: Path,
+    recipe: dict[str, Any],
+    result: pl.DataFrame,
+    artifact_paths: list[str],
+    *,
+    client_engagement: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Build audit metadata for a variance run."""
+
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "generated_at": utc_now(),
+        "source_file": _source_reference(input_path, client_engagement),
+        "row_count": result.height,
+        "recipe": recipe,
+        "accounting_readiness": recipe.get("accounting_readiness"),
+        "checks": {
+            "max_abs_component_reconciliation_delta": max_abs(
+                result, "component_reconciliation_delta"
+            ),
+            "max_abs_margin_reconciliation_delta": max_abs(
+                result, "margin_mix_variance"
+            ),
+            "max_abs_margin_component_reconciliation_delta": max_abs(
+                result, "margin_component_reconciliation_delta"
+            ),
+        },
+        "outputs": {Path(path).name: "written" for path in artifact_paths},
+    }
+
+
+def top_driver_rows(result: pl.DataFrame, limit: int = 10) -> list[dict[str, Any]]:
+    """Return top variance rows by absolute total delta."""
+
+    if result.is_empty():
+        return []
+    return (
+        result.with_columns(pl.col("total_delta").abs().alias("_abs_delta"))
+        .sort("_abs_delta", descending=True)
+        .drop("_abs_delta")
+        .head(limit)
+        .to_dicts()
+    )
+
+
+def build_summary_markdown(result: pl.DataFrame, recipe: dict[str, Any]) -> str:
+    """Build deterministic markdown for Codex to interpret."""
+
+    mappings = recipe["mappings"]
+    options = recipe.get("options") or {}
+    spanish = _output_language(recipe.get("language")) == "es"
+    labels = (
+        {
+            "title": "Datos fuente del análisis de variaciones",
+            "comparison_basis": "Base de comparación",
+            "period_mode": "Modo de comparación de periodos",
+            "baseline": "Periodo base",
+            "comparison": "Periodo de comparación",
+            "amount": "Columna de importe",
+            "dimensions": "Dimensiones",
+            "grain": "Nivel de cálculo",
+            "rows": "Filas de resultados",
+            "totals": "Totales",
+            "date_column": "Columna de fecha",
+            "baseline_window": "Ventana de fechas base",
+            "comparison_window": "Ventana de fechas de comparación",
+            "drivers": "Principales factores por valor absoluto",
+            "total": "Total",
+            "boundary": "Límite de interpretación",
+            "boundary_text": "Las cifras anteriores son cálculos deterministas. Codex debe utilizarlas como datos fuente, identificar los factores principales, señalar asignaciones ausentes o salvedades por denominadores cero y no modificar silenciosamente los resultados deterministas.",
+            "to": "a",
+            "unknown": "desconocido",
+        }
+        if spanish
+        else {
+            "title": "Variance Analysis Source Data",
+            "comparison_basis": "Comparison basis",
+            "period_mode": "Period comparison mode",
+            "baseline": "Baseline period",
+            "comparison": "Comparison period",
+            "amount": "Amount column",
+            "dimensions": "Dimensions",
+            "grain": "Calculation grain",
+            "rows": "Result rows",
+            "totals": "Totals",
+            "date_column": "Date column",
+            "baseline_window": "Baseline date window",
+            "comparison_window": "Comparison date window",
+            "drivers": "Largest Absolute Drivers",
+            "total": "Total",
+            "boundary": "Interpretation Boundary",
+            "boundary_text": "The figures above are deterministic calculations. Codex should use them as source data, identify the largest drivers, call out missing mappings or zero-denominator caveats, and avoid changing deterministic results silently.",
+            "to": "to",
+            "unknown": "unknown",
+        }
+    )
+    lines = [
+        f"# {labels['title']}",
+        "",
+        f"- {labels['comparison_basis']}: `{options.get('comparison_basis') or labels['unknown']}`",
+        f"- {labels['period_mode']}: `{options.get('period_comparison_mode') or labels['unknown']}`",
+        f"- {labels['baseline']}: `{mappings['baseline_period']}`",
+        f"- {labels['comparison']}: `{mappings['comparison_period']}`",
+        f"- {labels['amount']}: `{mappings['amount_column']}`",
+        f"- {labels['dimensions']}: `{', '.join(mappings.get('dimensions') or [labels['total']])}`",
+        f"- {labels['grain']}: `{', '.join(mappings.get('calculation_grain') or mappings.get('dimensions') or [labels['total']])}`",
+        f"- {labels['rows']}: `{result.height}`",
+        "",
+        f"## {labels['totals']}",
+        "",
+    ]
+    period_window = options.get("period_window") or {}
+    if period_window:
+        baseline = period_window.get("baseline", {})
+        comparison = period_window.get("comparison", {})
+        lines[7:7] = [
+            f"- {labels['date_column']}: `{period_window.get('date_column')}`",
+            (
+                f"- {labels['baseline_window']}: "
+                f"`{baseline.get('start_date')}` {labels['to']} `{baseline.get('end_date')}`"
+            ),
+            (
+                f"- {labels['comparison_window']}: "
+                f"`{comparison.get('start_date')}` {labels['to']} `{comparison.get('end_date')}`"
+            ),
+        ]
+    totals = result.select(
+        [
+            pl.col("total_delta").sum().alias("total_delta"),
+            *[
+                pl.col(column).sum().alias(column)
+                for column in (
+                    "price_variance",
+                    "volume_variance",
+                    "mix_variance",
+                    "net_delta",
+                    "margin_delta",
+                    "cogs_delta",
+                )
+                if column in result.schema
+            ],
+        ]
+    ).to_dicts()[0]
+    for key, value in totals.items():
+        lines.append(
+            f"- `{key}`: {value:,.2f}"
+            if isinstance(value, (int, float))
+            else f"- `{key}`: {value}"
+        )
+    lines.extend(["", f"## {labels['drivers']}", ""])
+    for row in top_driver_rows(result, 10):
+        dims = [
+            f"{dimension}={row.get(dimension)}"
+            for dimension in mappings.get("dimensions") or ["segment"]
+            if dimension in row
+        ]
+        label = ", ".join(dims) if dims else labels["total"]
+        delta = row.get("total_delta")
+        lines.append(f"- {label}: total_delta={float(delta):,.2f}")
+    lines.extend(
+        [
+            "",
+            f"## {labels['boundary']}",
+            "",
+            labels["boundary_text"],
+        ]
+    )
+    return "\n".join(lines) + "\n"
+
+
+def append_bridge_dimension_summary(
+    summary: str,
+    bridge_audit: dict[str, Any] | None,
+    *,
+    language: str = "en",
+) -> str:
+    """Append requested-versus-emitted root-cause dimensions to the summary."""
+
+    if not bridge_audit or not bridge_audit.get("enabled"):
+        return summary
+
+    spanish = _output_language(language) == "es"
+
+    def formatted(values: Any) -> str:
+        if not values:
+            return "`ninguna`" if spanish else "`none`"
+        return "`" + ", ".join(values) + "`"
+
+    lines = [
+        "",
+        (
+            "## Análisis de las causas de la variación"
+            if spanish
+            else "## Root-Cause Variance Analysis"
+        ),
+        "",
+        (
+            "- Dimensiones solicitadas del informe: "
+            if spanish
+            else "- Requested report dimensions: "
+        )
+        + formatted(bridge_audit.get("requested_report_dimensions")),
+        (
+            "- Nivel de cálculo solicitado: "
+            if spanish
+            else "- Requested calculation grain: "
+        )
+        + formatted(bridge_audit.get("requested_calculation_grain")),
+        (
+            "- Dimensiones efectivas de causa: "
+            if spanish
+            else "- Effective root-cause dimensions: "
+        )
+        + formatted(bridge_audit.get("effective_bridge_dimensions")),
+        (
+            "- Dimensiones de causa generadas: "
+            if spanish
+            else "- Emitted root-cause dimensions: "
+        )
+        + formatted(bridge_audit.get("emitted_bridge_dimensions")),
+        (
+            "- Dimensiones de causa descartadas: "
+            if spanish
+            else "- Dropped root-cause dimensions: "
+        )
+        + formatted(bridge_audit.get("dropped_bridge_dimensions")),
+        (
+            "- Dimensiones de causa añadidas internamente: "
+            if spanish
+            else "- Internally added root-cause dimensions: "
+        )
+        + formatted(bridge_audit.get("internally_added_bridge_dimensions")),
+    ]
+    return summary.rstrip() + "\n" + "\n".join(lines) + "\n"
+
+
+def _root_cause_dimension_columns(frame: pl.DataFrame) -> list[str]:
+    """Return active dimension columns in a normalized root-cause bridge frame."""
+
+    return [
+        column
+        for column in frame.columns
+        if column not in ROOT_CAUSE_BRIDGE_MEASURE_COLUMNS
+    ]
+
+
+def _root_cause_row_label(row: dict[str, Any], dimensions: list[str]) -> str:
+    """Return a compact business label for a selected root-cause row."""
+
+    inactive_values = {"", "All", "N/A", "None", "null"}
+    values = [
+        str(row.get(dimension))
+        for dimension in dimensions
+        if row.get(dimension) is not None
+        and str(row.get(dimension)) not in inactive_values
+    ]
+    label = " / ".join(values) if values else "Total"
+    variance_type = row.get("variance_type")
+    if variance_type is not None and str(variance_type):
+        label = f"{label} - {variance_type}"
+    return label
+
+
+def _root_cause_total_delta(result: pl.DataFrame) -> float:
+    """Return the overall comparison minus baseline delta for bridge residuals."""
+
+    if result.is_empty():
+        return 0.0
+    values = result.select(
+        (pl.col("amount_comparison").sum() - pl.col("amount_baseline").sum()).alias(
+            "total_delta"
+        )
+    ).to_dicts()[0]
+    return float(values["total_delta"] or 0.0)
+
+
+def _root_cause_selected_sum(frame: pl.DataFrame) -> float:
+    """Return the selected legacy sequence variance sum."""
+
+    if frame.is_empty() or "variance_amount" not in frame.schema:
+        return 0.0
+    value = frame.select(pl.col("variance_amount").sum()).item()
+    return float(value or 0.0)
+
+
+def _root_cause_sequence_payload(
+    *,
+    alternative_result: int,
+    frame: pl.DataFrame,
+    audit: dict[str, Any],
+    result: pl.DataFrame,
+    bridge_path: Path | None,
+    chart_path: Path | None,
+) -> dict[str, Any]:
+    """Return model-facing metadata for one root-cause alternative."""
+
+    dimensions = _root_cause_dimension_columns(frame)
+    rows = [
+        {
+            "row_number": index + 1,
+            "label": _root_cause_row_label(row, dimensions),
+            "variance_amount": float(row.get("variance_amount") or 0.0),
+            "bridge_dimensions": row.get("bridge_dimensions"),
+            "variance_type": row.get("variance_type"),
+        }
+        for index, row in enumerate(frame.to_dicts())
+    ]
+    drilldown_row_numbers: list[int] = []
+    for audit_key in ("drilldown_requested_rows", "automatic_drilldown_rows"):
+        for value in audit.get(audit_key, []) or []:
+            try:
+                row_number = int(value)
+            except (TypeError, ValueError):
+                continue
+            if row_number > 0 and row_number not in drilldown_row_numbers:
+                drilldown_row_numbers.append(row_number)
+    child_artifacts = []
+    for row_number in drilldown_row_numbers:
+        parent_row = rows[row_number - 1] if row_number <= len(rows) else {}
+        child_artifacts.append(
+            {
+                "child_type": "alternative_drilldown",
+                "capability_id": "variance.root_cause_alternative_sweep",
+                "parent_capability_id": "variance.root_cause_alternative_sweep",
+                "parent_child_type": "alternative_sequence",
+                "parent_artifact_id": f"root_cause_bridge_alt_{alternative_result}",
+                "alternative_result": alternative_result,
+                "drilldown_row": row_number,
+                "parent_row_number": row_number,
+                "parent_row_label": parent_row.get("label", ""),
+                "parent_row_bridge_dimensions": parent_row.get("bridge_dimensions"),
+                "parent_row_variance_type": parent_row.get("variance_type"),
+                "parent_row_variance_amount": parent_row.get("variance_amount"),
+                "artifact_id": (
+                    f"root_cause_bridge_alt_{alternative_result}"
+                    f"_drilldown_row_{row_number}"
+                ),
+                "chart_artifact": (
+                    f"root_cause_bridge_alt_{alternative_result}"
+                    f"_drilldown_row_{row_number}.png"
+                ),
+                "table_artifact": (
+                    f"root_cause_bridge_alt_{alternative_result}"
+                    f"_drilldown_row_{row_number}.csv"
+                ),
+            }
+        )
+    total_delta = _root_cause_total_delta(result)
+    selected_sum = _root_cause_selected_sum(frame)
+    return {
+        "alternative_result": alternative_result,
+        "row_count": frame.height,
+        "selected_rows": rows,
+        "selected_sequence_bridge_dimensions": audit.get(
+            "selected_sequence_bridge_dimensions", []
+        ),
+        "selected_sequence_unique_bridge_dimensions": audit.get(
+            "selected_sequence_unique_bridge_dimensions", []
+        ),
+        "selected_sequence_has_mixed_dimensions": bool(
+            audit.get("selected_sequence_has_mixed_dimensions", False)
+        ),
+        "total_delta": total_delta,
+        "selected_sequence_sum": selected_sum,
+        "other_residual": total_delta - selected_sum,
+        "drilldown_status": audit.get("drilldown_status"),
+        "drilldown_requested_rows": audit.get("drilldown_requested_rows", []),
+        "automatic_drilldown_mode": audit.get("automatic_drilldown_mode", "none"),
+        "automatic_drilldown_rows": audit.get("automatic_drilldown_rows", []),
+        "child_artifacts": child_artifacts,
+        "bridge_path": str(bridge_path) if bridge_path else "",
+        "chart_path": str(chart_path) if chart_path else "",
+    }
+
+
+def _root_cause_resolved_parameters(
+    recipe: dict[str, Any],
+    audit: dict[str, Any],
+) -> dict[str, Any]:
+    """Return the formal request parameters resolved by the root-cause runtime."""
+
+    mappings = recipe.get("mappings") or {}
+    options = recipe.get("options") or {}
+    return {
+        key: json_safe(value)
+        for key, value in {
+            "metric": mappings.get("amount_column"),
+            "units_metric": mappings.get("units_column"),
+            "comparison_basis": options.get("comparison_basis"),
+            "baseline_period": mappings.get("baseline_period"),
+            "comparison_period": mappings.get("comparison_period"),
+            "period_column": mappings.get("period_column"),
+            "date_column": mappings.get("date_column"),
+            "dimensions": mappings.get("dimensions") or [],
+            "calculation_grain": mappings.get("calculation_grain") or [],
+            "effective_bridge_dimensions": audit.get("effective_bridge_dimensions"),
+            "emitted_bridge_dimensions": audit.get("emitted_bridge_dimensions"),
+            "dropped_bridge_dimensions": audit.get("dropped_bridge_dimensions"),
+            "alternative_result": audit.get("alternative_result"),
+            "filters": options.get("recipe_filter_audit")
+            or recipe.get("filters")
+            or options.get("filters"),
+            "population_preparation": options.get("recipe_cohort_audit")
+            or options.get("cohort_definition")
+            or recipe.get("cohorts")
+            or options.get("cohorts"),
+        }.items()
+        if value is not None and value != "" and value != [] and value != {}
+    }
+
+
+def _write_root_cause_bridge_context(
+    *,
+    frame: pl.DataFrame,
+    result: pl.DataFrame,
+    recipe: dict[str, Any],
+    audit: dict[str, Any],
+    output_dir: Path,
+    bridge_path: Path,
+    chart_path: Path | None,
+    context_name: str = "root_cause_total_bridge_context.json",
+    analysis_type: str = "root_cause_total_bridge",
+    capability_id: str = "variance.root_cause_total_bridge",
+    chart_type: str = "root_cause_total_bridge",
+) -> Path:
+    """Write the structured payload behind the main root-cause bridge."""
+
+    variance_mode = str(audit.get("root_cause_variance_mode") or "total_variance")
+    if variance_mode == "component_variance":
+        deterministic_boundary = (
+            "The plugin selected and reconciled component-by-dimension rows. "
+            "Codex may interpret whether the component bridge is useful, but "
+            "must not change calculated rows, component types, amounts, "
+            "dimensions, or residuals."
+        )
+        required_points = [
+            "Treat this as second-order diagnostic source data.",
+            "Read each row as a variance component for a selected slice.",
+            "Do not describe component rows as having meaningful initial/final row bars.",
+            "Do not invent causes outside the generated component rows.",
+        ]
+    else:
+        deterministic_boundary = (
+            "The plugin selected and reconciled total-variance root-cause rows. "
+            "Codex may interpret whether the bridge is useful, but must not "
+            "change calculated rows, amounts, dimensions, or residuals."
+        )
+        required_points = [
+            "State that each selected row is total variance for that slice.",
+            "Use baseline and comparison row values where they are present.",
+            "Call out when a selected sequence mixes dimensions.",
+            "Use generated drilldown artifacts only when they exist.",
+            "Do not invent causes outside the generated bridge rows.",
+        ]
+    payload = {
+        "schema_version": SCHEMA_VERSION,
+        "analysis_type": analysis_type,
+        "capability_id": capability_id,
+        "chart_family": "variance_analysis",
+        "chart_type": chart_type,
+        "root_cause_variance_mode": variance_mode,
+        "metric": (recipe.get("mappings") or {}).get("amount_column"),
+        "comparison": _comparison_payload(recipe),
+        "resolved_parameters": _root_cause_resolved_parameters(recipe, audit),
+        "main_sequence": _root_cause_sequence_payload(
+            alternative_result=int(audit.get("alternative_result") or 1),
+            frame=frame,
+            audit=audit,
+            result=result,
+            bridge_path=bridge_path,
+            chart_path=chart_path,
+        ),
+        "runtime_audit": {
+            "variable_bridge_source": audit.get("variable_bridge_source"),
+            "legacy_processing_choice": audit.get("legacy_processing_choice"),
+            "legacy_variance_aggregation": audit.get("legacy_variance_aggregation"),
+            "plugin_variance_aggregation": audit.get("plugin_variance_aggregation"),
+            "root_cause_variance_mode": audit.get("root_cause_variance_mode"),
+            "selected_sequence_has_mixed_dimensions": audit.get(
+                "selected_sequence_has_mixed_dimensions"
+            ),
+            "selected_sequence_unique_bridge_dimensions": audit.get(
+                "selected_sequence_unique_bridge_dimensions"
+            ),
+            "drilldown_status": audit.get("drilldown_status"),
+            "moved_rows_status": audit.get("moved_rows_status"),
+            "alternative_sweep_enabled": audit.get("alternative_sweep_enabled"),
+            "alternative_sweep_values": audit.get("alternative_sweep_values"),
+        },
+        "codex_interpretation_contract": {
+            "must_review_when_written": True,
+            "deterministic_boundary": deterministic_boundary,
+            "required_points": required_points,
+        },
+    }
+    context_path = output_dir / context_name
+    write_json(context_path, payload)
+    return context_path
+
+
+def _root_cause_sweep_interpretation_contract() -> dict[str, Any]:
+    """Return the model-facing contract for root-cause sweep interpretation."""
+
+    return {
+        "codex_output_file": "codex_root_cause_sweep_analysis.md",
+        "deterministic_boundary": (
+            "The plugin has already selected and reconciled the alternatives. "
+            "Codex may interpret, compare, and recommend drilldowns, but must "
+            "not change calculated rows, amounts, dimensions, or residuals."
+        ),
+        "required_interpretation_points": [
+            "Separate deterministic facts from business interpretation.",
+            "Identify which alternatives are genuinely mixed-dimension.",
+            "Explain that each row is residual after earlier selected rows.",
+            "Rank alternatives as useful, possibly useful, or misleading/noisy.",
+            "Recommend drilldowns only from generated rows and detail outputs.",
+            "State caveats where labels, currency assumptions, units, or hierarchy meaning are missing.",
+        ],
+        "forbidden_claims": [
+            "Do not describe same-dimension alternatives as mixed variable-dimension bridges.",
+            "Do not interpret a later mixed row as the total for that dimension.",
+            "Do not fabricate rows or causes that are not in the generated files.",
+        ],
+    }
+
+
+def _format_root_cause_brief_amount(value: Any) -> str:
+    """Format a root-cause amount for a markdown interpretation brief."""
+
+    try:
+        return f"{float(value):,.1f}"
+    except (TypeError, ValueError):
+        return str(value)
+
+
+def _root_cause_sweep_interpretation_brief(
+    *,
+    context_payload: dict[str, Any],
+    summary_rows: list[dict[str, Any]],
+) -> str:
+    """Return a Codex-facing markdown brief for root-cause sweep analysis."""
+
+    contract = context_payload["codex_interpretation_contract"]
+    spanish = _output_language(context_payload.get("language")) == "es"
+    required_points = (
+        [
+            "Separe los hechos deterministas de la interpretación empresarial.",
+            "Identifique qué alternativas combinan realmente varias dimensiones.",
+            "Explique que cada fila es el residual después de las filas seleccionadas anteriormente.",
+            "Clasifique las alternativas como útiles, posiblemente útiles o engañosas/ruidosas.",
+            "Recomiende desgloses solo a partir de las filas y los detalles generados.",
+            "Indique las salvedades cuando falten etiquetas, supuestos de moneda, unidades o el significado de la jerarquía.",
+        ]
+        if spanish
+        else contract["required_interpretation_points"]
+    )
+    forbidden_claims = (
+        [
+            "No describa alternativas de una sola dimensión como puentes de dimensiones variables.",
+            "No interprete una fila mixta posterior como el total de esa dimensión.",
+            "No invente filas ni causas que no figuren en los archivos generados.",
+        ]
+        if spanish
+        else contract["forbidden_claims"]
+    )
+    lines = [
+        (
+            "# Guía de Codex para interpretar el barrido de causas"
+            if spanish
+            else "# Codex Root-Cause Sweep Interpretation Brief"
+        ),
+        "",
+        (
+            "Este archivo sirve de entrega al modelo. Las cifras son deterministas; Codex debe realizar la interpretación narrativa."
+            if spanish
+            else "This file is a model-facing handoff. The figures are deterministic; the narrative interpretation is Codex's job."
+        ),
+        "",
+        "## Salida que debe redactarse" if spanish else "## Output To Write",
+        "",
+        f"- {'Redacte' if spanish else 'Write'}: `{contract['codex_output_file']}`",
+        (
+            "- Utilice: `root_cause_sweep_model_context.json`, `root_cause_sweep_summary.csv` y los gráficos `root_cause_bridge_alt_<n>.png` generados."
+            if spanish
+            else "- Use: `root_cause_sweep_model_context.json`, `root_cause_sweep_summary.csv`, and the generated `root_cause_bridge_alt_<n>.png` charts."
+        ),
+        "",
+        "## Límite de interpretación" if spanish else "## Interpretation Boundary",
+        "",
+        (
+            "- El plugin ya ha seleccionado y conciliado las alternativas. Codex puede interpretarlas, compararlas y recomendar desgloses, pero no debe modificar las filas, los importes, las dimensiones ni los residuales calculados."
+            if spanish
+            else f"- {contract['deterministic_boundary']}"
+        ),
+        (
+            "- Las filas posteriores son residuales después de las filas seleccionadas anteriormente, no totales independientes de esa dimensión."
+            if spanish
+            else "- Later rows are residual after earlier selected rows, not standalone totals for that dimension."
+        ),
+        "",
+        "## Análisis requerido" if spanish else "## Required Analysis",
+        "",
+    ]
+    lines.extend(f"- {item}" for item in required_points)
+    lines.extend(
+        [
+            "",
+            "## Afirmaciones prohibidas" if spanish else "## Forbidden Claims",
+            "",
+        ]
+    )
+    lines.extend(f"- {item}" for item in forbidden_claims)
+    lines.extend(
+        [
+            "",
+            "## Resumen de alternativas" if spanish else "## Alternative Overview",
+            "",
+            (
+                "| Alternativa | Filas | Dimensiones mixtas | Residual Otros | Desglose | Filas seleccionadas |"
+                if spanish
+                else "| Alternative | Rows | Mixed dimensions | Other residual | Drilldown | Selected rows |"
+            ),
+            "| --- | ---: | --- | ---: | --- | --- |",
+        ]
+    )
+    for row in summary_rows:
+        selected_labels = str(row.get("selected_labels") or "").replace("|", "/")
+        lines.append(
+            "| "
+            f"{row.get('alternative_result')} | "
+            f"{row.get('row_count')} | "
+            f"{row.get('selected_sequence_has_mixed_dimensions')} | "
+            f"{_format_root_cause_brief_amount(row.get('other_residual'))} | "
+            f"{row.get('drilldown_status')} | "
+            f"{selected_labels} |"
+        )
+    lines.extend(
+        [
+            "",
+            "## Estructura recomendada" if spanish else "## Recommended Structure",
+            "",
+            (
+                "1. Lectura ejecutiva: qué alternativas son más útiles y por qué."
+                if spanish
+                else "1. Executive read: which alternatives are most useful and why."
+            ),
+            (
+                "2. Hechos deterministas: variación total, filas seleccionadas, residuales e indicadores de dimensiones mixtas."
+                if spanish
+                else "2. Deterministic facts: total delta, selected rows, residuals, and mixed-dimension flags."
+            ),
+            (
+                "3. Interpretación: qué sugieren las alternativas útiles, explicando la lógica residual."
+                if spanish
+                else "3. Interpretation: what the useful alternatives suggest, with residual logic explained."
+            ),
+            (
+                "4. Recomendaciones de desglose: qué filas generadas requieren seguimiento."
+                if spanish
+                else "4. Drilldown recommendations: which generated rows deserve follow-up."
+            ),
+            (
+                "5. Salvedades: etiquetas, supuestos de moneda, significado ausente de la jerarquía y alternativas ruidosas o engañosas."
+                if spanish
+                else "5. Caveats: labels, currency assumptions, missing hierarchy meaning, and alternatives that are noisy or misleading."
+            ),
+            "",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def _legacy_chart_not_written_audit(
+    exc: BaseException,
+    *,
+    artifact_name: str,
+) -> dict[str, Any]:
+    """Describe a non-blocking legacy chart render failure for audit output."""
+
+    return {
+        "status": "not_written_legacy_error",
+        "artifact": artifact_name,
+        "error": str(exc),
+        "exception_type": exc.__class__.__name__,
+    }
+
+
+def _write_root_cause_sweep_outputs(
+    bridge_result: Any,
+    result: pl.DataFrame,
+    recipe: dict[str, Any],
+    output_dir: Path,
+    *,
+    render: bool = True,
+) -> tuple[list[str], dict[str, Any]]:
+    """Write root-cause alternative sweep data and optional PNG artifacts."""
+
+    if not bridge_result.sweep_runs:
+        return [], {}
+    paths: list[str] = []
+    chart_audits: dict[str, Any] = {}
+    alternatives: list[dict[str, Any]] = []
+    for alternative, alternative_run in sorted(bridge_result.sweep_runs.items()):
+        sequence = alternative_run.sequence
+        bridge_path: Path | None = None
+        chart_path: Path | None = None
+        if not sequence.frame.is_empty():
+            bridge_path = output_dir / f"root_cause_bridge_alt_{alternative}.csv"
+            sequence.frame.write_csv(bridge_path)
+            paths.append(str(bridge_path))
+            chart_artifact = f"root_cause_bridge_alt_{alternative}.png"
+            if render:
+                try:
+                    chart_export = write_root_cause_bridge_png(
+                        sequence.frame,
+                        result,
+                        recipe,
+                        output_dir,
+                        artifact_name=chart_artifact,
+                        legacy_frame=sequence.legacy_frame,
+                        legacy_param=sequence.param,
+                        legacy_chart=bridge_result.chart,
+                        legacy_index_cols=bridge_result.bridge_dimensions,
+                    )
+                    paths.extend(chart_export.paths)
+                    chart_audits[str(alternative)] = chart_export.audit
+                    chart_path = output_dir / chart_artifact
+                except LEGACY_RENDER_ERRORS as exc:
+                    chart_audits[str(alternative)] = _legacy_chart_not_written_audit(
+                        exc,
+                        artifact_name=chart_artifact,
+                    )
+            else:
+                chart_audits[str(alternative)] = _data_written_chart_audit(
+                    chart_type=f"root_cause_bridge_alt_{alternative}",
+                    artifact_name=chart_artifact,
+                    source_functions=[
+                        "legacy_adapter.run_legacy_variable_dimension_bridge"
+                    ],
+                )
+        if (
+            alternative_run.audit.get("drilldown_requested_rows")
+            and not sequence.details_frame.is_empty()
+        ):
+            details_path = (
+                output_dir / f"root_cause_bridge_alt_{alternative}_details.csv"
+            )
+            sequence.details_frame.write_csv(details_path)
+            paths.append(str(details_path))
+        if (
+            alternative_run.audit.get("drilldown_requested_rows")
+            and not sequence.snapshot_frame.is_empty()
+        ):
+            snapshot_path = (
+                output_dir / f"root_cause_bridge_alt_{alternative}_snapshot.csv"
+            )
+            sequence.snapshot_frame.write_csv(snapshot_path)
+            paths.append(str(snapshot_path))
+        drilldown_chart_audits: dict[str, Any] = {}
+        for row, drilldown_run in sorted(alternative_run.drilldown_runs.items()):
+            if drilldown_run.frame.is_empty():
+                continue
+            drilldown_path = (
+                output_dir
+                / f"root_cause_bridge_alt_{alternative}_drilldown_row_{row}.csv"
+            )
+            drilldown_run.frame.write_csv(drilldown_path)
+            paths.append(str(drilldown_path))
+            parent_result = sequence.frame.slice(row - 1, 1)
+            if parent_result.is_empty():
+                continue
+            drilldown_artifact = (
+                f"root_cause_bridge_alt_{alternative}_drilldown_row_{row}.png"
+            )
+            if render:
+                try:
+                    drilldown_chart = write_root_cause_bridge_png(
+                        drilldown_run.frame,
+                        parent_result,
+                        recipe,
+                        output_dir,
+                        artifact_name=drilldown_artifact,
+                        legacy_frame=drilldown_run.legacy_frame,
+                        legacy_param=drilldown_run.param,
+                        legacy_chart=bridge_result.chart,
+                        legacy_index_cols=bridge_result.bridge_dimensions,
+                    )
+                    paths.extend(drilldown_chart.paths)
+                    drilldown_chart_audits[str(row)] = drilldown_chart.audit
+                except LEGACY_RENDER_ERRORS as exc:
+                    drilldown_chart_audits[str(row)] = _legacy_chart_not_written_audit(
+                        exc,
+                        artifact_name=drilldown_artifact,
+                    )
+            else:
+                drilldown_chart_audits[str(row)] = _data_written_chart_audit(
+                    chart_type=(
+                        f"root_cause_bridge_alt_{alternative}_drilldown_row_{row}"
+                    ),
+                    artifact_name=drilldown_artifact,
+                    source_functions=[
+                        "legacy_adapter.run_legacy_variable_dimension_bridge"
+                    ],
+                )
+        if drilldown_chart_audits:
+            chart_audits[f"{alternative}_drilldowns"] = drilldown_chart_audits
+        alternatives.append(
+            _root_cause_sequence_payload(
+                alternative_result=alternative,
+                frame=sequence.frame,
+                audit=alternative_run.audit,
+                result=result,
+                bridge_path=bridge_path,
+                chart_path=chart_path,
+            )
+        )
+    summary_rows = [
+        {
+            "alternative_result": alternative["alternative_result"],
+            "row_count": alternative["row_count"],
+            "selected_labels": " | ".join(
+                row["label"] for row in alternative["selected_rows"]
+            ),
+            "selected_amounts": " | ".join(
+                f"{row['variance_amount']:.6f}" for row in alternative["selected_rows"]
+            ),
+            "selected_sequence_bridge_dimensions": " | ".join(
+                str(value)
+                for value in alternative["selected_sequence_bridge_dimensions"]
+            ),
+            "selected_sequence_has_mixed_dimensions": alternative[
+                "selected_sequence_has_mixed_dimensions"
+            ],
+            "other_residual": alternative["other_residual"],
+            "drilldown_status": alternative["drilldown_status"],
+            "automatic_drilldown_rows": " | ".join(
+                str(value) for value in alternative["automatic_drilldown_rows"]
+            ),
+            "bridge_path": alternative["bridge_path"],
+            "chart_path": alternative["chart_path"],
+        }
+        for alternative in alternatives
+    ]
+    if summary_rows:
+        summary_path = output_dir / "root_cause_sweep_summary.csv"
+        pl.DataFrame(summary_rows).write_csv(summary_path)
+        paths.append(str(summary_path))
+    context_payload = {
+        "analysis_type": "root_cause_alternative_sweep",
+        "language": _output_language(recipe.get("language")),
+        "codex_interpretation_contract": _root_cause_sweep_interpretation_contract(),
+        "interpretation_rule": (
+            "Each selected row is residual after all prior selected rows have "
+            "been removed; mixed dimensions are valid but require this reading."
+        ),
+        "alternatives": alternatives,
+    }
+    client_report_paths, client_report_audit = write_root_cause_client_report(
+        summary_rows=summary_rows,
+        recipe=recipe,
+        output_dir=output_dir,
+    )
+    paths.extend(client_report_paths)
+    context_payload["client_report"] = client_report_audit
+    chart_audits["client_report"] = client_report_audit
+    context_path = output_dir / "root_cause_sweep_model_context.json"
+    write_json(context_path, context_payload)
+    paths.append(str(context_path))
+    summary_json_path = output_dir / "root_cause_sweep_summary.json"
+    write_json(summary_json_path, {"alternatives": summary_rows})
+    paths.append(str(summary_json_path))
+    brief_path = output_dir / "root_cause_sweep_interpretation_brief.md"
+    brief_path.write_text(
+        _root_cause_sweep_interpretation_brief(
+            context_payload=context_payload,
+            summary_rows=summary_rows,
+        ),
+        encoding="utf-8",
+    )
+    paths.append(str(brief_path))
+    return paths, chart_audits
+
+
+def write_root_cause_bridge(
+    df: pl.DataFrame,
+    result: pl.DataFrame,
+    recipe: dict[str, Any],
+    output_dir: Path,
+    *,
+    render: bool = True,
+) -> tuple[list[str], dict[str, Any] | None, dict[str, Any] | None]:
+    """Write root-cause data and optionally render bridge PNG artifacts."""
+
+    if not bool(recipe["options"].get("root_cause_bridge")):
+        return [], None, None
+    try:
+        bridge_result = run_legacy_variable_dimension_bridge(df, recipe)
+    except LEGACY_RENDER_ERRORS as exc:
+        LOGGER.warning("Root-cause bridge was not written: %s", exc)
+        return (
+            [],
+            {
+                "enabled": True,
+                "status": "not_written_legacy_error",
+                "reason": str(exc),
+                "exception_type": exc.__class__.__name__,
+            },
+            None,
+        )
+    paths: list[str] = []
+    drilldown_requested = bool(
+        bridge_result.audit.get("drilldown_requested_rows")
+        or bridge_result.audit.get("moved_rows_requested")
+    )
+    if not bridge_result.candidate_frame.is_empty():
+        candidate_path = output_dir / "root_cause_bridge_candidates.csv"
+        bridge_result.candidate_frame.write_csv(candidate_path)
+        paths.append(str(candidate_path))
+    if drilldown_requested and not bridge_result.details_frame.is_empty():
+        details_path = output_dir / "root_cause_bridge_details.csv"
+        bridge_result.details_frame.write_csv(details_path)
+        paths.append(str(details_path))
+    if drilldown_requested and not bridge_result.snapshot_frame.is_empty():
+        snapshot_path = output_dir / "root_cause_bridge_snapshot.csv"
+        bridge_result.snapshot_frame.write_csv(snapshot_path)
+        paths.append(str(snapshot_path))
+    if bridge_result.frame.is_empty():
+        return paths, bridge_result.audit, None
+    bridge_path = output_dir / "root_cause_total_bridge.csv"
+    bridge_result.frame.write_csv(bridge_path)
+    paths.append(str(bridge_path))
+    chart_paths: list[str] = []
+    chart_path: Path | None = None
+    if render:
+        try:
+            chart_export = write_root_cause_bridge_png(
+                bridge_result.frame,
+                result,
+                recipe,
+                output_dir,
+                artifact_name="root_cause_total_bridge.png",
+                variance_mode="total_variance",
+                legacy_frame=bridge_result.legacy_frame,
+                legacy_param=bridge_result.param,
+                legacy_chart=bridge_result.chart,
+                legacy_index_cols=bridge_result.bridge_dimensions,
+            )
+            chart_paths = chart_export.paths
+            chart_audit = chart_export.audit
+            chart_path_value = chart_audit.get("path")
+            chart_path = Path(str(chart_path_value)) if chart_path_value else None
+        except LEGACY_RENDER_ERRORS as exc:
+            LOGGER.warning("Root-cause bridge chart was not written: %s", exc)
+            chart_audit = _legacy_chart_not_written_audit(
+                exc,
+                artifact_name="root_cause_total_bridge.png",
+            )
+    else:
+        chart_audit = _data_written_chart_audit(
+            chart_type=VARIANCE_CHART_ROOT_CAUSE,
+            artifact_name="root_cause_total_bridge.png",
+            source_functions=["legacy_adapter.run_legacy_variable_dimension_bridge"],
+        )
+        bridge_result.audit["status"] = "data_written"
+        bridge_result.audit["rendered"] = False
+    drilldown_chart_audits: dict[str, Any] = {}
+    for row, drilldown_run in sorted(bridge_result.drilldown_runs.items()):
+        if drilldown_run.frame.is_empty():
+            continue
+        drilldown_path = output_dir / f"root_cause_total_bridge_drilldown_row_{row}.csv"
+        drilldown_run.frame.write_csv(drilldown_path)
+        paths.append(str(drilldown_path))
+        parent_result = bridge_result.frame.slice(row - 1, 1)
+        if parent_result.is_empty():
+            continue
+        drilldown_artifact = f"root_cause_total_bridge_drilldown_row_{row}.png"
+        if render:
+            try:
+                drilldown_chart = write_root_cause_bridge_png(
+                    drilldown_run.frame,
+                    parent_result,
+                    recipe,
+                    output_dir,
+                    artifact_name=drilldown_artifact,
+                    variance_mode="total_variance",
+                    legacy_frame=drilldown_run.legacy_frame,
+                    legacy_param=drilldown_run.param,
+                    legacy_chart=bridge_result.chart,
+                    legacy_index_cols=bridge_result.bridge_dimensions,
+                )
+            except LEGACY_RENDER_ERRORS as exc:
+                drilldown_chart_audits[str(row)] = _legacy_chart_not_written_audit(
+                    exc,
+                    artifact_name=drilldown_artifact,
+                )
+                continue
+            paths.extend(drilldown_chart.paths)
+            drilldown_chart_audits[str(row)] = drilldown_chart.audit
+        else:
+            drilldown_chart_audits[str(row)] = _data_written_chart_audit(
+                chart_type=f"root_cause_total_bridge_drilldown_row_{row}",
+                artifact_name=drilldown_artifact,
+                source_functions=[
+                    "legacy_adapter.run_legacy_variable_dimension_bridge"
+                ],
+            )
+    if drilldown_chart_audits:
+        bridge_result.audit["drilldown_chart_audits"] = drilldown_chart_audits
+    if (
+        bridge_result.moved_run is not None
+        and not bridge_result.moved_run.frame.is_empty()
+    ):
+        moved_path = output_dir / "root_cause_total_bridge_moved_rows.csv"
+        bridge_result.moved_run.frame.write_csv(moved_path)
+        paths.append(str(moved_path))
+        if render:
+            try:
+                moved_chart = write_root_cause_bridge_png(
+                    bridge_result.moved_run.frame,
+                    result,
+                    recipe,
+                    output_dir,
+                    artifact_name="root_cause_total_bridge_moved_rows.png",
+                    variance_mode="total_variance",
+                    legacy_frame=bridge_result.moved_run.legacy_frame,
+                    legacy_param=bridge_result.moved_run.param,
+                    legacy_chart=bridge_result.chart,
+                    legacy_index_cols=bridge_result.bridge_dimensions,
+                )
+                paths.extend(moved_chart.paths)
+                bridge_result.audit["moved_rows_chart_audit"] = moved_chart.audit
+            except LEGACY_RENDER_ERRORS as exc:
+                bridge_result.audit["moved_rows_chart_audit"] = (
+                    _legacy_chart_not_written_audit(
+                        exc,
+                        artifact_name="root_cause_total_bridge_moved_rows.png",
+                    )
+                )
+        else:
+            bridge_result.audit["moved_rows_chart_audit"] = _data_written_chart_audit(
+                chart_type="root_cause_total_bridge_moved_rows",
+                artifact_name="root_cause_total_bridge_moved_rows.png",
+                source_functions=[
+                    "legacy_adapter.run_legacy_variable_dimension_bridge"
+                ],
+            )
+    sweep_paths, sweep_chart_audits = _write_root_cause_sweep_outputs(
+        bridge_result,
+        result,
+        recipe,
+        output_dir,
+        render=render,
+    )
+    paths.extend(sweep_paths)
+    if sweep_chart_audits:
+        bridge_result.audit["alternative_sweep_chart_audits"] = sweep_chart_audits
+    context_path = _write_root_cause_bridge_context(
+        frame=bridge_result.frame,
+        result=result,
+        recipe=recipe,
+        audit=bridge_result.audit,
+        output_dir=output_dir,
+        bridge_path=bridge_path,
+        chart_path=chart_path,
+        context_name="root_cause_total_bridge_context.json",
+        analysis_type="root_cause_total_bridge",
+        capability_id="variance.root_cause_total_bridge",
+        chart_type="root_cause_total_bridge",
+    )
+    paths.append(str(context_path))
+    if bool(recipe.get("options", {}).get("root_cause_component_bridge")):
+        try:
+            component_result = run_legacy_variable_dimension_component_bridge(
+                df,
+                recipe,
+            )
+        except LEGACY_RENDER_ERRORS as exc:
+            bridge_result.audit["component_bridge_audit"] = {
+                "enabled": True,
+                "status": "not_written_legacy_error",
+                "reason": str(exc),
+                "exception_type": exc.__class__.__name__,
+                "root_cause_variance_mode": "component_variance",
+            }
+        else:
+            bridge_result.audit["component_bridge_audit"] = component_result.audit
+            if not component_result.candidate_frame.is_empty():
+                component_candidate_path = (
+                    output_dir / "root_cause_component_bridge_candidates.csv"
+                )
+                component_result.candidate_frame.write_csv(component_candidate_path)
+                paths.append(str(component_candidate_path))
+            if not component_result.frame.is_empty():
+                component_path = output_dir / "root_cause_component_bridge.csv"
+                component_result.frame.write_csv(component_path)
+                paths.append(str(component_path))
+                component_chart_path: Path | None = None
+                try:
+                    component_chart = write_root_cause_bridge_png(
+                        component_result.frame,
+                        result,
+                        recipe,
+                        output_dir,
+                        artifact_name="root_cause_component_bridge.png",
+                        variance_mode="component_variance",
+                        legacy_frame=component_result.legacy_frame,
+                        legacy_param=component_result.param,
+                        legacy_chart=component_result.chart,
+                        legacy_index_cols=component_result.bridge_dimensions,
+                    )
+                    paths.extend(component_chart.paths)
+                    bridge_result.audit["component_bridge_chart_audit"] = (
+                        component_chart.audit
+                    )
+                    chart_path_value = component_chart.audit.get("path")
+                    component_chart_path = (
+                        Path(str(chart_path_value)) if chart_path_value else None
+                    )
+                except LEGACY_RENDER_ERRORS as exc:
+                    bridge_result.audit["component_bridge_chart_audit"] = (
+                        _legacy_chart_not_written_audit(
+                            exc,
+                            artifact_name="root_cause_component_bridge.png",
+                        )
+                    )
+                component_context = _write_root_cause_bridge_context(
+                    frame=component_result.frame,
+                    result=result,
+                    recipe=recipe,
+                    audit=component_result.audit,
+                    output_dir=output_dir,
+                    bridge_path=component_path,
+                    chart_path=component_chart_path,
+                    context_name="root_cause_component_bridge_context.json",
+                    analysis_type="root_cause_component_bridge",
+                    capability_id="variance.root_cause_component_bridge",
+                    chart_type="root_cause_component_bridge",
+                )
+                paths.append(str(component_context))
+    return (
+        [*paths, *chart_paths],
+        bridge_result.audit,
+        chart_audit,
+    )
+
+
+def run_variance_analysis(
+    input_path: Path,
+    output_dir: Path,
+    recipe_path: Path | None = None,
+    *,
+    root_cause_bridge: bool | None = None,
+    root_cause_bridge_alternative_result: int | None = None,
+    root_cause_bridge_drilldown_rows: list[int] | None = None,
+    root_cause_bridge_drilldown_all: bool | None = None,
+    root_cause_bridge_move_rows: dict[int | str, list[int]] | None = None,
+    root_cause_bridge_alternative_sweep: bool | None = None,
+    root_cause_bridge_alternative_sweep_start: int | None = None,
+    root_cause_bridge_alternative_sweep_end: int | None = None,
+    root_cause_bridge_auto_drilldown: str | None = None,
+    root_cause_bridge_auto_drilldown_min_share: float | None = None,
+    root_cause_component_bridge: bool | None = None,
+    root_cause_component_bridge_alternative_result: int | None = None,
+    waterfall_chart: bool | None = None,
+    waterfall_small_multiples: bool | None = None,
+    waterfall_small_multiples_dimension: str | None = None,
+    total_by_dimension_bridge: bool | None = None,
+    total_by_dimension_bridge_dimension: str | None = None,
+    total_by_dimension_bridge_top_n: int | None = None,
+    exploded_variance_bridge: bool | None = None,
+    exploded_variance_bridge_parent_dimension: str | None = None,
+    exploded_variance_bridge_child_dimension: str | None = None,
+    exploded_variance_bridge_parent_top_n: int | None = None,
+    exploded_variance_bridge_child_top_n: int | None = None,
+    exploded_variance_bridge_max_drilldowns: int | None = None,
+    currency: str | None = None,
+    language: str = "en",
+    artifact_mode: str = ARTIFACT_MODE_DATA_AND_RENDER,
+    client_engagement: dict[str, Any] | None = None,
+) -> VarianceRunResult:
+    """Run deterministic variance analysis and write output artifacts."""
+
+    vera_managed_host = is_vera_managed_host()
+    if vera_managed_host and client_engagement is None:
+        raise ValueError(
+            "The Vera-packaged variance runner requires --client-engagement."
+        )
+    if (vera_managed_host or client_engagement is not None) and not str(
+        currency or ""
+    ).strip():
+        raise ValueError("Managed Vera variance runs require an explicit currency.")
+    artifact_mode = _normalize_artifact_mode(artifact_mode)
+    try:
+        df = read_table(input_path)
+        source_population_rows = df.height
+        recipe = build_recipe(input_path, df, language=language)
+        existing_recipe = None
+        if recipe_path:
+            existing_recipe = load_json(recipe_path)
+            recipe = build_recipe(
+                input_path,
+                df,
+                language=language,
+                existing_recipe=existing_recipe,
+            )
+        recipe = preserve_recipe_filters(recipe, existing_recipe)
+        recipe = preserve_recipe_cohorts(recipe, existing_recipe)
+        recipe["accounting_review"] = normalize_accounting_review(
+            recipe.get("accounting_review")
+        )
+        recipe["source_file"] = _source_reference(input_path, client_engagement)
+        recipe["execution_context"] = {
+            "host_mode": (
+                "vera_managed"
+                if vera_managed_host or client_engagement is not None
+                else "standalone_or_clara"
+            )
+        }
+        if currency is not None:
+            recipe.setdefault("options", {})["currency"] = currency
+        recipe = validate_recipe(df, recipe)
+        if root_cause_bridge is not None:
+            recipe["options"]["root_cause_bridge"] = root_cause_bridge
+        if root_cause_bridge_alternative_result is not None:
+            recipe["options"][
+                "root_cause_bridge_alternative_result"
+            ] = root_cause_bridge_alternative_result
+        if root_cause_bridge_drilldown_rows is not None:
+            recipe["options"][
+                "root_cause_bridge_drilldown_rows"
+            ] = root_cause_bridge_drilldown_rows
+        if root_cause_bridge_drilldown_all is not None:
+            recipe["options"][
+                "root_cause_bridge_drilldown_all"
+            ] = root_cause_bridge_drilldown_all
+        if root_cause_bridge_move_rows is not None:
+            recipe["options"][
+                "root_cause_bridge_move_rows"
+            ] = root_cause_bridge_move_rows
+        if root_cause_bridge_alternative_sweep is not None:
+            recipe["options"][
+                "root_cause_bridge_alternative_sweep"
+            ] = root_cause_bridge_alternative_sweep
+            if root_cause_bridge_alternative_sweep:
+                recipe["options"]["root_cause_bridge"] = True
+        if root_cause_bridge_alternative_sweep_start is not None:
+            recipe["options"][
+                "root_cause_bridge_alternative_sweep_start"
+            ] = root_cause_bridge_alternative_sweep_start
+        if root_cause_bridge_alternative_sweep_end is not None:
+            recipe["options"][
+                "root_cause_bridge_alternative_sweep_end"
+            ] = root_cause_bridge_alternative_sweep_end
+        if root_cause_bridge_auto_drilldown is not None:
+            recipe["options"][
+                "root_cause_bridge_auto_drilldown"
+            ] = root_cause_bridge_auto_drilldown
+        if root_cause_bridge_auto_drilldown_min_share is not None:
+            recipe["options"][
+                "root_cause_bridge_auto_drilldown_min_share"
+            ] = root_cause_bridge_auto_drilldown_min_share
+        if root_cause_component_bridge is not None:
+            recipe["options"][
+                "root_cause_component_bridge"
+            ] = root_cause_component_bridge
+            if root_cause_component_bridge:
+                recipe["options"]["root_cause_bridge"] = True
+        if root_cause_component_bridge_alternative_result is not None:
+            recipe["options"][
+                "root_cause_component_bridge_alternative_result"
+            ] = root_cause_component_bridge_alternative_result
+        if waterfall_chart is not None:
+            recipe["options"]["waterfall_chart"] = waterfall_chart
+        if waterfall_small_multiples is not None:
+            recipe["options"]["waterfall_small_multiples"] = waterfall_small_multiples
+        if waterfall_small_multiples_dimension:
+            recipe["options"][
+                "waterfall_small_multiples_dimension"
+            ] = waterfall_small_multiples_dimension
+        if total_by_dimension_bridge is not None:
+            recipe["options"]["total_by_dimension_bridge"] = total_by_dimension_bridge
+        if total_by_dimension_bridge_dimension:
+            recipe["options"][
+                "total_by_dimension_bridge_dimension"
+            ] = total_by_dimension_bridge_dimension
+        if total_by_dimension_bridge_top_n is not None:
+            recipe["options"][
+                "total_by_dimension_bridge_top_n"
+            ] = total_by_dimension_bridge_top_n
+        if exploded_variance_bridge is not None:
+            recipe["options"]["exploded_variance_bridge"] = exploded_variance_bridge
+        if exploded_variance_bridge_parent_dimension:
+            recipe["options"][
+                "exploded_variance_bridge_parent_dimension"
+            ] = exploded_variance_bridge_parent_dimension
+        if exploded_variance_bridge_child_dimension:
+            recipe["options"][
+                "exploded_variance_bridge_child_dimension"
+            ] = exploded_variance_bridge_child_dimension
+        if exploded_variance_bridge_parent_top_n is not None:
+            recipe["options"][
+                "exploded_variance_bridge_parent_top_n"
+            ] = exploded_variance_bridge_parent_top_n
+        if exploded_variance_bridge_child_top_n is not None:
+            recipe["options"][
+                "exploded_variance_bridge_child_top_n"
+            ] = exploded_variance_bridge_child_top_n
+        if exploded_variance_bridge_max_drilldowns is not None:
+            recipe["options"][
+                "exploded_variance_bridge_max_drilldowns"
+            ] = exploded_variance_bridge_max_drilldowns
+        df, recipe = prepare_period_comparison_buckets(df, recipe)
+        df, filter_audit = apply_recipe_filters(df, recipe)
+        recipe.setdefault("options", {})["recipe_filter_audit"] = filter_audit
+        df, cohort_audit = apply_recipe_cohorts(
+            df,
+            recipe,
+            period_column=str(recipe["mappings"]["period_column"]),
+            value_column=str(recipe["mappings"]["amount_column"]),
+            current_period=str(recipe["mappings"]["comparison_period"]),
+            previous_period=str(recipe["mappings"]["baseline_period"]),
+        )
+        recipe = validate_recipe(df, recipe)
+        warn_if_output_dir_has_existing_files(output_dir, "Variance")
+        output_dir.mkdir(parents=True, exist_ok=True)
+        run_intake = write_run_intake(
+            output_dir,
+            input_path,
+            recipe_path=recipe_path,
+            recipe=recipe,
+            source_row_count=df.height,
+            client_engagement=client_engagement,
+        )
+
+        legacy_result = run_legacy_variance(
+            df, recipe, list(recipe["mappings"].get("dimensions") or [])
+        )
+        result = legacy_result.frame
+        amount_baseline = float(
+            result.select(pl.col("amount_baseline").sum()).item() or 0.0
+        )
+        amount_comparison = float(
+            result.select(pl.col("amount_comparison").sum()).item() or 0.0
+        )
+        recipe["accounting_readiness"] = evaluate_accounting_readiness(
+            recipe["accounting_review"],
+            amount_baseline=amount_baseline,
+            amount_comparison=amount_comparison,
+            max_abs_component_reconciliation_delta=max_abs(
+                result, "component_reconciliation_delta"
+            ),
+        )
+        if bool(recipe["options"].get("waterfall_small_multiples")):
+            small_multiples_selection = select_waterfall_small_multiples_dimension(
+                result,
+                recipe,
+            )
+        else:
+            small_multiples_selection = {
+                "status": "disabled",
+                "reason": "waterfall_small_multiples is false",
+                "dimension": None,
+            }
+        recipe["options"][
+            "waterfall_small_multiples_dimension_selection"
+        ] = small_multiples_selection
+        selected_small_multiples_dimension = small_multiples_selection.get("dimension")
+        recipe["options"]["waterfall_small_multiples"] = bool(
+            selected_small_multiples_dimension
+        )
+        recipe["options"][
+            "waterfall_small_multiples_dimension"
+        ] = selected_small_multiples_dimension
+        if bool(recipe["options"].get("total_by_dimension_bridge")):
+            total_bridge_selection = select_total_by_dimension_bridge_dimension(
+                result,
+                recipe,
+            )
+        else:
+            total_bridge_selection = {
+                "status": "disabled",
+                "reason": "total_by_dimension_bridge is false",
+                "dimension": None,
+            }
+        recipe["options"][
+            "total_by_dimension_bridge_dimension_selection"
+        ] = total_bridge_selection
+        selected_total_bridge_dimension = total_bridge_selection.get("dimension")
+        recipe["options"]["total_by_dimension_bridge"] = bool(
+            selected_total_bridge_dimension
+        )
+        recipe["options"][
+            "total_by_dimension_bridge_dimension"
+        ] = selected_total_bridge_dimension
+        if bool(recipe["options"].get("exploded_variance_bridge")):
+            exploded_bridge_selection = select_exploded_variance_bridge_dimensions(
+                result,
+                recipe,
+                fallback_parent_dimension=(
+                    str(selected_total_bridge_dimension)
+                    if selected_total_bridge_dimension
+                    else None
+                ),
+            )
+        else:
+            exploded_bridge_selection = {
+                "status": "disabled",
+                "reason": "exploded_variance_bridge is false",
+                "parent_dimension": None,
+                "child_dimension": None,
+            }
+        recipe["options"][
+            "exploded_variance_bridge_dimension_selection"
+        ] = exploded_bridge_selection
+        selected_exploded_parent_dimension = exploded_bridge_selection.get(
+            "parent_dimension"
+        )
+        selected_exploded_child_dimension = exploded_bridge_selection.get(
+            "child_dimension"
+        )
+        recipe["options"]["exploded_variance_bridge"] = bool(
+            selected_exploded_parent_dimension and selected_exploded_child_dimension
+        )
+        recipe["options"][
+            "exploded_variance_bridge_parent_dimension"
+        ] = selected_exploded_parent_dimension
+        recipe["options"][
+            "exploded_variance_bridge_child_dimension"
+        ] = selected_exploded_child_dimension
+        available_chart_types = []
+        if bool(recipe["options"].get("waterfall_chart", True)):
+            available_chart_types.append(VARIANCE_CHART_STANDARD_WATERFALL)
+        if recipe.get("mappings", {}).get("units_column") and bool(
+            recipe.get("options", {}).get("pvm_decomposition_ladder", True)
+        ):
+            available_chart_types.append(VARIANCE_CHART_PVM_LADDER)
+        if bool(recipe["options"].get("waterfall_small_multiples")):
+            available_chart_types.append(VARIANCE_CHART_SMALL_MULTIPLES)
+        if selected_total_bridge_dimension:
+            available_chart_types.append(VARIANCE_CHART_TOTAL_BY_DIMENSION)
+        if selected_exploded_parent_dimension and selected_exploded_child_dimension:
+            available_chart_types.append(VARIANCE_CHART_EXPLODED_BRIDGE)
+        if bool(recipe["options"].get("root_cause_bridge", True)):
+            available_chart_types.append(VARIANCE_CHART_ROOT_CAUSE)
+        render_standard_waterfall = _variance_chart_selected(
+            VARIANCE_CHART_STANDARD_WATERFALL,
+            artifact_mode,
+            available_chart_types,
+        )
+        render_small_multiples = _variance_chart_selected(
+            VARIANCE_CHART_SMALL_MULTIPLES,
+            artifact_mode,
+            available_chart_types,
+        )
+        if artifact_mode == ARTIFACT_MODE_DATA_ONLY and _variance_data_chart_enabled(
+            VARIANCE_CHART_STANDARD_WATERFALL,
+            available_chart_types,
+        ):
+            waterfall_export = argparse.Namespace(
+                paths=[],
+                audit=_data_written_chart_audit(
+                    chart_type=VARIANCE_CHART_STANDARD_WATERFALL,
+                    artifact_name="waterfall.png",
+                    source_functions=[
+                        "modules.charting.draw_waterfall.draw_vertical_waterfall_chart"
+                    ],
+                ),
+            )
+            if _variance_data_chart_enabled(
+                VARIANCE_CHART_SMALL_MULTIPLES,
+                available_chart_types,
+            ):
+                waterfall_export.audit["small_multiples_status"] = "data_written"
+                waterfall_export.audit["small_multiples_artifact"] = (
+                    "waterfall_small_multiples.png"
+                )
+        elif artifact_mode == ARTIFACT_MODE_DATA_ONLY:
+            waterfall_export = argparse.Namespace(
+                paths=[],
+                audit=_skipped_chart_audit(
+                    VARIANCE_CHART_STANDARD_WATERFALL,
+                    "not enabled in recipe",
+                ),
+            )
+        elif render_standard_waterfall or render_small_multiples:
+            waterfall_export = write_waterfall_png(
+                result,
+                recipe,
+                output_dir,
+                legacy_frame=legacy_result.legacy_frame,
+                render_standard=render_standard_waterfall,
+                render_small_multiples=render_small_multiples,
+            )
+        else:
+            waterfall_export = argparse.Namespace(
+                paths=[],
+                audit=_skipped_chart_audit(
+                    VARIANCE_CHART_STANDARD_WATERFALL,
+                    "not enabled in recipe",
+                ),
+            )
+        render_pvm_ladder = _variance_chart_selected(
+            VARIANCE_CHART_PVM_LADDER,
+            artifact_mode,
+            available_chart_types,
+        )
+        if artifact_mode == ARTIFACT_MODE_DATA_ONLY and _variance_data_chart_enabled(
+            VARIANCE_CHART_PVM_LADDER,
+            available_chart_types,
+        ):
+            pvm_ladder_export = argparse.Namespace(
+                paths=[],
+                audit=_data_written_chart_audit(
+                    chart_type=VARIANCE_CHART_PVM_LADDER,
+                    artifact_name="pvm_decomposition_ladder.png",
+                    source_functions=[
+                        "modules.charting.draw_waterfall.draw_vertical_waterfall_chart"
+                    ],
+                ),
+            )
+        elif render_pvm_ladder:
+            pvm_ladder_export = write_pvm_decomposition_ladder_png(
+                result,
+                recipe,
+                output_dir,
+                legacy_frame=legacy_result.legacy_frame,
+            )
+        else:
+            pvm_ladder_export = argparse.Namespace(
+                paths=[],
+                audit=_skipped_chart_audit(
+                    VARIANCE_CHART_PVM_LADDER,
+                    "not enabled in recipe",
+                ),
+            )
+        (
+            pvm_ladder_chart_data_paths,
+            pvm_ladder_chart_data_audit,
+            pvm_ladder_summary,
+        ) = write_pvm_decomposition_ladder_chart_data(result, recipe, output_dir)
+        (
+            small_multiples_chart_data_paths,
+            small_multiples_chart_data_audit,
+            small_multiples_summary,
+        ) = write_waterfall_small_multiples_chart_data(result, recipe, output_dir)
+        render_total_by_dimension = _variance_chart_selected(
+            VARIANCE_CHART_TOTAL_BY_DIMENSION,
+            artifact_mode,
+            available_chart_types,
+        )
+        if selected_total_bridge_dimension and artifact_mode == ARTIFACT_MODE_DATA_ONLY:
+            total_by_dimension_export = write_total_by_dimension_bridge_artifacts(
+                result,
+                recipe,
+                output_dir,
+                dimension=str(selected_total_bridge_dimension),
+                top_n=int(recipe["options"]["total_by_dimension_bridge_top_n"]),
+                render=False,
+            )
+        elif selected_total_bridge_dimension and render_total_by_dimension:
+            total_by_dimension_export = write_total_by_dimension_bridge_artifacts(
+                result,
+                recipe,
+                output_dir,
+                dimension=str(selected_total_bridge_dimension),
+                top_n=int(recipe["options"]["total_by_dimension_bridge_top_n"]),
+            )
+        else:
+            total_by_dimension_export = argparse.Namespace(
+                paths=[],
+                audit={
+                    "enabled": bool(recipe["options"].get("total_by_dimension_bridge")),
+                    "status": total_bridge_selection["status"],
+                    "dimension": None,
+                    "selection": total_bridge_selection,
+                },
+                summary_markdown="",
+            )
+        render_exploded_bridge = _variance_chart_selected(
+            VARIANCE_CHART_EXPLODED_BRIDGE,
+            artifact_mode,
+            available_chart_types,
+        )
+        if (
+            selected_exploded_parent_dimension
+            and selected_exploded_child_dimension
+            and artifact_mode == ARTIFACT_MODE_DATA_ONLY
+        ):
+            exploded_bridge_export = write_exploded_variance_bridge_artifacts(
+                result,
+                recipe,
+                output_dir,
+                parent_dimension=str(selected_exploded_parent_dimension),
+                child_dimension=str(selected_exploded_child_dimension),
+                parent_top_n=int(
+                    recipe["options"]["exploded_variance_bridge_parent_top_n"]
+                ),
+                child_top_n=int(
+                    recipe["options"]["exploded_variance_bridge_child_top_n"]
+                ),
+                max_drilldowns=int(
+                    recipe["options"]["exploded_variance_bridge_max_drilldowns"]
+                ),
+                render=False,
+            )
+        elif (
+            selected_exploded_parent_dimension
+            and selected_exploded_child_dimension
+            and render_exploded_bridge
+        ):
+            exploded_bridge_export = write_exploded_variance_bridge_artifacts(
+                result,
+                recipe,
+                output_dir,
+                parent_dimension=str(selected_exploded_parent_dimension),
+                child_dimension=str(selected_exploded_child_dimension),
+                parent_top_n=int(
+                    recipe["options"]["exploded_variance_bridge_parent_top_n"]
+                ),
+                child_top_n=int(
+                    recipe["options"]["exploded_variance_bridge_child_top_n"]
+                ),
+                max_drilldowns=int(
+                    recipe["options"]["exploded_variance_bridge_max_drilldowns"]
+                ),
+            )
+        else:
+            exploded_bridge_export = argparse.Namespace(
+                paths=[],
+                audit={
+                    "enabled": bool(recipe["options"].get("exploded_variance_bridge")),
+                    "status": exploded_bridge_selection["status"],
+                    "parent_dimension": None,
+                    "child_dimension": None,
+                    "selection": exploded_bridge_selection,
+                },
+                summary_markdown="",
+            )
+        render_root_cause = _variance_chart_selected(
+            VARIANCE_CHART_ROOT_CAUSE,
+            artifact_mode,
+            available_chart_types,
+        )
+        if artifact_mode == ARTIFACT_MODE_DATA_ONLY and _variance_data_chart_enabled(
+            VARIANCE_CHART_ROOT_CAUSE,
+            available_chart_types,
+        ):
+            bridge_paths, bridge_audit, bridge_chart_audit = write_root_cause_bridge(
+                df,
+                result,
+                recipe,
+                output_dir,
+                render=False,
+            )
+        elif render_root_cause:
+            bridge_paths, bridge_audit, bridge_chart_audit = write_root_cause_bridge(
+                df,
+                result,
+                recipe,
+                output_dir,
+            )
+        else:
+            bridge_paths = []
+            bridge_audit = None
+            bridge_chart_audit = bridge_audit
+        summary = build_summary_markdown(result, recipe)
+        summary += pvm_ladder_summary
+        summary += small_multiples_summary
+        summary += total_by_dimension_export.summary_markdown
+        summary += exploded_bridge_export.summary_markdown
+        summary = append_bridge_dimension_summary(
+            summary,
+            bridge_audit,
+            language=str(recipe.get("language") or "en"),
+        )
+        artifact_paths = [
+            *bridge_paths,
+            *waterfall_export.paths,
+            *pvm_ladder_export.paths,
+            *pvm_ladder_chart_data_paths,
+            *small_multiples_chart_data_paths,
+            *total_by_dimension_export.paths,
+            *exploded_bridge_export.paths,
+        ]
+        audit = build_audit(
+            input_path,
+            recipe,
+            result,
+            artifact_paths,
+            client_engagement=client_engagement,
+        )
+        audit["legacy_runtime"] = legacy_result.audit
+        audit["legacy_runtime"]["variable_dimension_bridge"] = bridge_audit
+        audit["legacy_runtime"]["variable_dimension_bridge_chart"] = bridge_chart_audit
+        audit["legacy_runtime"]["waterfall_chart"] = waterfall_export.audit
+        audit["legacy_runtime"][
+            "pvm_decomposition_ladder_chart"
+        ] = pvm_ladder_export.audit
+        audit["legacy_runtime"][
+            "pvm_decomposition_ladder_chart_data"
+        ] = pvm_ladder_chart_data_audit
+        audit["legacy_runtime"][
+            "waterfall_small_multiples_dimension_selection"
+        ] = small_multiples_selection
+        audit["legacy_runtime"][
+            "waterfall_small_multiples_chart_data"
+        ] = small_multiples_chart_data_audit
+        audit["legacy_runtime"][
+            "total_by_dimension_bridge_dimension_selection"
+        ] = total_bridge_selection
+        audit["legacy_runtime"][
+            "total_by_dimension_bridge"
+        ] = total_by_dimension_export.audit
+        audit["legacy_runtime"][
+            "exploded_variance_bridge_dimension_selection"
+        ] = exploded_bridge_selection
+        audit["legacy_runtime"][
+            "exploded_variance_bridge"
+        ] = exploded_bridge_export.audit
+        if waterfall_export.audit.get("status") == "not_written":
+            audit["outputs"]["waterfall.png"] = "not_written: " + str(
+                waterfall_export.audit.get("error", "unknown")
+            )
+        if waterfall_export.audit.get("small_multiples_status") == "not_written":
+            audit["outputs"]["waterfall_small_multiples.png"] = "not_written: " + str(
+                waterfall_export.audit.get("small_multiples_error", "unknown")
+            )
+        if pvm_ladder_export.audit.get("status", "").startswith("not_written"):
+            audit["outputs"]["pvm_decomposition_ladder.png"] = "not_written: " + str(
+                pvm_ladder_export.audit.get(
+                    "error", pvm_ladder_export.audit.get("reason", "unknown")
+                )
+            )
+        audit["legacy_runtime"]["artifact_mode"] = artifact_mode
+        chart_statuses = {
+            VARIANCE_CHART_STANDARD_WATERFALL: waterfall_export.audit.get("status"),
+            VARIANCE_CHART_PVM_LADDER: pvm_ladder_export.audit.get("status"),
+            VARIANCE_CHART_SMALL_MULTIPLES: (
+                waterfall_export.audit.get("small_multiples_status")
+                or small_multiples_chart_data_audit.get("status")
+            ),
+            VARIANCE_CHART_TOTAL_BY_DIMENSION: (
+                total_by_dimension_export.audit.get("status")
+            ),
+            VARIANCE_CHART_EXPLODED_BRIDGE: (
+                exploded_bridge_export.audit.get("status")
+            ),
+            VARIANCE_CHART_ROOT_CAUSE: (
+                bridge_audit.get("status") if bridge_audit else None
+            ),
+        }
+        audit["checks"]["legacy_chart_attempt_count"] = sum(
+            1
+            for status in chart_statuses.values()
+            if status not in {None, "skipped", "disabled"}
+        )
+        audit["checks"]["legacy_chart_written_count"] = sum(
+            1 for status in chart_statuses.values() if status == "written"
+        )
+        audit["checks"]["legacy_chart_data_count"] = sum(
+            1
+            for status in chart_statuses.values()
+            if status in {"written", "data_written"}
+        )
+        write_json(output_dir / "used_recipe.json", recipe)
+        audit["outputs"]["used_recipe.json"] = "written"
+        write_outputs(result, audit, summary, output_dir, artifact_paths=artifact_paths)
+        prepared_manifest_path = write_prepared_data_manifest(
+            output_dir=output_dir,
+            plugin="variance-analysis",
+            chart_family="variance_analysis",
+            source_file=str(recipe["source_file"]),
+            prepared_path=output_dir / "variance_results.csv",
+            frame=result,
+            recipe=recipe,
+            stage="variance_result",
+            preparation_audit={
+                "status": "prepared",
+                "recipe_filters": filter_audit,
+                "recipe_cohorts": cohort_audit,
+                "legacy_runtime": legacy_result.audit,
+            },
+        )
+        audit["outputs"][
+            _relative_artifact_path(prepared_manifest_path, output_dir)
+        ] = "written"
+        standard_context_path = output_dir / "standard_variance_context.json"
+        write_json(
+            standard_context_path,
+            _standard_variance_context(result, recipe, output_dir),
+        )
+        audit["outputs"][
+            _relative_artifact_path(standard_context_path, output_dir)
+        ] = "written"
+        write_json(output_dir / "variance_audit.json", audit)
+        default_model_paths = [
+            output_dir / "variance_results.csv",
+            output_dir / "variance_summary.md",
+            output_dir / "used_recipe.json",
+            prepared_manifest_path,
+            standard_context_path,
+            *(Path(path) for path in artifact_paths),
+        ]
+        model_use_manifest_path = write_model_use_manifest(
+            input_path=input_path,
+            output_dir=output_dir,
+            recipe=recipe,
+            recipe_path=output_dir / "used_recipe.json",
+            source_population_rows=source_population_rows,
+            in_scope_rows=df.height,
+            default_artifact_paths=default_model_paths,
+        )
+        audit["outputs"][
+            _relative_artifact_path(model_use_manifest_path, output_dir)
+        ] = "written"
+        artifact_paths = [
+            *artifact_paths,
+            str(prepared_manifest_path),
+            str(standard_context_path),
+            str(model_use_manifest_path),
+        ]
+        review_session = write_review_session_artifacts(
+            output_dir,
+            input_path,
+            run_id=run_intake.run_id,
+            run_intake_path=run_intake.path,
+            recipe_path=recipe_path,
+            recipe=recipe,
+            result_rows=result.to_dicts(),
+            audit=audit,
+            client_engagement=client_engagement,
+        )
+        audit["review_session"] = {
+            "run_intake_path": review_session.run_intake_path.name,
+            "review_payload_path": review_session.review_payload_path.name,
+            "ui_decisions_path": review_session.ui_decisions_path.name,
+            "final_artifacts_path": review_session.final_artifacts_path.name,
+            "review_item_count": review_session.review_item_count,
+        }
+        for path in (
+            review_session.run_intake_path,
+            review_session.review_payload_path,
+            review_session.ui_decisions_path,
+            review_session.final_artifacts_path,
+        ):
+            audit["outputs"][_relative_artifact_path(path, output_dir)] = "written"
+        artifact_paths = [
+            *artifact_paths,
+            str(review_session.run_intake_path),
+            str(review_session.review_payload_path),
+            str(review_session.ui_decisions_path),
+            str(review_session.final_artifacts_path),
+        ]
+        write_json(output_dir / "variance_audit.json", audit)
+        return VarianceRunResult(
+            frame=result,
+            audit=audit,
+            summary_markdown=summary,
+            artifact_paths=artifact_paths,
+        )
+    finally:
+        cleanup_legacy_imports()

Full technical diff · 1269 changed fields

added `/files/.agents~1skills~1advisory-output-shaper~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "d265f67f735245b7145b24407080170e0fb29597a0782469b9c153eafefef791",
  "size": 9003
}

changed `/files/.codex-plugin~1plugin.json/sha256`

BEFORE

"ca3867c23b6be6ccf2f96d13672dc623b40ea4bc7b97a608943429cbe983e134"

AFTER

"76d5492467b98c9db450f4233c519a97d762ddb46de9d4af0c02a1555ffd2b65"

changed `/files/.codex-plugin~1plugin.json/size`

BEFORE

AFTER

added `/files/LEGGIMI_INSTALLAZIONE.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "a954f5a9a8ddfa2afc3a3530a415f4502bf36f06abff08dd4a0c5e1f7c77f678",
  "size": 3130
}

removed `/files/LICENSE`

BEFORE

{
  "sha256": "0d96a4ff68ad6d4b6f1f30f713b18d5184912ba8dd389f86aa7710db079abcb0",
  "size": 34523
}

AFTER

Field is absent

added `/files/README.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "7aefd0c8bf52dee07ac39df6ee30fe91ec480a83cc2ee16733f22a0b4c8d5068",
  "size": 56771
}

added `/files/assets~1courses~1advisory-brief-planner~1course.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "9249d651e279c7470c71c0ebdb7b6f4291dc6f90d7d769baa1df8aee2b0f9d9c",
  "size": 32930
}

added `/files/assets~1courses~1advisory-case-director~1course.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "1c47236906eca13f0212869b08314b5b8e62ae87b796b6fa4e419243e8e1bd4a",
  "size": 30833
}

added `/files/assets~1courses~1advisory-deliverable-validator~1course.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "19afc42b95ed08b637cc986dac937bd421332d864f2f0c7b3b9fa6573481fd8d",
  "size": 37766
}

added `/files/assets~1courses~1attribute-reporting~1course.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "3c8f862a4acf16721d06ba306ba83656211ad4a8c899279622d15236ffc23459",
  "size": 42555
}

added `/files/assets~1courses~1brand-fit~1course.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "57ca324725a2a9e5bd07d2b97cba7433499a99c0f62a726e217240f195aeb0ac",
  "size": 22976
}

added `/files/assets~1courses~1business-planning~1course.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "b61e8e226c87d6d794b85ec0a8cde07045b7ca19b7d0987fafa85886a047e908",
  "size": 28008
}

added `/files/assets~1courses~1deck-correction~1course.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "bebe73b2a6a4dd0da6460a5bf09cbe72d816c97325657834626360cf45cb576d",
  "size": 41069
}

added `/files/assets~1courses~1hosted-interview~1course.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "d7b7e22cb69bd95a3442a1c29cd86bd6b8d9eb25896032e5274a4dfb3d4abeab",
  "size": 18069
}

added `/files/assets~1courses~1html-deck~1course.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "6c4847c14dd4d2235187043e00976b99361d3d61a141f192f51ff2d0230a7a09",
  "size": 34945
}

added `/files/assets~1courses~1index.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "1d2cc75195b9ea0bd61a1a99b7c469a032d278a64248bc131dbc49fac5a8861c",
  "size": 12912
}

added `/files/assets~1courses~1remote.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "e46d0ffd70e97f45c2672d28795c38ccea5a5a9c7a5a6d72e10295e3c4df0cc0",
  "size": 52953
}

added `/files/assets~1courses~1reporting-engine~1course.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "61a0b924afaa68e70775e892d9f8f6a2d18f14f009f4d4983ac8748f30ba2964",
  "size": 38274
}

added `/files/assets~1courses~1research-video~1course.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "c343f09f4b92125e95b80612247cf54101e359071398800e65c60790c4ea0f11",
  "size": 17393
}

added `/files/assets~1courses~1transcribe~1course.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "ecd2ea3916490e46e514cccabd07838ea734965c865e62297f658aa49a39d489",
  "size": 35922
}

added `/files/assets~1onboarding~1actual-budget.xlsx`

BEFORE

Field was absent

AFTER

{
  "sha256": "8d6512c94dc0157476844eed608082feac49d89156d832c127525f82b19a839a",
  "size": 5585
}

added `/files/assets~1onboarding~1advisory-brief.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "c13640e2a445df703d43eb270a352419520d420ef3ece4802e9fab3b1392cfe4",
  "size": 557
}

changed `/files/components.json/sha256`

BEFORE

"4e76b705e08c831c423cdb003f64d77fcd6f09b3bdff8b2687ff673db2c42d60"

AFTER

"2a7291d3cc577d5c8a4d7598abb55f7f88aa1031780400e99c5555ae29e3cf84"

changed `/files/components.json/size`

BEFORE

AFTER

removed `/files/distribution.json`

BEFORE

{
  "sha256": "ef596f1bbc548379942c9608aa7d04eb9abe1d09f5272e98b0f9329f2e34b509",
  "size": 282
}

AFTER

Field is absent

added `/files/docs~1specs~1pptx_templates~1ag-style-spec.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "89b974726837b69188e9416c8c5154733bb728876b899699151fb1c5f9f1a760",
  "size": 5134
}

added `/files/docs~1specs~1pptx_templates~1bain-style-spec.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "7955c74d8631968006dc6ded2ca5bcb305c84c0e7802f8e103ccf09a00bb7212",
  "size": 1610
}

added `/files/evals~1html_deck_benchmark_protocol.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "c948878da661aed109de87121932aa51ac88f82f2f1f1ab8b0fcbc61c67247eb",
  "size": 7346
}

added `/files/evals~1html_deck_benchmark_runs.schema.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "3064049983e1dbbe83d540cbce44bbf2e37f8228d46d5ea001648029fb6b24f8",
  "size": 11735
}

added `/files/evals~1html_deck_capability_benchmarks.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "41656a784e5a72023d6f3a7aacbedb98a2e231147d83a4a3c628dd3b6fef4205",
  "size": 13282
}

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1case.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "4051affdaf72127968dd0a377eec41be2a403c3ea4201e2c03376be871e680e9",
  "size": 5816
}

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1exact_control_facts.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "57a84b89c7172e7f8d1497cf1974ae13860289dd44902d83302deb66812f25f8",
  "size": 771
}

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1exact_extracted_facts.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "784a2785e5f3a17f4c3382ca61a669a9f0680139865a202328eb0339b4806be7",
  "size": 2448
}

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1expected~1customer_concentration_summary.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "48c75363a10a4e5339fee4f3f57b9e27d4005430a7faa099d38ca4e4f94a00f2",
  "size": 2595
}

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1expected~1exceptions.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "aae96c35ad9098a8580bbc08b841dfb2ae41a374efeb9ce97ad69a7f8eb0b1a3",
  "size": 39
}

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1expected~1prepared_evidence_manifest.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "f422439cde2c63839b0e812159f91ddddd425d41b4dd19e100200e20ae716120",
  "size": 8735
}

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1expected~1reconciliation.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "27446774176f313a8a1a7f8d72c615e5bf4267c0770dfa1d063843cb5d6135fa",
  "size": 9628
}

added `/files/evals~1preparation~1wd40_fy2025~1SOURCE_NOTES.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "7ea069095ffff82bfed4d1643ce3fb53fd8afa0b38f28d570ad91b1f59b23d3a",
  "size": 3770
}

added `/files/evals~1preparation~1wd40_fy2025~1case.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "16e1454f3d3b6d1ac73269a720bd4f74e6feab9764fe5d795193cd8ead9d6480",
  "size": 7709
}

added `/files/evals~1preparation~1wd40_fy2025~1expected~1monthly_pnl.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "ad7b2f1b2267ece697d7ec1cce9e0155da68ae10d5a8eeb7100823fda28bf1a0",
  "size": 14892
}

added `/files/evals~1preparation~1wd40_fy2025~1expected~1prepared_evidence_manifest.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "a1784ad9a4ce33ed4090c9e9e6e036382ea4a628080fcd8526ae24d5afe271c3",
  "size": 6901
}

added `/files/evals~1preparation~1wd40_fy2025~1expected~1reconciliation.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "4dd146d25196b79a24f70c9363b73623c55bf600359d4c70239815db2e6126a4",
  "size": 66449
}

added `/files/evals~1preparation~1wd40_fy2025~1expected~1unmapped_accounts.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "4268cab92c65ff567104c2243854a0cc6722b0eaaa61f9544e57c2bc098c0052",
  "size": 115
}

added `/files/evals~1preparation~1wd40_fy2025~1monthly_pnl.semantic.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "016535666fcf286057fb4e475f9b5daea12e9c4360f1eab3fba6f6ccd9afbd27",
  "size": 24745
}

added `/files/evals~1preparation~1wd40_fy2025~1public_statement_facts.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "91a650591f155dfa5a6722747d95832eb5cbc453353cfa94b00ce374da2c5c42",
  "size": 17627
}

added `/files/evals~1preparation~1wd40_fy2025~1reporting_handoff_request.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "4ca9586efa32653bf754f7fca4bd12b4f07133329695861476c7c39ffd8dde2b",
  "size": 3141
}

added `/files/evals~1preparation~1wd40_fy2025~1reviewed_coa_mapping.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "32a754b6d57a6dd08abaf0f932e8c92399e9ffbdf38ea66bcd4579c4e89025ef",
  "size": 3359
}

added `/files/evals~1preparation~1wd40_fy2025~1statement_render_recipe.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "493727b2874f005d1d338725fd5c461953397f079c133413b3eab9a4653cd5e8",
  "size": 3239
}

added `/files/evals~1preparation~1wd40_fy2025~1synthetic_monthly_trial_balance.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "25f6ddc79de3d03aa58d3e606bbe933768f4584c768e15d9d384d3392618f8a3",
  "size": 25633
}

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1case.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "a7542faf40a63fe00a1eb16bde128aaad5dbd7653d7d4067a48cd5dedd003518",
  "size": 6394
}

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1discrete_cash_flow_schedule.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "37712a663e5020fb9044666596e189e0f102824de18a630a5326b653c469e679",
  "size": 1232
}

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1exceptions.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "aae96c35ad9098a8580bbc08b841dfb2ae41a374efeb9ce97ad69a7f8eb0b1a3",
  "size": 39
}

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1prepared_evidence_manifest.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "eae57ebc0cab265cbbce19461be573626498f4997bdc6a52d8c590fd8494ac1d",
  "size": 5192
}

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1raw_fact_preservation.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "dd925bd158142eb3a8b27cecc307c522629edcc8b2514b04416e68ddf31daf65",
  "size": 22852
}

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1reconciliation.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "6611a4d4e54c42fe2438cc49cee57db9d04b9d8a5e7cebf9d6b70e4af2442806",
  "size": 3356
}

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1stock_flow_bridge.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "fbc674450b2eee6db991e59969f4dd08b05982933502dbed02a511f38c2fd210",
  "size": 923
}

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1working_capital_schedule.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "08859ba960029c9452242a57ebcfc81ef52b39cba52368b61c3eb16171814127",
  "size": 876
}

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1public_working_capital_facts.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "dd925bd158142eb3a8b27cecc307c522629edcc8b2514b04416e68ddf31daf65",
  "size": 22852
}

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1reviewed_working_capital_policy.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "232661ccf01aff9c6852b8d02de81af708b7f9ab7f70384021cab90c1afa1e80",
  "size": 3306
}

added `/files/evals~1public_truth~1fastenal_q1_2025~1SOURCE_NOTES.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "adb60c54f821512433d55adcf2c75373ba99ee048a2e9ea82498789850937ef1",
  "size": 1687
}

added `/files/evals~1public_truth~1fastenal_q1_2025~1benchmark.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "88b859f1e43a2ee6883bb9c6c7b9e61bcae26108de9db7c8deabf77d97dd22fc",
  "size": 6615
}

added `/files/evals~1public_truth~1fastenal_q1_2025~1expected_prepared_observations.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "bf27e23960f1050394584f865a8fd59a7f7db1f9cabfa3345be923094fbc6eac",
  "size": 2228
}

added `/files/evals~1public_truth~1fastenal_q1_2025~1expected_validation_report.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "b2bf3848db2851f4b1b31fd63568af555ab99e174b28705873bfffee2aa1bf74",
  "size": 6928
}

added `/files/evals~1public_truth~1fastenal_q1_2025~1truth_observations.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "bf27e23960f1050394584f865a8fd59a7f7db1f9cabfa3345be923094fbc6eac",
  "size": 2228
}

added `/files/evals~1trigger_fixtures.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "0fe442e3c2637722df655d1517fdb73d71fb8d1a25d2e9891ac9cd0202820537",
  "size": 16252
}

changed `/files/execution-files.json/sha256`

BEFORE

"9a19dadcebf78caa95571651e328cfb85805827d7046f68468b3948d19b8390a"

AFTER

"8cbf24474c0c1dd1bb8bc5f095d27b73775adb8c8a86affd7629f694c997bc56"

changed `/files/execution-files.json/size`

BEFORE

AFTER

added `/files/marketplace_skill_instructions.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "0927c8c334a1e2a7c367956dc98802ed198e2a43db3eb33940cf28211c5c0249",
  "size": 13445
}

added `/files/mcp-catalog.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "9d58ce1fac5ef7857cbe49af8373fde37a90883b8dcf9a6bf2f95a32701ac94a",
  "size": 45448
}

added `/files/mcp-services.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "dee3cd6c891e8cb7641897e57b6b5d649a635e1c11a5fafe5222ceb94dc6e34d",
  "size": 856
}

removed `/files/modules~1README.md`

BEFORE

{
  "sha256": "5dc64efc3e2252327e6717f251e049168c0707f3d90b160376858873217ac9f8",
  "size": 49
}

AFTER

Field is absent

added `/files/modules~1attribute-reporting~1.codex-plugin~1plugin.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "bfa6e3e4fb5acd72c7afd674731e1375761e76d79d11670649e510284fa40c98",
  "size": 2548
}

added `/files/modules~1attribute-reporting~1README.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "5302d8fbd68b0f1e99d7cad82797fa64d2052cdeb10a25ffb1ae671a07cf7db1",
  "size": 866
}

added `/files/modules~1attribute-reporting~1assets~1icon.svg`

BEFORE

Field was absent

AFTER

{
  "sha256": "0c1edab1496be5d851dc3bf5a17cce10b612ad74d0f3a8567659b8e69027710d",
  "size": 917
}

added `/files/modules~1attribute-reporting~1evals~1trigger_fixtures.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "a70f4a8d28086e830d8bea069ed730e231a41aadd95a272f6c04d3e2a52136f4",
  "size": 1810
}

added `/files/modules~1attribute-reporting~1requirements.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "19f93c2e80b6e39003de1131a2fff49f70c5281c3badade0deb10a8fa61a5b9b",
  "size": 34
}

added `/files/modules~1attribute-reporting~1scripts~1apply_validated_mappings.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1dcc9ab6bf2e622dcfa78d4dc3fa178f32fa6d87f696f4f12a65b1b3914098fe",
  "size": 16444
}

added `/files/modules~1attribute-reporting~1scripts~1attribute_reporting.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dfb71e185cb1a428081cb4e808b4f1410f8878cf140a1e5525e4241831094ad2",
  "size": 246613
}

added `/files/modules~1attribute-reporting~1scripts~1bind_mapping_images.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e984adecac352d2281f34b741570be03b6727c1598a0cccc14655f37abbc3f82",
  "size": 1232
}

added `/files/modules~1attribute-reporting~1scripts~1brand_fit.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c81792ff92a0f5b6e9e2db435acb5a6a234d013f3cff25e4d9006d1c4a8698a4",
  "size": 135788
}

added `/files/modules~1attribute-reporting~1scripts~1browser_qa.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4d57596687f210359858e3a48c5205df63512f18de7a09c60400593d194a9a3b",
  "size": 14721
}

added `/files/modules~1attribute-reporting~1scripts~1check_brand_fit_report.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5cfc4465060ceeed8053c5248856c11399fc278266fc982d9d9475c71554abbb",
  "size": 861
}

added `/files/modules~1attribute-reporting~1scripts~1check_dependencies.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f1ae4013ca0e4c709dd412bf3a71d490b67d9a22610d27a571ea8fe9c4a3b762",
  "size": 2195
}

added `/files/modules~1attribute-reporting~1scripts~1check_report.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a1faa5ddbf2ae31d97eb143dabd1c7483a56d2e8476953ebc529fc16b83782b6",
  "size": 1765
}

added `/files/modules~1attribute-reporting~1scripts~1create_mapping_tasks.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3b244f3f99b704ed361b6586d881c329c6c8f293dafe92cdac244656660d63f8",
  "size": 2129
}

added `/files/modules~1attribute-reporting~1scripts~1hydrate_images.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b88fa51362b4f7f686e735c7ff869618cadd93f5c8d5fc349a5481932f6fb874",
  "size": 32116
}

added `/files/modules~1attribute-reporting~1scripts~1mapping_shards.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c7ea065fa5d28c08e2eb23b08bc80218fe4fd2df216d54544e133acd46eac453",
  "size": 42419
}

added `/files/modules~1attribute-reporting~1scripts~1prepare_brand_fit_run.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1b2d148c9e6ecdc102da0fbf2ebbcc6cbd5c2ed73591660aef48c2040f9b7d85",
  "size": 1494
}

added `/files/modules~1attribute-reporting~1scripts~1prepare_mapping_review.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "cc2b8084b757a51124e2172c9b2427c6ded15ff2b95747264f46d4fe00ae1bcf",
  "size": 2226
}

added `/files/modules~1attribute-reporting~1scripts~1prepare_run.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "86d2c52270dcc5eeebb4412e94fcf94e542182f7163fb996ed741d932d68204a",
  "size": 3918
}

added `/files/modules~1attribute-reporting~1scripts~1project_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c5ad8e78591e2304371ff7ade9dbb8a302305bfea956a4ec2e5e50730459f023",
  "size": 7002
}

added `/files/modules~1attribute-reporting~1scripts~1render_brand_fit_report.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9de5c11b392e33094ae4af8ac702d6dbe3d43c2be33ac33cd7fcc5bf207f3c0c",
  "size": 727
}

added `/files/modules~1attribute-reporting~1scripts~1render_report.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "51e198ac847156d978815a2e34dd3307caba827fb0b5bb5a4c89b214fbc27b9e",
  "size": 1796
}

added `/files/modules~1attribute-reporting~1scripts~1run_state.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1ce28986e52c0efa18560afc01024fdce03ad6b6ef49ac25b7d4eaabac7d5308",
  "size": 20779
}

added `/files/modules~1attribute-reporting~1scripts~1server_bridge_client.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d9ca2aa1ff6ecf7679eb835e40c1f0c56bdc72f1618b82d0cf2671704c5ae1f5",
  "size": 40486
}

added `/files/modules~1attribute-reporting~1scripts~1validate_mapping_decisions.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8a90b8ac2b42cb273c11a3b86bf0a0c661c45740936105cc9bec114b0ea6e2d1",
  "size": 1926
}

added `/files/modules~1attribute-reporting~1scripts~1validate_mapping_review.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "0457715ca2895eab228a854aa58374ec81d3db27872a0b4fbd534f35a93f32d0",
  "size": 2172
}

added `/files/modules~1attribute-reporting~1skills~1attribute-reporting~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "936411e8d0f4aefb76e32fe74b968cb82782f5f1703b0e611178f8c75bee83fd",
  "size": 32571
}

added `/files/modules~1attribute-reporting~1skills~1attribute-reporting~1references~1server-boundary.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "c6c0476aaffd73e547a8801573598988c177afa1b96fd099fd6d00cd9609f769",
  "size": 10999
}

added `/files/modules~1attribute-reporting~1skills~1attribute-reporting~1references~1workflow-reference.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "765e0a37288e20c148c8dd3f699b53a5fb4239156e0a5592f4da8ef1fd85e8f4",
  "size": 22997
}

added `/files/modules~1attribute-reporting~1skills~1brand-fit~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "692acf92c23bf51e3d7e86b9fd69ff3dbd0b32a5f39947247273a51a4e803e0b",
  "size": 9895
}

added `/files/modules~1attribute-reporting~1vendor~1modules~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
  "size": 1
}

added `/files/modules~1attribute-reporting~1vendor~1modules~1pdp~1attribute_report_copy.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "c388ee1e2681df6c9cd611a0afcd75b1035a95d07110214da0492179e7eac6dd",
  "size": 47111
}

added `/files/modules~1attribute-reporting~1vendor~1modules~1pdp~1attribute_table_catalog.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "5f5a44e1ff0b3c6de6a64f0efe4886b1a103911fbb8e6ee7507a5fdbc5f6c1ad",
  "size": 5608
}

added `/files/modules~1attribute-reporting~1vendor~1modules~1pdp~1attribute_table_catalog.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "db3eebe7ce9ded9acf25a9da33bf7ec70c8ee762f36c46512ccc2c471fefedc0",
  "size": 4036
}

added `/files/modules~1attribute-reporting~1vendor~1modules~1pdp~1attribute_table_templates.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4e4a46812fa6a4c04e0e78d18b9f51cfee86bfaa629827abf50e9e0cd93a33f5",
  "size": 44328
}

added `/files/modules~1attribute-reporting~1vendor~1modules~1utilities~1utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dfeb4543d1482650e8be2bf6ea9f5ff313abe7dde7fef0539031c95a08a5c56e",
  "size": 7566
}

added `/files/modules~1business-planning~1.codex-plugin~1plugin.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "1c8b35b2e4a152fa2ebca901df2495f33b5e780c4e5251ccb0934f83ec1402c0",
  "size": 1892
}

added `/files/modules~1business-planning~1assets~1icon.svg`

BEFORE

Field was absent

AFTER

{
  "sha256": "785402457fc534e9c558bc9320e1495957e4c825399d55db53b516d971f20c51",
  "size": 913
}

added `/files/modules~1business-planning~1assets~1report-interaction.css`

BEFORE

Field was absent

AFTER

{
  "sha256": "e80e8e85ca62779557d302446c0cdaccad00be2a2220c87adb0cef02ac8cd4b7",
  "size": 1100
}

added `/files/modules~1business-planning~1assets~1report-interaction.js`

BEFORE

Field was absent

AFTER

{
  "sha256": "3a9809b9b3bf2396fae1ce7fcca96071b517449cb03c8c5d774887fae2485b97",
  "size": 1364
}

added `/files/modules~1business-planning~1evals~1decision_assessment_cases.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "eb732a7daf3f2d1c9be100ab9058178b9d59c051c19f0a12fdb0bcea8e5cb038",
  "size": 2763
}

added `/files/modules~1business-planning~1evals~1trigger_fixtures.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "57690c065c7142cf52a85ac1a0d846f1307b0015b46c2f804083762838ab7440",
  "size": 2541
}

added `/files/modules~1business-planning~1references~1case-contract.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "d26e907e314b421fb72b3d58e9e9bc81f292072ab199eae48dcbe2d558a5ed67",
  "size": 25624
}

added `/files/modules~1business-planning~1references~1financing-assessment.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "8fca3d1622c56814ddbfe3537adee25c762535a5aac687e43aec140f60d2125d",
  "size": 5129
}

added `/files/modules~1business-planning~1references~1sites-delivery.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "11eff0e90e80cfb5fa853d509c82cbdfec60ab625a23d501ad9f4ed94e767776",
  "size": 3807
}

added `/files/modules~1business-planning~1requirements-pdf.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "6ab735f53cb40a6cbe0aad3aa4c51187efde50843e206efeaa56dce32c8c5674",
  "size": 166
}

added `/files/modules~1business-planning~1requirements.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "9bba605fd7b6ea23038de15e5a1ae6714b3d3fb14ed2d6e6bedbfb0665ca2122",
  "size": 17
}

added `/files/modules~1business-planning~1scripts~1business_planning_contribution.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ad2f1500df8ceb0127ce22aae3bd85ead8b57c84616ebd4db23022795e1f2926",
  "size": 18640
}

added `/files/modules~1business-planning~1scripts~1business_planning_core.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "28bf6bc3bf03fc6eb7ba05ce38c66b417a6aa5461ffcd0048b5033bf96d67963",
  "size": 53574
}

added `/files/modules~1business-planning~1scripts~1check_dependencies.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "df7d7c9ab748163f98d50d3514f859594ea89aab65b05b302bb2d7987c8410c2",
  "size": 2303
}

added `/files/modules~1business-planning~1scripts~1planning_assessment.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ae5f7075ccad11e35d6a7b0559d5b1a44037efcd9d9eaf3949f7c5dd8374b389",
  "size": 3780
}

added `/files/modules~1business-planning~1scripts~1planning_cli.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "677242e2a027c0d3c3aeff6cf537cf3e879aedbfc943d2edc6cd7ae4c49874f2",
  "size": 3269
}

added `/files/modules~1business-planning~1scripts~1planning_commercial.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5d318e0fc442378a6ac27780e392a1435bfe0ae0f9b04c7f7e04dcdb5f3eed44",
  "size": 5186
}

added `/files/modules~1business-planning~1scripts~1planning_cycle.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "86ea90f4c52b8b00bd012e6da49d08b337a3a8aac3ac8be072b648e8076b991e",
  "size": 7261
}

added `/files/modules~1business-planning~1scripts~1planning_decision_report.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "41de252255551ce768c4dd3fb5ae3f86a161d17eaccd3581a69ad6b374ff86d7",
  "size": 4286
}

added `/files/modules~1business-planning~1scripts~1planning_financing.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e6c852b3d34817a3b4a111223e7e3071430261301dfba6d509339fe60fdcd25a",
  "size": 6330
}

added `/files/modules~1business-planning~1scripts~1planning_french.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3ad166b7f13337280aa13de20da6e56d3167b1ac0f882e763a1f963b338e9780",
  "size": 8037
}

added `/files/modules~1business-planning~1scripts~1planning_interaction.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3acf8c8bc7e22042291f8050205bf2c3fcf17c5a66c9d5e3621d61cd236d63bf",
  "size": 4114
}

added `/files/modules~1business-planning~1scripts~1planning_presentation.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f9ccfc89c1ecf912e22b989b033bd7abd95964b26c7b5706e213f89464576e3a",
  "size": 28389
}

added `/files/modules~1business-planning~1scripts~1planning_report.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "077d47c8bb10d28b0dfb5d20140d60da9247d9483d5697dbe0924a69b7992822",
  "size": 43811
}

added `/files/modules~1business-planning~1scripts~1planning_site.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2c78c6cba31ce24603582d5b8c739c5fdabe4ed3e5eb14189331a8d69b36af7f",
  "size": 3090
}

added `/files/modules~1business-planning~1scripts~1planning_workflow.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "44bb1a8ae6193bdea5c7e4a9173181c6cd0fb73dc0cfcc97f72fbf7d6d7ce506",
  "size": 41810
}

added `/files/modules~1business-planning~1scripts~1prepare_report_site.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1d49f59d6e493f658902b828048332859edd996dfa3494a7532a31a6e056f38e",
  "size": 1551
}

added `/files/modules~1business-planning~1scripts~1run_business_plan.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ce43cb335e342c74b5fe578d2b52558ccc2fef85678cc6ffdf07008a87c5d9c9",
  "size": 1723
}

added `/files/modules~1business-planning~1scripts~1run_strategic_plan.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ecf900ef1a32771f53848eac3d530bd908a95b27a0a80227f0aff7cce2cf653c",
  "size": 1726
}

added `/files/modules~1business-planning~1scripts~1strategic_planning_core.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7f5360c69a0441de3647e6077fe7b0a876eaa194366afc38c3bf04a7a1b5fb51",
  "size": 44486
}

added `/files/modules~1business-planning~1skills~1business-planning~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "76a7c1d31a6be7be73eb917b33784f513211d6feeae04b8a72584f996c681aea",
  "size": 22842
}

added `/files/modules~1business-planning~1skills~1business-planning~1references~1geneva.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "dcc3568a18a17179f0c4b3092beaac512e426e102e1a3ec122094b0619cd3acb",
  "size": 806
}

added `/files/modules~1business-planning~1vendor~1modules~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1business-planning~1vendor~1modules~1reporting_table.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "99b687b83f4ce62fb2a33c875cf5740edb0854e9a7b094f1c314b1b6198adc1e",
  "size": 17079
}

added `/files/modules~1business-planning~1vendor~1modules~1vera_assurance~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e7c525a93ec80ec01a6134527f33a17d07f61cccafd90b33d26bdb96d8e1281f",
  "size": 2710
}

added `/files/modules~1business-planning~1vendor~1modules~1vera_assurance~1contracts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8203378c30262e1dfc568099a34a444cb33130343abf17d4a2eea8da107d7cb0",
  "size": 93104
}

added `/files/modules~1business-planning~1vendor~1modules~1vera_assurance~1decisions.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "28b62f4932997aa50d4d5b099383823096c203a035f1fdbb94ec97b0ce7fe63b",
  "size": 6397
}

added `/files/modules~1business-planning~1vendor~1modules~1vera_assurance~1envelope.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "80f9b005b190a2607ab3a12ad9c508174c8de100d7b9752f87644c62db070358",
  "size": 18987
}

added `/files/modules~1business-planning~1vendor~1modules~1vera_assurance~1jurisdiction.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9bbf63c917cad41f2d2f516c7400b092d1a5a020e8e6e83831fbacc31968ebf1",
  "size": 7887
}

added `/files/modules~1business-planning~1vendor~1modules~1vera_assurance~1money.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a2064acd368ae921fc37156e88711ed9afef4c7b8de7a374be552fa644a52431",
  "size": 10967
}

added `/files/modules~1business-planning~1vendor~1modules~1vera_assurance~1recovery.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fbc5402144b405057deb92005580923f7b2ab67cfd439fe2af977a49f96f1715",
  "size": 21592
}

added `/files/modules~1business-planning~1vendor~1modules~1vera_assurance~1relationships.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bfadd997d33e764f414e55d967933a7745ba0a9032df21addf8fed076400a085",
  "size": 15349
}

added `/files/modules~1business-planning~1vendor~1modules~1vera_assurance~1review_output_transaction.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "63075c6c3b0eff1d3a6706aa59d0dd1e00c558f9a4b51dcf952e881caccfa348",
  "size": 41618
}

added `/files/modules~1business-planning~1vendor~1modules~1vera_assurance~1serialization.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8fdbb590830d8a41b6bb3271ceb0abf9874237d0151028b994b9e5521077141f",
  "size": 11043
}

added `/files/modules~1distribution-analysis~1.codex-plugin~1plugin.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "c45e0e51efcc5e3230591799ccf77b11d68bd9e936cfce2a1038d6b66f50e9c8",
  "size": 2203
}

added `/files/modules~1distribution-analysis~1README.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "42de98fac4adc48922ed4b259a2a3b01f89eeb86fcd4c46a18c2c4405945bbd6",
  "size": 2014
}

added `/files/modules~1distribution-analysis~1assets~1icon.svg`

BEFORE

Field was absent

AFTER

{
  "sha256": "11a9544c5d33f5243634ea8b3e2064fc2890241646690f05daa4022aac5da2a4",
  "size": 736
}

added `/files/modules~1distribution-analysis~1evals~1trigger_fixtures.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "d9a48a1570f21e3db9e83746aaaede0eac0e4bc37a475d2c3f75ff9aad69115b",
  "size": 895
}

added `/files/modules~1distribution-analysis~1mcp~1server.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "897f611578c78cf35f66ae350430f3e7e75dcc863d47519b165f11c42f8b04d7",
  "size": 65881
}

added `/files/modules~1distribution-analysis~1references~1legacy_distribution_inventory.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "2068461b71786e992b8c47fb77c2b832850d258b0e3bd21e7a876ad45ee47403",
  "size": 2343
}

added `/files/modules~1distribution-analysis~1references~1legacy_inventory.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "26934b40e7127742db193204e40586633c15e625f12c54d9c346c8266fa04768",
  "size": 756
}

added `/files/modules~1distribution-analysis~1requirements.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "ef89688b68ba05bdb864cd0382b15ac2db2210bc6df1a116926fbfe9969639b7",
  "size": 130
}

added `/files/modules~1distribution-analysis~1scripts~1check_dependencies.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "25b3a413f67ca4bd46516a9dcffb68b1a458cac8622e61051fab9223b7c9a7ca",
  "size": 4068
}

added `/files/modules~1distribution-analysis~1scripts~1distribution_core.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1880db72dde1b37e4b8fc5a28bfd864a180d7208db50147095e450ec97ff401d",
  "size": 55886
}

added `/files/modules~1distribution-analysis~1scripts~1inspect_inputs.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a4a9411fb0e2fdbb84bd6f52398107d016a823fa79522667b28de6d4ba2ff524",
  "size": 1669
}

added `/files/modules~1distribution-analysis~1scripts~1legacy_distribution_charting.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "af91327efbc46b31548befe32ae4d01e996cbaac0019349af9fbaa25fde6f5a2",
  "size": 45565
}

added `/files/modules~1distribution-analysis~1scripts~1review_session.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "454f7606ab331b0eb8b6923cf07b1254ac8bb5fa01474c302c5c200057ce20e3",
  "size": 20030
}

added `/files/modules~1distribution-analysis~1scripts~1run_distribution.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a2d510513d7ab0e041cb714d35d513734e070e9e35bc1d1b0634a8af53685133",
  "size": 1665
}

added `/files/modules~1distribution-analysis~1skills~1distribution-analysis~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "67caca336ecd2eff4555b686afcbd46150bb1e7f4d72d3a61952effd646b7da9",
  "size": 10062
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1auth~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1auth~1config.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7e95dfe02a16f254346f49ae981890d5641ca11fa6c32e1ba92269c6e04327a9",
  "size": 4441
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1auth~1google_identity.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bc33a5cacf88ab073c72171640c7067429c6884927ab1628f5fece503262dd9e",
  "size": 5521
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1auth~1session.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "554cb2902d1ad2ee3ce232dd5c06422cd23232d0995489e18c25be61778ae42b",
  "size": 3849
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1chart_harness~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "64040e09b08b176a94cee3a65971c649479d7bc2d47a7a48c0fed0bf00c65dc5",
  "size": 4699
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1chart_harness~1analysis_context.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b1a530fffe1f9ae963950e779dd409920d94a168289f3faafef6cc93c8c2985e",
  "size": 10800
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1chart_harness~1artifacts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "190476ae688368778b08804e049244e595461edb7206f3525a0a1baec1f5b5e6",
  "size": 22039
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1chart_harness~1date_parsing.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "175f17c295b0029db1bb895876aaa4f66d9a3e19b924cfffbbf22af42879a087",
  "size": 1104
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1chart_harness~1metric_semantics.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "10849cdef532699ff323233f4f699eddee7fba7836075984199657c5c8d41f5a",
  "size": 12757
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1chart_harness~1period_contract.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1d04dd1a23808ecda086a53f3d76a492a2600c2b58917a63cd272a0b330e1384",
  "size": 11110
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1chart_harness~1period_derivations.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dfbe2252a94f7a264c1431a82fcf6cedd664756496399ad3090d9ee05c7fe614",
  "size": 30445
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1chart_harness~1period_label_policy.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e03d299651e00918a803e39c135eaeeeda9d972b77336fc8032daf7a068d946b",
  "size": 10567
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1chart_harness~1recipe_filters.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7a5bf6afab4cada57bb7093b517351c2ebeeb586c1524ae4b5a0d265fdc26792",
  "size": 13543
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1chart_harness~1reporting_titles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b60bd2d5d20ed1f05fb1ce41c2a6807b139fc147789b22dde516de72f5fd830f",
  "size": 15842
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "23163594f883b6262202001df66075390e9e30e23df2a858cff3b9b116d841e6",
  "size": 620
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1adjust_position.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "aa92efb668a3f805b6a00759d6f933886c0d881d63a7a4c38247b90775707bc5",
  "size": 24574
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1area_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "47c2b23ba566d76fe253aaa31d32f021827eb56a7005eb7191fa60cff7b5b40b",
  "size": 21316
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1bubble_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f7367dc5809ef5bde6c31b58029c620bd50f582a243cfe90dd38b63df2f5e541",
  "size": 5782
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1chart_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3828d367f5ad4299a4b3e71c06c6517127ec4ffde171b82cf260b74b3567f686",
  "size": 48060
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1chart_primitives.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "38a3ccbac651300f21aae8f8025870aae7bebfd04e28db9f7fd27d6c38e99bf4",
  "size": 94051
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1draw_bubble.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "da11bef92f80038c86a80aa009835d6bb27d20323cc9c813b023546078aaab16",
  "size": 39099
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1draw_charts_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dac0fd1fc0e7c43d997c37213cd62948a38f73bc291e86d0fd22bdf9e90fac0f",
  "size": 156824
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1draw_distribution.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fdb8b8308913e63563dbd8e629b56f0e17dbe43af4e60bfa2a13d583d8f9f474",
  "size": 16947
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1draw_multitier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "79bf120e05207e156ad2103e6be6756ca129352cc496acd8db7867542237d319",
  "size": 97915
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1draw_other_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4a9a5f0cd900619047d1f923859decc99b16a5839b74ad4b896d0cd39b7b4e23",
  "size": 38354
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1draw_pareto.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "318b897545148615807e122073e6247a9f31ad142c87921725ac8a09c1b5fd66",
  "size": 23834
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1draw_scatter.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b24d0b34245382c710f30a230fd7555c7b13b03a84645d5a9c5aa822f0182292",
  "size": 42871
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1draw_timeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "0b812d1fd53ab4ce4baf40e5cd293fd9ee702838e1b8aef528ea39e6289d6dfe",
  "size": 34282
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1draw_venn_upset.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9f87901443c040780033b340bdc7f581d9e79b3dc3f871ff607ba7f23662ad69",
  "size": 9244
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1draw_waterfall.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e4e39337e67efa4f5398b39fda99a096d8453ee7e68fb455f50039b5f2f567e",
  "size": 44354
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1draw_width_and_stacked_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "0ff2a1f0492c01e86176157fa8f2974a434b8dfd3e0de2af5672c091189e211e",
  "size": 115738
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1legacy_draw_waterfall.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6a14e69341f1b1e37bb65fc0b090bfac72ac1951e05a0611507deb739a98ce14",
  "size": 44022
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1logic.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e616f6d339939ffe2131f7eb9cdc5d05d97a144a9ea1114aacd36a6e60a84e08",
  "size": 881
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1make_titles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "338445e55ea08d31a0a153a4737171a175ae6b56306add64ffae82d10558dfde",
  "size": 45352
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1mekko_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d7229676db87f714c77d02df808256e7a835e01c771ac1452c3076722028a62d",
  "size": 41054
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1palettes.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a6ad512a80dff49c70c7b3c44aa7c8b160f9b1a1bf7b7c6d81e3bd45c88beb89",
  "size": 51874
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1plot_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5468db22b976f4eeb76b23bc83e9ae994fb2cc861dc19ce584ebaec8f47fedb4",
  "size": 143629
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1plot_horizontal_bar.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7c407e19d49ff436220e465bdf0e20107ef421a7cc0e8497abe6bfe04eb821c8",
  "size": 1241
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1plotting_utilities.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "62a9e8e68fb02c56949b7e3b67822242fdbca5eb4ad5d05aa39f0b8fe51beb06",
  "size": 45111
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1polars_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b0ba28065a01feaa1e0ca5230a1127b847dbd6cac2cacf321825fc4e423a3ab2",
  "size": 7601
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1prepare_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3421d495f5aabcaffd20572285bc5b8e97bcd3ffe22c15f30ee68a91818984d6",
  "size": 36776
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1run_charting.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "cffeddeed5f075773d58b7947b1365f4acd8f91f8f7f0f5ddc5ce87811ea5ea4",
  "size": 28749
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1scatter_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "da9560c49177b5d8954e82fc8340bd45ab6ae8fb19349f830fdb43cab3e0479a",
  "size": 4831
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1setup_fig.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c4c72ad57df1cc5bda6b71d2cab4aaa9e4128741da4c01c655b5b68b97e99f02",
  "size": 26104
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1small_multiples_ordering.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bd90f35e9fbb8eb5f3ef25a2ee743a4acc0ecda48781435e0522b2b382a6b816",
  "size": 2523
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1stacked_column_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a0bd93e94ec98e8f1a2484e9df813f3154c8117ffb6c6fc3b158922c6b04b66d",
  "size": 27156
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1static_export.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dfe6d915a5b171d018d58472764c9e9431eb6d567093eefea2872e04138bd6d6",
  "size": 1131
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1update_layouts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "05f81b40ed4298d07c51d9465576ebc1b6b4a53689f99319501fe89390cf64c9",
  "size": 60908
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1upset_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c7ef21bbe353280653a5983f5a972a6f406aecbd5a7c024b0bec2a7088447b3f",
  "size": 362
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1charting~1upset_plot.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "494ae1d6c14de66e730ff7d4685a2e0638b7f715895aa82e89899cd930c64fb0",
  "size": 9905
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1data~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
  "size": 1
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1data~1cohort_processing.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c400326ca69007552cd5a23ef5e483b28d3362b4886e859528d32017456d3b91",
  "size": 16284
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1data~1common_data_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6d1da1d46c3194f2531a4a016e6983663be68ef681c35c14d6f87c08a4b014da",
  "size": 132890
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1data~1data_cleaning.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "65c0b486a2c44d7bdef6f5893591313a800c86e103ab7b7d564717aadd7a3b01",
  "size": 33497
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1data~1identify_columns.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "99503c3b78f9292a3886c0dce06763f114b4014552f062fd1f244328fe35b6ad",
  "size": 110631
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1data~1merge_data.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e6db2448e376169026e2f3771ebe7a09fda2de3b28ed3278faf38a4978693da",
  "size": 7151
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1data~1misc_charts_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e93f9b58864160fcacd11d2bf68ddf2f2363d412a496a9b4583ef962f50ca30d",
  "size": 38571
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1data~1multidimensional_charts_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "59a572198611659b84d3a338e8e0b9f581b9a339202ebd1a6bdea579c07d98e6",
  "size": 76808
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1data~1time_series_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6f9fdbfdfc1efef268f14f443b3fbe516661782fa96adfca73a2d64525af36be",
  "size": 4425
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1data~1waterfall_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f78b45dc9ec4073c7f27d864bf790e1572dce80bce3f6d1b45c96dd94c4abd27",
  "size": 55834
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1layout~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1layout~1core~1ui_adapter.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "76b429c2939fe46aea274d84d3100d74ce491b4efef77f5daed0c88a943d3182",
  "size": 3870
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1layout~1core~1widget_state.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "981c40c7692385a2759846de4c95e98e2d9966ac956e33dce4346d62047c1538",
  "size": 3426
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1layout~1layout_data.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "87cf31d1387ad2d7845aa9ecc212feae1bfc6206cc50db9b67b8b72d63574523",
  "size": 2064
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1layout~1layout_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "62b1dae0b4881d9194d4cd10e339417a161b159b76d78d8bde0b1d3efd13c3a4",
  "size": 31815
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1layout~1memoization.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ead4a46d07b43ea84aba55fe0555ee41408e2ba142c0557f0f8d1be91e931ba3",
  "size": 13439
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1layout~1performance.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4996b586dff3692252ec885e66d36a7327070c781c680f41dc5489c171531616",
  "size": 930
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1layout~1session_manager.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e2d8bcc45065741009c314209239be57270455203d22176784dd084e49910f4",
  "size": 1105
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1layout~1set_up_widgets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d12359ef6f67d0be4908a5e849a89935e6aee580897442609f8f71a29d78a5e5",
  "size": 761
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1layout~1widgets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a4c5d79b664bc303080e083850ac0941ce66a0527e9e5858fec66e21aef0f6c0",
  "size": 923
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1llm~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e416198937f477b64f1d2857ae2c442ae0fd5142def500be486a160c2a3d5340",
  "size": 51
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1llm~1confirm_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8d14b250f446893c6266d689f26a40ed8c275ab96fcd2b474a49cd6b60e6bacb",
  "size": 693
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1llm~1interpret_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2a594115f304474e9f55308ab91563645bcfe3b14f24cca416c001d5f45bab68",
  "size": 628
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1llm~1prompt_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f15b08a346138fc64b662d53905d369a00069ae5c67aa51575371b0915d4006e",
  "size": 498
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1plan~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8ca432b4acd188c61581e22655212589661f36359f6f409ea6b9faca4c018a20",
  "size": 72
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1plan~1plan_dataset.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e7827dcf76ea64047d30bd1831745e219719c0bfcb76c0d588715322fed69fe3",
  "size": 601
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1utilities~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1utilities~1config.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b4e7c75e766a2619ab768d2e79e8934b3238083bcfd260fc2a7375b3198aeef1",
  "size": 233980
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1utilities~1date_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ddb2041be93ed08476f4a6c5fad67d6d59d94076cfc20d14c2d89a28b04aaba3",
  "size": 1930
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1utilities~1error_messages.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "87828173f92a862ef37a88181d813ed39a3c1255ff2a6e5ab4a6d6d63d926315",
  "size": 19248
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1utilities~1helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "43c2c6083ad0635ab84664c7c6c8402780363aa718ea239e694785cf98ce29f7",
  "size": 105016
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1utilities~1logging_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e78581502d65120f8a76560769a460702817206fbaf6226f95fdac94eb8e3f84",
  "size": 2551
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1utilities~1notifier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5bcd244b4d319381b9cf67e8f1d6d7a9764891c32fd589801dd1ae5d98846b08",
  "size": 1020
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1utilities~1session_context.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "93399e3e3c8ae812269304f6c3d5325f524baf3f8ce25835391108d158445b3c",
  "size": 8820
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1utilities~1ui_notifier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "918c62f85ff5ddd16337c608d8325b68a356573c54492ac0607a5316b09239cf",
  "size": 7212
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1utilities~1utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e8a7d350a40c9eedd864771c0327b6f1ddac4b40d434c96cbc778df849788b58",
  "size": 11296
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1utils~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1utils~1polars_excel_writer.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c70e202ca92489ee3411bddfa266a786c6838b6b7a9b512c80212f07c737def4",
  "size": 2688
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1variance~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1variance~1index_handling.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d7e578c8dd5cf2a008469d6aee132ca19d0fc416c19761f9f9af4cf9a61ac449",
  "size": 76257
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1variance~1variance_decomposition.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "769cbf8b2096398fa1d9df6ad045f26085b3b0e331cc71f77d2ddde3ded373fe",
  "size": 60557
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1variance~1variance_formulas.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "af95c36e55a861585a1e8e59b2a247f2b1a11cdc747c5a9d561a63b0a7f3e947",
  "size": 92461
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1variance~1variance_orchestrator.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5a1176d5a5ed9a4e97b1d7bd953de68f57a7fde2170480fbd4dfffa5bd92b5c9",
  "size": 83371
}

added `/files/modules~1distribution-analysis~1vendor~1modules~1variance~1variance_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "60b50dd739ff11f1d1b098fcc3c340974ed0825033df0a204fa54980fc6667cf",
  "size": 51623
}

added `/files/modules~1funnel-analysis~1.codex-plugin~1plugin.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "e8b31027d2a6fbaffadcd760579501996fb7cf26c0c54cccda0325bd14a48649",
  "size": 1828
}

added `/files/modules~1funnel-analysis~1README.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "a07d2976601beb9e75f5e8373139cf2737cb717e6bb1c849a5fe070043edda7c",
  "size": 547
}

added `/files/modules~1funnel-analysis~1assets~1icon.svg`

BEFORE

Field was absent

AFTER

{
  "sha256": "3c528c545f2c1a9bb6510fea8ad5454561adb740e0041580b273b42be862ca91",
  "size": 706
}

added `/files/modules~1funnel-analysis~1evals~1trigger_fixtures.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "a45d42b87dfa52e08003f2397bd6c1676e6a8dd6928320dda9315ff6eed19a07",
  "size": 978
}

added `/files/modules~1funnel-analysis~1requirements.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "df9f2fabe756b2206d3f6e2b6f99d6cc7381a51c497a4e5a13abcd978fad40c2",
  "size": 40
}

added `/files/modules~1funnel-analysis~1scripts~1check_dependencies.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fb07cb441aa91c50cef407e58fdd866f9d567f40b9417689edca486136993b04",
  "size": 4206
}

added `/files/modules~1funnel-analysis~1scripts~1funnel_core.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "970b4664ca91d9382a314499287cf71db574c7bf226fc6dc3323cd97f32fce5d",
  "size": 29465
}

added `/files/modules~1funnel-analysis~1scripts~1run_funnel_analysis.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8b315f87ec629bbd66d483736f13209dcec3e9e16d7de82388bc50e96c36a977",
  "size": 1414
}

added `/files/modules~1funnel-analysis~1skills~1funnel-analysis~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "123307632c952defbb102e3bc653d001637624c8519f267c60bdfd159190758c",
  "size": 5613
}

added `/files/modules~1management-control-pack~1.codex-plugin~1plugin.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "9728c5f22f8b208a96515e64f460e203cc4606822f28496d8d3dfebb13528430",
  "size": 2533
}

added `/files/modules~1management-control-pack~1assets~1budget-report.css`

BEFORE

Field was absent

AFTER

{
  "sha256": "708ebf8bc1867002287453273982e1e709a8979bce7935027196559485415bce",
  "size": 999
}

added `/files/modules~1management-control-pack~1assets~1budget-report.js`

BEFORE

Field was absent

AFTER

{
  "sha256": "290f329589411bd18c956ef9d9f908a785cc6775e0e66049063519fc5e6c559b",
  "size": 836
}

added `/files/modules~1management-control-pack~1assets~1icon.svg`

BEFORE

Field was absent

AFTER

{
  "sha256": "8242353d7b5b73e94c302432ec362ea06a36a7acd1682e6b84c9d67bd292ae96",
  "size": 780
}

added `/files/modules~1management-control-pack~1assets~1management-report-copy.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "1214b0fd2646a5a13db85ccebf1ef233f0cb2cb1f8ce3daf28cb681f4244db94",
  "size": 45270
}

added `/files/modules~1management-control-pack~1evals~1trigger_fixtures.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "8c3cd34abc56eddeb611c39c582c0ac3b1c0f1c07b5c75952517c2e88cc79b94",
  "size": 1036
}

added `/files/modules~1management-control-pack~1references~1costing.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "32c07ec98dcb04d9393285c441e3eb1abe926ca5a9baa5a4e0a66e83c026dee2",
  "size": 10183
}

added `/files/modules~1management-control-pack~1requirements.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "9bba605fd7b6ea23038de15e5a1ae6714b3d3fb14ed2d6e6bedbfb0665ca2122",
  "size": 17
}

added `/files/modules~1management-control-pack~1scripts~1budget_presentation.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f28a72487e3c7e726ffc98ee995309d6446469d07feb04ea42b9eb3761e1378d",
  "size": 6629
}

added `/files/modules~1management-control-pack~1scripts~1check_dependencies.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "edbc9f16d57800b1110eb94c9c6d68d94e2713bd2da7120cb5c8bc33186e17a5",
  "size": 1782
}

added `/files/modules~1management-control-pack~1scripts~1costing_core.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4bfdc57844dad015bd4506ece3d322a1f25fecff1a57f04fbe4d1fe56d1fa6eb",
  "size": 20298
}

added `/files/modules~1management-control-pack~1scripts~1costing_pack.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8d83ea5cf28a22a0f08aaf427a7022452a92a92b045cbd4765f9cea51cc9f9d2",
  "size": 10382
}

added `/files/modules~1management-control-pack~1scripts~1costing_report.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5163f73c6e780b5923e4304140530defd05c82725fbc1b3fd67c630b1a93161d",
  "size": 15423
}

added `/files/modules~1management-control-pack~1scripts~1finalize_pack.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "acd51df1fc944ca307527d3509c2641f75ba9746963bd780c8c991562e70fb63",
  "size": 3357
}

added `/files/modules~1management-control-pack~1scripts~1inspect_inputs.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "cfbd14235a96796befa1170918bf2cd8bf230a04c4c2015012d07de7083e3e62",
  "size": 2401
}

added `/files/modules~1management-control-pack~1scripts~1management_control_core.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6014b9222498ea75fdacdbaa4baca0188b7f1faf383e80de588a7ce51df4c088",
  "size": 97843
}

added `/files/modules~1management-control-pack~1scripts~1management_delivery.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4f0defc123841a3ed85d69b5dbdb7ea360363a7ef32aba0dac174bce707ce6ef",
  "size": 4505
}

added `/files/modules~1management-control-pack~1scripts~1management_report_copy.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4d972ac51f9d101f954fa4b3aaff645747fa51b7bef9fac4e88fb44a678c7e63",
  "size": 1415
}

added `/files/modules~1management-control-pack~1scripts~1management_site.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5001e888310f865a2d226770a3c1438e4d0f5fdd90f5c4f157a876d9c9828f81",
  "size": 2717
}

added `/files/modules~1management-control-pack~1scripts~1prepare_report_site.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "81b222612685768843dc76d914b59b0df2a58dbe0abbf41185ccd550cbabbbb1",
  "size": 3366
}

added `/files/modules~1management-control-pack~1scripts~1report_preview.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fbe325749fe1377222d571666b90e5c40cdf3bf66d111b68bea46b3384518cf7",
  "size": 2494
}

added `/files/modules~1management-control-pack~1scripts~1run_costing.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d41bd9be497e090d2fc8e057e44d79f115fcce17e610d3d54e76a6fec75ae303",
  "size": 3774
}

added `/files/modules~1management-control-pack~1scripts~1run_pack.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "52e3e8deb4c2236261c6b00384ced92b0dc00eaf33a2d242726c4b404ab09ac4",
  "size": 2443
}

added `/files/modules~1management-control-pack~1skills~1management-control-pack~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "98203ff2637c939093c705eb50203e3d427e732a898b47407b5d2e1de20aa602",
  "size": 14496
}

added `/files/modules~1management-control-pack~1skills~1management-control-pack~1references~1sites-delivery.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "bd4dd0328b0f8b2f7bb5e244c50ff6ef66664934416894e4d453d071177d92e8",
  "size": 2517
}

added `/files/modules~1management-control-pack~1vendor~1modules~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1management-control-pack~1vendor~1modules~1reporting_table.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "99b687b83f4ce62fb2a33c875cf5740edb0854e9a7b094f1c314b1b6198adc1e",
  "size": 17079
}

added `/files/modules~1management-control-pack~1vendor~1modules~1vera_assurance~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e7c525a93ec80ec01a6134527f33a17d07f61cccafd90b33d26bdb96d8e1281f",
  "size": 2710
}

added `/files/modules~1management-control-pack~1vendor~1modules~1vera_assurance~1contracts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8203378c30262e1dfc568099a34a444cb33130343abf17d4a2eea8da107d7cb0",
  "size": 93104
}

added `/files/modules~1management-control-pack~1vendor~1modules~1vera_assurance~1decisions.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "28b62f4932997aa50d4d5b099383823096c203a035f1fdbb94ec97b0ce7fe63b",
  "size": 6397
}

added `/files/modules~1management-control-pack~1vendor~1modules~1vera_assurance~1envelope.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "80f9b005b190a2607ab3a12ad9c508174c8de100d7b9752f87644c62db070358",
  "size": 18987
}

added `/files/modules~1management-control-pack~1vendor~1modules~1vera_assurance~1jurisdiction.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9bbf63c917cad41f2d2f516c7400b092d1a5a020e8e6e83831fbacc31968ebf1",
  "size": 7887
}

added `/files/modules~1management-control-pack~1vendor~1modules~1vera_assurance~1money.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a2064acd368ae921fc37156e88711ed9afef4c7b8de7a374be552fa644a52431",
  "size": 10967
}

added `/files/modules~1management-control-pack~1vendor~1modules~1vera_assurance~1recovery.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fbc5402144b405057deb92005580923f7b2ab67cfd439fe2af977a49f96f1715",
  "size": 21592
}

added `/files/modules~1management-control-pack~1vendor~1modules~1vera_assurance~1relationships.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bfadd997d33e764f414e55d967933a7745ba0a9032df21addf8fed076400a085",
  "size": 15349
}

added `/files/modules~1management-control-pack~1vendor~1modules~1vera_assurance~1review_output_transaction.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "63075c6c3b0eff1d3a6706aa59d0dd1e00c558f9a4b51dcf952e881caccfa348",
  "size": 41618
}

added `/files/modules~1management-control-pack~1vendor~1modules~1vera_assurance~1serialization.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8fdbb590830d8a41b6bb3271ceb0abf9874237d0151028b994b9e5521077141f",
  "size": 11043
}

added `/files/modules~1mix-contribution-analysis~1.codex-plugin~1plugin.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "9ddbcf93e085483d530b5b4d7c1097e9e2a7eeb2dc2cb79e3544dea8f105fa90",
  "size": 2407
}

added `/files/modules~1mix-contribution-analysis~1README.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "4833ad89d60437848945aade01fa39e5bc1eb2799d6bca1618b32faf397359ff",
  "size": 2105
}

added `/files/modules~1mix-contribution-analysis~1assets~1icon.svg`

BEFORE

Field was absent

AFTER

{
  "sha256": "49c8e9ec27ffc80d7606f8b5f23c60967669e561b8a0c19cf0c587c287862289",
  "size": 772
}

added `/files/modules~1mix-contribution-analysis~1evals~1trigger_fixtures.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "7726024e3aa346a84d2cafcafea557306abfb0fedf34fac53d3beb82c0730735",
  "size": 1128
}

added `/files/modules~1mix-contribution-analysis~1mcp~1server.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "0d5e84940e4fb285d4ef62565b02da0b2d6950c089e0701ebf04a92aea04eb93",
  "size": 66062
}

added `/files/modules~1mix-contribution-analysis~1references~1legacy_inventory.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "738dab5fd7fcb2a72b9e951174079db2ed031d0baaed89cd2ddb4435fe1ddc85",
  "size": 2524
}

added `/files/modules~1mix-contribution-analysis~1requirements.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "b4fdaff17d8edfeace9bca4b5601bcde6ceddb7c21e660e0f812281fa240a799",
  "size": 98
}

added `/files/modules~1mix-contribution-analysis~1scripts~1check_dependencies.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "744d438a2804e811d983be0b40b1274ab8efd3f48b97127629983f8211dddfec",
  "size": 4057
}

added `/files/modules~1mix-contribution-analysis~1scripts~1inspect_inputs.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b6c055cedbe913bf0a49ad02603acd78a1265577a52a54faed9a67459ca59a1e",
  "size": 1475
}

added `/files/modules~1mix-contribution-analysis~1scripts~1legacy_mix_charting.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "52d2aa4815cd8a22898480f7d5ed357e1677e93750655be4f8e09127b146084a",
  "size": 281903
}

added `/files/modules~1mix-contribution-analysis~1scripts~1mix_core.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "475031f5f5c47ff83c37657a8b29781cfc47461b0c4873118e09560505828357",
  "size": 139473
}

added `/files/modules~1mix-contribution-analysis~1scripts~1review_session.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "589fe6a07bba0e67ce1c89f1ac07f3706bb78656fcfff6eaf98456070786af5d",
  "size": 21603
}

added `/files/modules~1mix-contribution-analysis~1scripts~1run_mix_contribution.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "64bd3244ca84e42e718a8740c2c8f1bd8627655b2871d889ca056e574fa41ce9",
  "size": 1589
}

added `/files/modules~1mix-contribution-analysis~1skills~1mix-contribution-analysis~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "f6a59d03e4914d2598bfa5eb9f693d2e52f4a311b0e746b976adb7462d8d30cf",
  "size": 9247
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1auth~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1auth~1config.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7e95dfe02a16f254346f49ae981890d5641ca11fa6c32e1ba92269c6e04327a9",
  "size": 4441
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1auth~1google_identity.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bc33a5cacf88ab073c72171640c7067429c6884927ab1628f5fece503262dd9e",
  "size": 5521
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1auth~1session.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "554cb2902d1ad2ee3ce232dd5c06422cd23232d0995489e18c25be61778ae42b",
  "size": 3849
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1chart_harness~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "64040e09b08b176a94cee3a65971c649479d7bc2d47a7a48c0fed0bf00c65dc5",
  "size": 4699
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1chart_harness~1analysis_context.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b1a530fffe1f9ae963950e779dd409920d94a168289f3faafef6cc93c8c2985e",
  "size": 10800
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1chart_harness~1artifacts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "190476ae688368778b08804e049244e595461edb7206f3525a0a1baec1f5b5e6",
  "size": 22039
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1chart_harness~1date_parsing.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "175f17c295b0029db1bb895876aaa4f66d9a3e19b924cfffbbf22af42879a087",
  "size": 1104
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1chart_harness~1metric_semantics.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "10849cdef532699ff323233f4f699eddee7fba7836075984199657c5c8d41f5a",
  "size": 12757
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1chart_harness~1period_contract.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1d04dd1a23808ecda086a53f3d76a492a2600c2b58917a63cd272a0b330e1384",
  "size": 11110
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1chart_harness~1period_derivations.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dfbe2252a94f7a264c1431a82fcf6cedd664756496399ad3090d9ee05c7fe614",
  "size": 30445
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1chart_harness~1period_label_policy.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e03d299651e00918a803e39c135eaeeeda9d972b77336fc8032daf7a068d946b",
  "size": 10567
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1chart_harness~1recipe_filters.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7a5bf6afab4cada57bb7093b517351c2ebeeb586c1524ae4b5a0d265fdc26792",
  "size": 13543
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1chart_harness~1reporting_titles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b60bd2d5d20ed1f05fb1ce41c2a6807b139fc147789b22dde516de72f5fd830f",
  "size": 15842
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "23163594f883b6262202001df66075390e9e30e23df2a858cff3b9b116d841e6",
  "size": 620
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1adjust_position.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "aa92efb668a3f805b6a00759d6f933886c0d881d63a7a4c38247b90775707bc5",
  "size": 24574
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1area_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "47c2b23ba566d76fe253aaa31d32f021827eb56a7005eb7191fa60cff7b5b40b",
  "size": 21316
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1bubble_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f7367dc5809ef5bde6c31b58029c620bd50f582a243cfe90dd38b63df2f5e541",
  "size": 5782
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1chart_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3828d367f5ad4299a4b3e71c06c6517127ec4ffde171b82cf260b74b3567f686",
  "size": 48060
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1chart_primitives.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "38a3ccbac651300f21aae8f8025870aae7bebfd04e28db9f7fd27d6c38e99bf4",
  "size": 94051
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1draw_bubble.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "da11bef92f80038c86a80aa009835d6bb27d20323cc9c813b023546078aaab16",
  "size": 39099
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1draw_charts_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dac0fd1fc0e7c43d997c37213cd62948a38f73bc291e86d0fd22bdf9e90fac0f",
  "size": 156824
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1draw_distribution.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fdb8b8308913e63563dbd8e629b56f0e17dbe43af4e60bfa2a13d583d8f9f474",
  "size": 16947
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1draw_multitier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "79bf120e05207e156ad2103e6be6756ca129352cc496acd8db7867542237d319",
  "size": 97915
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1draw_other_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4a9a5f0cd900619047d1f923859decc99b16a5839b74ad4b896d0cd39b7b4e23",
  "size": 38354
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1draw_pareto.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "318b897545148615807e122073e6247a9f31ad142c87921725ac8a09c1b5fd66",
  "size": 23834
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1draw_scatter.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b24d0b34245382c710f30a230fd7555c7b13b03a84645d5a9c5aa822f0182292",
  "size": 42871
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1draw_timeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "0b812d1fd53ab4ce4baf40e5cd293fd9ee702838e1b8aef528ea39e6289d6dfe",
  "size": 34282
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1draw_venn_upset.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9f87901443c040780033b340bdc7f581d9e79b3dc3f871ff607ba7f23662ad69",
  "size": 9244
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1draw_waterfall.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e4e39337e67efa4f5398b39fda99a096d8453ee7e68fb455f50039b5f2f567e",
  "size": 44354
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1draw_width_and_stacked_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "0ff2a1f0492c01e86176157fa8f2974a434b8dfd3e0de2af5672c091189e211e",
  "size": 115738
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1legacy_draw_waterfall.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6a14e69341f1b1e37bb65fc0b090bfac72ac1951e05a0611507deb739a98ce14",
  "size": 44022
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1logic.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e616f6d339939ffe2131f7eb9cdc5d05d97a144a9ea1114aacd36a6e60a84e08",
  "size": 881
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1make_titles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "338445e55ea08d31a0a153a4737171a175ae6b56306add64ffae82d10558dfde",
  "size": 45352
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1mekko_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d7229676db87f714c77d02df808256e7a835e01c771ac1452c3076722028a62d",
  "size": 41054
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1palettes.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a6ad512a80dff49c70c7b3c44aa7c8b160f9b1a1bf7b7c6d81e3bd45c88beb89",
  "size": 51874
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1plot_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5468db22b976f4eeb76b23bc83e9ae994fb2cc861dc19ce584ebaec8f47fedb4",
  "size": 143629
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1plot_horizontal_bar.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7c407e19d49ff436220e465bdf0e20107ef421a7cc0e8497abe6bfe04eb821c8",
  "size": 1241
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1plotting_utilities.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "62a9e8e68fb02c56949b7e3b67822242fdbca5eb4ad5d05aa39f0b8fe51beb06",
  "size": 45111
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1polars_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b0ba28065a01feaa1e0ca5230a1127b847dbd6cac2cacf321825fc4e423a3ab2",
  "size": 7601
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1prepare_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3421d495f5aabcaffd20572285bc5b8e97bcd3ffe22c15f30ee68a91818984d6",
  "size": 36776
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1run_charting.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "cffeddeed5f075773d58b7947b1365f4acd8f91f8f7f0f5ddc5ce87811ea5ea4",
  "size": 28749
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1scatter_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "da9560c49177b5d8954e82fc8340bd45ab6ae8fb19349f830fdb43cab3e0479a",
  "size": 4831
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1setup_fig.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c4c72ad57df1cc5bda6b71d2cab4aaa9e4128741da4c01c655b5b68b97e99f02",
  "size": 26104
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1small_multiples_ordering.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bd90f35e9fbb8eb5f3ef25a2ee743a4acc0ecda48781435e0522b2b382a6b816",
  "size": 2523
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1stacked_column_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a0bd93e94ec98e8f1a2484e9df813f3154c8117ffb6c6fc3b158922c6b04b66d",
  "size": 27156
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1static_export.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dfe6d915a5b171d018d58472764c9e9431eb6d567093eefea2872e04138bd6d6",
  "size": 1131
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1update_layouts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "05f81b40ed4298d07c51d9465576ebc1b6b4a53689f99319501fe89390cf64c9",
  "size": 60908
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1upset_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c7ef21bbe353280653a5983f5a972a6f406aecbd5a7c024b0bec2a7088447b3f",
  "size": 362
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1charting~1upset_plot.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "494ae1d6c14de66e730ff7d4685a2e0638b7f715895aa82e89899cd930c64fb0",
  "size": 9905
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1data~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
  "size": 1
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1data~1cohort_processing.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c400326ca69007552cd5a23ef5e483b28d3362b4886e859528d32017456d3b91",
  "size": 16284
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1data~1common_data_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6d1da1d46c3194f2531a4a016e6983663be68ef681c35c14d6f87c08a4b014da",
  "size": 132890
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1data~1data_cleaning.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "65c0b486a2c44d7bdef6f5893591313a800c86e103ab7b7d564717aadd7a3b01",
  "size": 33497
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1data~1identify_columns.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "99503c3b78f9292a3886c0dce06763f114b4014552f062fd1f244328fe35b6ad",
  "size": 110631
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1data~1merge_data.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e6db2448e376169026e2f3771ebe7a09fda2de3b28ed3278faf38a4978693da",
  "size": 7151
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1data~1misc_charts_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e93f9b58864160fcacd11d2bf68ddf2f2363d412a496a9b4583ef962f50ca30d",
  "size": 38571
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1data~1multidimensional_charts_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "59a572198611659b84d3a338e8e0b9f581b9a339202ebd1a6bdea579c07d98e6",
  "size": 76808
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1data~1time_series_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6f9fdbfdfc1efef268f14f443b3fbe516661782fa96adfca73a2d64525af36be",
  "size": 4425
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1data~1waterfall_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f78b45dc9ec4073c7f27d864bf790e1572dce80bce3f6d1b45c96dd94c4abd27",
  "size": 55834
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1layout~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1layout~1core~1ui_adapter.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "76b429c2939fe46aea274d84d3100d74ce491b4efef77f5daed0c88a943d3182",
  "size": 3870
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1layout~1core~1widget_state.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "981c40c7692385a2759846de4c95e98e2d9966ac956e33dce4346d62047c1538",
  "size": 3426
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1layout~1layout_data.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "87cf31d1387ad2d7845aa9ecc212feae1bfc6206cc50db9b67b8b72d63574523",
  "size": 2064
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1layout~1layout_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "62b1dae0b4881d9194d4cd10e339417a161b159b76d78d8bde0b1d3efd13c3a4",
  "size": 31815
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1layout~1memoization.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ead4a46d07b43ea84aba55fe0555ee41408e2ba142c0557f0f8d1be91e931ba3",
  "size": 13439
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1layout~1performance.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4996b586dff3692252ec885e66d36a7327070c781c680f41dc5489c171531616",
  "size": 930
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1layout~1session_manager.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e2d8bcc45065741009c314209239be57270455203d22176784dd084e49910f4",
  "size": 1105
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1layout~1set_up_widgets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d12359ef6f67d0be4908a5e849a89935e6aee580897442609f8f71a29d78a5e5",
  "size": 761
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1layout~1widgets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a4c5d79b664bc303080e083850ac0941ce66a0527e9e5858fec66e21aef0f6c0",
  "size": 923
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1llm~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e416198937f477b64f1d2857ae2c442ae0fd5142def500be486a160c2a3d5340",
  "size": 51
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1llm~1confirm_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8d14b250f446893c6266d689f26a40ed8c275ab96fcd2b474a49cd6b60e6bacb",
  "size": 693
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1llm~1interpret_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2a594115f304474e9f55308ab91563645bcfe3b14f24cca416c001d5f45bab68",
  "size": 628
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1llm~1prompt_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f15b08a346138fc64b662d53905d369a00069ae5c67aa51575371b0915d4006e",
  "size": 498
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1plan~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8ca432b4acd188c61581e22655212589661f36359f6f409ea6b9faca4c018a20",
  "size": 72
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1plan~1plan_dataset.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e7827dcf76ea64047d30bd1831745e219719c0bfcb76c0d588715322fed69fe3",
  "size": 601
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1utilities~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1utilities~1config.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b4e7c75e766a2619ab768d2e79e8934b3238083bcfd260fc2a7375b3198aeef1",
  "size": 233980
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1utilities~1date_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ddb2041be93ed08476f4a6c5fad67d6d59d94076cfc20d14c2d89a28b04aaba3",
  "size": 1930
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1utilities~1error_messages.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "87828173f92a862ef37a88181d813ed39a3c1255ff2a6e5ab4a6d6d63d926315",
  "size": 19248
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1utilities~1helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "43c2c6083ad0635ab84664c7c6c8402780363aa718ea239e694785cf98ce29f7",
  "size": 105016
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1utilities~1logging_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e78581502d65120f8a76560769a460702817206fbaf6226f95fdac94eb8e3f84",
  "size": 2551
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1utilities~1notifier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5bcd244b4d319381b9cf67e8f1d6d7a9764891c32fd589801dd1ae5d98846b08",
  "size": 1020
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1utilities~1session_context.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "93399e3e3c8ae812269304f6c3d5325f524baf3f8ce25835391108d158445b3c",
  "size": 8820
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1utilities~1ui_notifier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "918c62f85ff5ddd16337c608d8325b68a356573c54492ac0607a5316b09239cf",
  "size": 7212
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1utilities~1utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e8a7d350a40c9eedd864771c0327b6f1ddac4b40d434c96cbc778df849788b58",
  "size": 11296
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1utils~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1utils~1polars_excel_writer.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c70e202ca92489ee3411bddfa266a786c6838b6b7a9b512c80212f07c737def4",
  "size": 2688
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1variance~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1variance~1index_handling.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d7e578c8dd5cf2a008469d6aee132ca19d0fc416c19761f9f9af4cf9a61ac449",
  "size": 76257
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1variance~1variance_decomposition.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "769cbf8b2096398fa1d9df6ad045f26085b3b0e331cc71f77d2ddde3ded373fe",
  "size": 60557
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1variance~1variance_formulas.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "af95c36e55a861585a1e8e59b2a247f2b1a11cdc747c5a9d561a63b0a7f3e947",
  "size": 92461
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1variance~1variance_orchestrator.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5a1176d5a5ed9a4e97b1d7bd953de68f57a7fde2170480fbd4dfffa5bd92b5c9",
  "size": 83371
}

added `/files/modules~1mix-contribution-analysis~1vendor~1modules~1variance~1variance_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "60b50dd739ff11f1d1b098fcc3c340974ed0825033df0a204fa54980fc6667cf",
  "size": 51623
}

added `/files/modules~1period-comparison~1.codex-plugin~1plugin.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "ca8bbb0ae738503a578dc7fdaa18657fd7e2bf3f204a38c27ce19d16ecb9e6d3",
  "size": 2227
}

added `/files/modules~1period-comparison~1README.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "e2232ec7830a25285826dbd83a48ed1f6e07702c4076246a987e3f13713a35c9",
  "size": 3282
}

added `/files/modules~1period-comparison~1assets~1icon.svg`

BEFORE

Field was absent

AFTER

{
  "sha256": "48ef17d28bea5644b1ba2963ee31b084c41307e3f451553fefc3809302133081",
  "size": 727
}

added `/files/modules~1period-comparison~1evals~1trigger_fixtures.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "d58870fb00562b83996b6bb02ca5ef2a2c8d22bf14241ce1f84a9578fff7f127",
  "size": 1163
}

added `/files/modules~1period-comparison~1mcp~1server.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "8a7e3d26e437be9d3e3c06a8d9e6fd96e14823dbfaefb6fad6426d90ee5328db",
  "size": 66111
}

added `/files/modules~1period-comparison~1references~1legacy_inventory.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "896e9c615464e9a7a1ec84763773a8ac7a28b0215fa8c5cc53dbeb11484ab02e",
  "size": 2136
}

added `/files/modules~1period-comparison~1requirements.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "faa585f0f884edc202fee8f266310fb5c0d69b996e40c72b5853acd7778f20b8",
  "size": 143
}

added `/files/modules~1period-comparison~1scripts~1check_dependencies.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "71e3a978ecde7ba912fc6ab7a4409c15e21a39415006bd70eb13cc32adaa7ca3",
  "size": 4044
}

added `/files/modules~1period-comparison~1scripts~1inspect_inputs.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f9ea6c0a06fa43a9dae49045e3ad4e092a6132a77fe2013040c4cbf8bc7fbeca",
  "size": 1525
}

added `/files/modules~1period-comparison~1scripts~1legacy_charting.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d435e7e2426273eb9b86385e3ae4f28bf6c6c96b23ae7ff1156ec2cdb3ed3322",
  "size": 67479
}

added `/files/modules~1period-comparison~1scripts~1period_core.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7b790b4e3a0e2c11e14da7d5ab8db50e3bafffba82d5958fac2af827cbcc494e",
  "size": 81684
}

added `/files/modules~1period-comparison~1scripts~1review_session.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bb7bf29c1504da342e9d6fa92577c79b2594d5f9bc0b3999fdc6b812c9170d6e",
  "size": 21876
}

added `/files/modules~1period-comparison~1scripts~1run_period_comparison.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fa537e3a80e794ce07107ae5ac6d9882841416015d1071e919939ade4e3351aa",
  "size": 1597
}

added `/files/modules~1period-comparison~1skills~1period-comparison~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "a6416de337c67064cb35010fc19fd769c8e38b6936cd23f27339e479569d8a6d",
  "size": 11373
}

added `/files/modules~1period-comparison~1vendor~1modules~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1period-comparison~1vendor~1modules~1auth~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1period-comparison~1vendor~1modules~1auth~1config.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7e95dfe02a16f254346f49ae981890d5641ca11fa6c32e1ba92269c6e04327a9",
  "size": 4441
}

added `/files/modules~1period-comparison~1vendor~1modules~1auth~1google_identity.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bc33a5cacf88ab073c72171640c7067429c6884927ab1628f5fece503262dd9e",
  "size": 5521
}

added `/files/modules~1period-comparison~1vendor~1modules~1auth~1session.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "554cb2902d1ad2ee3ce232dd5c06422cd23232d0995489e18c25be61778ae42b",
  "size": 3849
}

added `/files/modules~1period-comparison~1vendor~1modules~1chart_harness~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "64040e09b08b176a94cee3a65971c649479d7bc2d47a7a48c0fed0bf00c65dc5",
  "size": 4699
}

added `/files/modules~1period-comparison~1vendor~1modules~1chart_harness~1analysis_context.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b1a530fffe1f9ae963950e779dd409920d94a168289f3faafef6cc93c8c2985e",
  "size": 10800
}

added `/files/modules~1period-comparison~1vendor~1modules~1chart_harness~1artifacts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "190476ae688368778b08804e049244e595461edb7206f3525a0a1baec1f5b5e6",
  "size": 22039
}

added `/files/modules~1period-comparison~1vendor~1modules~1chart_harness~1date_parsing.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "175f17c295b0029db1bb895876aaa4f66d9a3e19b924cfffbbf22af42879a087",
  "size": 1104
}

added `/files/modules~1period-comparison~1vendor~1modules~1chart_harness~1metric_semantics.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "10849cdef532699ff323233f4f699eddee7fba7836075984199657c5c8d41f5a",
  "size": 12757
}

added `/files/modules~1period-comparison~1vendor~1modules~1chart_harness~1period_contract.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1d04dd1a23808ecda086a53f3d76a492a2600c2b58917a63cd272a0b330e1384",
  "size": 11110
}

added `/files/modules~1period-comparison~1vendor~1modules~1chart_harness~1period_derivations.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dfbe2252a94f7a264c1431a82fcf6cedd664756496399ad3090d9ee05c7fe614",
  "size": 30445
}

added `/files/modules~1period-comparison~1vendor~1modules~1chart_harness~1period_label_policy.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e03d299651e00918a803e39c135eaeeeda9d972b77336fc8032daf7a068d946b",
  "size": 10567
}

added `/files/modules~1period-comparison~1vendor~1modules~1chart_harness~1recipe_filters.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7a5bf6afab4cada57bb7093b517351c2ebeeb586c1524ae4b5a0d265fdc26792",
  "size": 13543
}

added `/files/modules~1period-comparison~1vendor~1modules~1chart_harness~1reporting_titles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b60bd2d5d20ed1f05fb1ce41c2a6807b139fc147789b22dde516de72f5fd830f",
  "size": 15842
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "23163594f883b6262202001df66075390e9e30e23df2a858cff3b9b116d841e6",
  "size": 620
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1adjust_position.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "aa92efb668a3f805b6a00759d6f933886c0d881d63a7a4c38247b90775707bc5",
  "size": 24574
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1area_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "47c2b23ba566d76fe253aaa31d32f021827eb56a7005eb7191fa60cff7b5b40b",
  "size": 21316
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1bubble_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f7367dc5809ef5bde6c31b58029c620bd50f582a243cfe90dd38b63df2f5e541",
  "size": 5782
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1chart_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3828d367f5ad4299a4b3e71c06c6517127ec4ffde171b82cf260b74b3567f686",
  "size": 48060
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1chart_primitives.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "38a3ccbac651300f21aae8f8025870aae7bebfd04e28db9f7fd27d6c38e99bf4",
  "size": 94051
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1draw_bubble.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "da11bef92f80038c86a80aa009835d6bb27d20323cc9c813b023546078aaab16",
  "size": 39099
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1draw_charts_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dac0fd1fc0e7c43d997c37213cd62948a38f73bc291e86d0fd22bdf9e90fac0f",
  "size": 156824
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1draw_distribution.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fdb8b8308913e63563dbd8e629b56f0e17dbe43af4e60bfa2a13d583d8f9f474",
  "size": 16947
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1draw_multitier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "79bf120e05207e156ad2103e6be6756ca129352cc496acd8db7867542237d319",
  "size": 97915
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1draw_other_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4a9a5f0cd900619047d1f923859decc99b16a5839b74ad4b896d0cd39b7b4e23",
  "size": 38354
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1draw_pareto.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "318b897545148615807e122073e6247a9f31ad142c87921725ac8a09c1b5fd66",
  "size": 23834
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1draw_scatter.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b24d0b34245382c710f30a230fd7555c7b13b03a84645d5a9c5aa822f0182292",
  "size": 42871
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1draw_timeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "0b812d1fd53ab4ce4baf40e5cd293fd9ee702838e1b8aef528ea39e6289d6dfe",
  "size": 34282
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1draw_venn_upset.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9f87901443c040780033b340bdc7f581d9e79b3dc3f871ff607ba7f23662ad69",
  "size": 9244
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1draw_waterfall.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e4e39337e67efa4f5398b39fda99a096d8453ee7e68fb455f50039b5f2f567e",
  "size": 44354
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1draw_width_and_stacked_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "0ff2a1f0492c01e86176157fa8f2974a434b8dfd3e0de2af5672c091189e211e",
  "size": 115738
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1legacy_draw_waterfall.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6a14e69341f1b1e37bb65fc0b090bfac72ac1951e05a0611507deb739a98ce14",
  "size": 44022
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1logic.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e616f6d339939ffe2131f7eb9cdc5d05d97a144a9ea1114aacd36a6e60a84e08",
  "size": 881
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1make_titles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "338445e55ea08d31a0a153a4737171a175ae6b56306add64ffae82d10558dfde",
  "size": 45352
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1mekko_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d7229676db87f714c77d02df808256e7a835e01c771ac1452c3076722028a62d",
  "size": 41054
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1palettes.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a6ad512a80dff49c70c7b3c44aa7c8b160f9b1a1bf7b7c6d81e3bd45c88beb89",
  "size": 51874
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1plot_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5468db22b976f4eeb76b23bc83e9ae994fb2cc861dc19ce584ebaec8f47fedb4",
  "size": 143629
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1plot_horizontal_bar.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7c407e19d49ff436220e465bdf0e20107ef421a7cc0e8497abe6bfe04eb821c8",
  "size": 1241
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1plotting_utilities.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "62a9e8e68fb02c56949b7e3b67822242fdbca5eb4ad5d05aa39f0b8fe51beb06",
  "size": 45111
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1polars_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b0ba28065a01feaa1e0ca5230a1127b847dbd6cac2cacf321825fc4e423a3ab2",
  "size": 7601
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1prepare_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3421d495f5aabcaffd20572285bc5b8e97bcd3ffe22c15f30ee68a91818984d6",
  "size": 36776
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1run_charting.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "cffeddeed5f075773d58b7947b1365f4acd8f91f8f7f0f5ddc5ce87811ea5ea4",
  "size": 28749
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1scatter_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "da9560c49177b5d8954e82fc8340bd45ab6ae8fb19349f830fdb43cab3e0479a",
  "size": 4831
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1setup_fig.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c4c72ad57df1cc5bda6b71d2cab4aaa9e4128741da4c01c655b5b68b97e99f02",
  "size": 26104
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1small_multiples_ordering.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bd90f35e9fbb8eb5f3ef25a2ee743a4acc0ecda48781435e0522b2b382a6b816",
  "size": 2523
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1stacked_column_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a0bd93e94ec98e8f1a2484e9df813f3154c8117ffb6c6fc3b158922c6b04b66d",
  "size": 27156
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1static_export.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dfe6d915a5b171d018d58472764c9e9431eb6d567093eefea2872e04138bd6d6",
  "size": 1131
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1update_layouts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "05f81b40ed4298d07c51d9465576ebc1b6b4a53689f99319501fe89390cf64c9",
  "size": 60908
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1upset_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c7ef21bbe353280653a5983f5a972a6f406aecbd5a7c024b0bec2a7088447b3f",
  "size": 362
}

added `/files/modules~1period-comparison~1vendor~1modules~1charting~1upset_plot.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "494ae1d6c14de66e730ff7d4685a2e0638b7f715895aa82e89899cd930c64fb0",
  "size": 9905
}

added `/files/modules~1period-comparison~1vendor~1modules~1data~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
  "size": 1
}

added `/files/modules~1period-comparison~1vendor~1modules~1data~1cohort_processing.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c400326ca69007552cd5a23ef5e483b28d3362b4886e859528d32017456d3b91",
  "size": 16284
}

added `/files/modules~1period-comparison~1vendor~1modules~1data~1common_data_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6d1da1d46c3194f2531a4a016e6983663be68ef681c35c14d6f87c08a4b014da",
  "size": 132890
}

added `/files/modules~1period-comparison~1vendor~1modules~1data~1data_cleaning.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "65c0b486a2c44d7bdef6f5893591313a800c86e103ab7b7d564717aadd7a3b01",
  "size": 33497
}

added `/files/modules~1period-comparison~1vendor~1modules~1data~1identify_columns.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "99503c3b78f9292a3886c0dce06763f114b4014552f062fd1f244328fe35b6ad",
  "size": 110631
}

added `/files/modules~1period-comparison~1vendor~1modules~1data~1merge_data.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e6db2448e376169026e2f3771ebe7a09fda2de3b28ed3278faf38a4978693da",
  "size": 7151
}

added `/files/modules~1period-comparison~1vendor~1modules~1data~1misc_charts_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e93f9b58864160fcacd11d2bf68ddf2f2363d412a496a9b4583ef962f50ca30d",
  "size": 38571
}

added `/files/modules~1period-comparison~1vendor~1modules~1data~1multidimensional_charts_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "59a572198611659b84d3a338e8e0b9f581b9a339202ebd1a6bdea579c07d98e6",
  "size": 76808
}

added `/files/modules~1period-comparison~1vendor~1modules~1data~1time_series_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6f9fdbfdfc1efef268f14f443b3fbe516661782fa96adfca73a2d64525af36be",
  "size": 4425
}

added `/files/modules~1period-comparison~1vendor~1modules~1data~1waterfall_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f78b45dc9ec4073c7f27d864bf790e1572dce80bce3f6d1b45c96dd94c4abd27",
  "size": 55834
}

added `/files/modules~1period-comparison~1vendor~1modules~1layout~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1period-comparison~1vendor~1modules~1layout~1core~1ui_adapter.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "76b429c2939fe46aea274d84d3100d74ce491b4efef77f5daed0c88a943d3182",
  "size": 3870
}

added `/files/modules~1period-comparison~1vendor~1modules~1layout~1core~1widget_state.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "981c40c7692385a2759846de4c95e98e2d9966ac956e33dce4346d62047c1538",
  "size": 3426
}

added `/files/modules~1period-comparison~1vendor~1modules~1layout~1layout_data.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "87cf31d1387ad2d7845aa9ecc212feae1bfc6206cc50db9b67b8b72d63574523",
  "size": 2064
}

added `/files/modules~1period-comparison~1vendor~1modules~1layout~1layout_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "62b1dae0b4881d9194d4cd10e339417a161b159b76d78d8bde0b1d3efd13c3a4",
  "size": 31815
}

added `/files/modules~1period-comparison~1vendor~1modules~1layout~1memoization.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ead4a46d07b43ea84aba55fe0555ee41408e2ba142c0557f0f8d1be91e931ba3",
  "size": 13439
}

added `/files/modules~1period-comparison~1vendor~1modules~1layout~1performance.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4996b586dff3692252ec885e66d36a7327070c781c680f41dc5489c171531616",
  "size": 930
}

added `/files/modules~1period-comparison~1vendor~1modules~1layout~1session_manager.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e2d8bcc45065741009c314209239be57270455203d22176784dd084e49910f4",
  "size": 1105
}

added `/files/modules~1period-comparison~1vendor~1modules~1layout~1set_up_widgets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d12359ef6f67d0be4908a5e849a89935e6aee580897442609f8f71a29d78a5e5",
  "size": 761
}

added `/files/modules~1period-comparison~1vendor~1modules~1layout~1widgets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a4c5d79b664bc303080e083850ac0941ce66a0527e9e5858fec66e21aef0f6c0",
  "size": 923
}

added `/files/modules~1period-comparison~1vendor~1modules~1llm~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e416198937f477b64f1d2857ae2c442ae0fd5142def500be486a160c2a3d5340",
  "size": 51
}

added `/files/modules~1period-comparison~1vendor~1modules~1llm~1confirm_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8d14b250f446893c6266d689f26a40ed8c275ab96fcd2b474a49cd6b60e6bacb",
  "size": 693
}

added `/files/modules~1period-comparison~1vendor~1modules~1llm~1interpret_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2a594115f304474e9f55308ab91563645bcfe3b14f24cca416c001d5f45bab68",
  "size": 628
}

added `/files/modules~1period-comparison~1vendor~1modules~1llm~1prompt_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f15b08a346138fc64b662d53905d369a00069ae5c67aa51575371b0915d4006e",
  "size": 498
}

added `/files/modules~1period-comparison~1vendor~1modules~1plan~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8ca432b4acd188c61581e22655212589661f36359f6f409ea6b9faca4c018a20",
  "size": 72
}

added `/files/modules~1period-comparison~1vendor~1modules~1plan~1plan_dataset.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e7827dcf76ea64047d30bd1831745e219719c0bfcb76c0d588715322fed69fe3",
  "size": 601
}

added `/files/modules~1period-comparison~1vendor~1modules~1reporting_table.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "99b687b83f4ce62fb2a33c875cf5740edb0854e9a7b094f1c314b1b6198adc1e",
  "size": 17079
}

added `/files/modules~1period-comparison~1vendor~1modules~1utilities~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1period-comparison~1vendor~1modules~1utilities~1config.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b4e7c75e766a2619ab768d2e79e8934b3238083bcfd260fc2a7375b3198aeef1",
  "size": 233980
}

added `/files/modules~1period-comparison~1vendor~1modules~1utilities~1date_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ddb2041be93ed08476f4a6c5fad67d6d59d94076cfc20d14c2d89a28b04aaba3",
  "size": 1930
}

added `/files/modules~1period-comparison~1vendor~1modules~1utilities~1error_messages.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "87828173f92a862ef37a88181d813ed39a3c1255ff2a6e5ab4a6d6d63d926315",
  "size": 19248
}

added `/files/modules~1period-comparison~1vendor~1modules~1utilities~1helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "43c2c6083ad0635ab84664c7c6c8402780363aa718ea239e694785cf98ce29f7",
  "size": 105016
}

added `/files/modules~1period-comparison~1vendor~1modules~1utilities~1logging_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e78581502d65120f8a76560769a460702817206fbaf6226f95fdac94eb8e3f84",
  "size": 2551
}

added `/files/modules~1period-comparison~1vendor~1modules~1utilities~1notifier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5bcd244b4d319381b9cf67e8f1d6d7a9764891c32fd589801dd1ae5d98846b08",
  "size": 1020
}

added `/files/modules~1period-comparison~1vendor~1modules~1utilities~1session_context.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "93399e3e3c8ae812269304f6c3d5325f524baf3f8ce25835391108d158445b3c",
  "size": 8820
}

added `/files/modules~1period-comparison~1vendor~1modules~1utilities~1ui_notifier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "918c62f85ff5ddd16337c608d8325b68a356573c54492ac0607a5316b09239cf",
  "size": 7212
}

added `/files/modules~1period-comparison~1vendor~1modules~1utilities~1utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e8a7d350a40c9eedd864771c0327b6f1ddac4b40d434c96cbc778df849788b58",
  "size": 11296
}

added `/files/modules~1period-comparison~1vendor~1modules~1utils~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1period-comparison~1vendor~1modules~1utils~1polars_excel_writer.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c70e202ca92489ee3411bddfa266a786c6838b6b7a9b512c80212f07c737def4",
  "size": 2688
}

added `/files/modules~1period-comparison~1vendor~1modules~1variance~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1period-comparison~1vendor~1modules~1variance~1index_handling.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d7e578c8dd5cf2a008469d6aee132ca19d0fc416c19761f9f9af4cf9a61ac449",
  "size": 76257
}

added `/files/modules~1period-comparison~1vendor~1modules~1variance~1variance_decomposition.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "769cbf8b2096398fa1d9df6ad045f26085b3b0e331cc71f77d2ddde3ded373fe",
  "size": 60557
}

added `/files/modules~1period-comparison~1vendor~1modules~1variance~1variance_formulas.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "af95c36e55a861585a1e8e59b2a247f2b1a11cdc747c5a9d561a63b0a7f3e947",
  "size": 92461
}

added `/files/modules~1period-comparison~1vendor~1modules~1variance~1variance_orchestrator.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5a1176d5a5ed9a4e97b1d7bd953de68f57a7fde2170480fbd4dfffa5bd92b5c9",
  "size": 83371
}

added `/files/modules~1period-comparison~1vendor~1modules~1variance~1variance_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "60b50dd739ff11f1d1b098fcc3c340974ed0825033df0a204fa54980fc6667cf",
  "size": 51623
}

added `/files/modules~1reporting-engine~1README.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "50a10cc2ac0ebec5c3ed628b8102aca800d3015d0ca2154b7aa2b5e91f2986f6",
  "size": 6284
}

added `/files/modules~1reporting-engine~1catalog~1adapter_registry.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "1ba4308be2f04bc8e66568221f738728765bdbc41b8c402e0462d5cd322b3edc",
  "size": 20880
}

added `/files/modules~1reporting-engine~1catalog~1family_selector_playbooks~1attributes.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "652f3266a6fbff4d4b2ae8099586dd96a232776190808af2ed9c18dad0801b74",
  "size": 8421
}

added `/files/modules~1reporting-engine~1catalog~1family_selector_playbooks~1distribution.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "9e7c0b9c66620d7eccee6d615efc02e2b02289bcbcb181d60d23f2e8cdc3a98b",
  "size": 12382
}

added `/files/modules~1reporting-engine~1catalog~1family_selector_playbooks~1funnel.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "a5c0323e480bbc2b86e9a5e9d595ea3962968b49bafe15a7280684c1cd4c6569",
  "size": 2347
}

added `/files/modules~1reporting-engine~1catalog~1family_selector_playbooks~1index.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "4c6ce54763da9be5e8594c5873c3fb949b2244bda2e47ad33563238fd5bf847c",
  "size": 765
}

added `/files/modules~1reporting-engine~1catalog~1family_selector_playbooks~1mix.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "f75f4a2ca69366e282a94a7ce371c4e891c12202c00819c01d864fff9da9c544",
  "size": 32555
}

added `/files/modules~1reporting-engine~1catalog~1family_selector_playbooks~1period_comparison.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "3936f568ab63894abb0cec3c9d11a63e241c0b65e4b906eb5654c24ab5d5d344",
  "size": 16228
}

added `/files/modules~1reporting-engine~1catalog~1family_selector_playbooks~1scatter_bubble.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "3cbe94e88712738bb0c18b1e3718bce82f9770090d919fce3edef9224172f0e2",
  "size": 4121
}

added `/files/modules~1reporting-engine~1catalog~1family_selector_playbooks~1set_overlap.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "1e737d4beca73eb1b6f1b6a4820c1be39cb0f3c01c407435d3288e7aa5e9321d",
  "size": 5397
}

added `/files/modules~1reporting-engine~1catalog~1family_selector_playbooks~1statement.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "32cc219cd8762f80cd1a7cb2c00da82bfbd0101e478adfc2d6e0a86cdd10037a",
  "size": 2421
}

added `/files/modules~1reporting-engine~1catalog~1family_selector_playbooks~1variance.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "1fb647f1c6aed44780bff17b4bf28537f24e27306da9869637d601ae3778eab5",
  "size": 15249
}

added `/files/modules~1reporting-engine~1catalog~1manifest_assessment.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "839aba7064793f7919a755a4822c8b66343127b7799693f21bbd4b20797c949e",
  "size": 8865
}

added `/files/modules~1reporting-engine~1catalog~1manifest_summary.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "859e130df1d2dd194134bbbc1f6884706c477c07d368fa99c44adb0a2a702951",
  "size": 4300
}

added `/files/modules~1reporting-engine~1catalog~1mechanical_acceptance_summary.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "46f8da4ddeae837e36685ad17d0cc5d0569249595618725fe122e4273f125dae",
  "size": 29991
}

added `/files/modules~1reporting-engine~1catalog~1png_gallery_manifest.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "28fa77ceadfb33e6b0a0089d0fb1b757142e0a3b92e475cee0bbfed8966c9252",
  "size": 216903
}

added `/files/modules~1reporting-engine~1catalog~1role_registry.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "02d13fc0c4cda246206e328801cf759023a0311d4fd6b835b28b63b75c84f4b2",
  "size": 51223
}

added `/files/modules~1reporting-engine~1catalog~1selection_manifest.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "934a06b31811f2aee51863b668070b3b0dcef2f28f4739d3730e9c5b03bfd374",
  "size": 1439212
}

added `/files/modules~1reporting-engine~1catalog~1semantic_acceptance_summary.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "e1bd8b92932fff0964766765b00cf0f92e916e26dd8b399ff9137bf154f7af6e",
  "size": 17543
}

added `/files/modules~1reporting-engine~1catalog~1semantic_layer.schema.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "b4d23bd51fcf9298e68926b995976f31125c5e17d35f200dc82bd4920c34dccb",
  "size": 25532
}

added `/files/modules~1reporting-engine~1fixtures~1mechanical_acceptance~1attribute_package~1innovation_pairs.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "7cbcafca62f1637e861b3b8cc95a26041810a68ccdb91b0df8b3d82e7da68726",
  "size": 339
}

added `/files/modules~1reporting-engine~1fixtures~1mechanical_acceptance~1attribute_package~1top_seller_pairs.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "1b2fcc7d44bfcd8a691cf95eace50195b4c1a581ecbd2e31164d2a955884c9df",
  "size": 359
}

added `/files/modules~1reporting-engine~1fixtures~1mechanical_acceptance~1attribute_recipe.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "971394607f98994feb5a6d3f2028410fd06197a3d6bcfb0ba40cde006fd422f6",
  "size": 41
}

added `/files/modules~1reporting-engine~1fixtures~1mechanical_acceptance~1funnel_stage.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "96eed2b9c134da17083fc73b5b62b4045b8192e974995408d7a51b3897669ff7",
  "size": 120
}

added `/files/modules~1reporting-engine~1fixtures~1mechanical_acceptance~1set_overlap.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "2f32e7d56be56b176a8c98174461953dabeaa45c3b98a70c803c2f8263854cca",
  "size": 400
}

added `/files/modules~1reporting-engine~1fixtures~1mechanical_acceptance~1statement.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "fc6ade94610244df7abac89824807d8f5ba115f10a7a842344c1c30a2c6dbd87",
  "size": 234
}

added `/files/modules~1reporting-engine~1fixtures~1mechanical_acceptance~1statement_recipe.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "89263148fb08ad7a3122a86d2d82489f0864f89aa7ceeb12e711c4f4571659e1",
  "size": 1186
}

added `/files/modules~1reporting-engine~1fixtures~1mechanical_acceptance~1universal_complete.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "bfe18a56603ad5232eba10a45c2cbceec383e40867048ae54e8b27d8fd90b65b",
  "size": 3044
}

added `/files/modules~1reporting-engine~1fixtures~1mechanical_acceptance~1variance_root_cause.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "5420f77921111b36d03caaf99bca154cf5c6ce622f27e37d23c06b24c0348446",
  "size": 246
}

added `/files/modules~1reporting-engine~1fixtures~1semantic_layer~1retail_monthly.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "5473abf694a0a40a04be245bcff25b875c6b42cf9f1da85097fd4f8ffbd7d59a",
  "size": 907
}

added `/files/modules~1reporting-engine~1fixtures~1semantic_layer~1retail_monthly.semantic.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "50f4f3082a216e790ca85593023961d4a790195c814927806b4bfdeacbfac1fb",
  "size": 34386
}

added `/files/modules~1reporting-engine~1fixtures~1semantic_layer~1retail_monthly.snapshot_cases.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "c93fea39f49c11c4cc99d5576e8e00f4f551341e34c151eaf2346ba560b06aa1",
  "size": 553
}

added `/files/modules~1reporting-engine~1fixtures~1semantic_layer~1retail_monthly_extension.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "5765d9edfc127148e0348e0b24dc0b2c266410b5f9c0fa99e9bdf37bac8a0cc4",
  "size": 1028
}

added `/files/modules~1reporting-engine~1fixtures~1semantic_layer~1retail_monthly_incompatible.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "1b155727834d2f145c415e9e210a14d2a2c84106254200fd68fc97b12bfda55b",
  "size": 319
}

added `/files/modules~1reporting-engine~1fixtures~1semantic_layer~1retail_monthly_refresh.csv`

BEFORE

Field was absent

AFTER

{
  "sha256": "d174c933cf05ed6ea24c6abf2f495b6d37379da0f3459e61360d7943360f8a69",
  "size": 1648
}

added `/files/modules~1reporting-engine~1fixtures~1semantic_layer~1retail_monthly_source_notes.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "4ff2398b70225454aaadbce955ae20150151378385b0925a0b92c55432fac27c",
  "size": 3712
}

added `/files/modules~1reporting-engine~1references~1semantic_layer.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "00b83c9edc09c8428717ed0047b72726f1e1d077d99061e2dc8c83998fe1d84a",
  "size": 10515
}

added `/files/modules~1reporting-engine~1requirements-render.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "53f547afe67556e4bd36aaceafe97b32b6235e7ccc5c6984f629291113e24b00",
  "size": 156
}

added `/files/modules~1reporting-engine~1requirements.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "aed9fc3e2dacf46152efcf4ec678bfae9701d7bc7702123717b6b34a7fd12ccf",
  "size": 44
}

added `/files/modules~1reporting-engine~1scripts~1budget_report.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fe69859b4b64c212b2ee4672dcabb73802e8840bc9f5cc312c13542ad7c837dc",
  "size": 4540
}

added `/files/modules~1reporting-engine~1scripts~1budget_report_preview.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fa7668661b094590d62e39678f5dfa4cb39f07e355dcb8fbfd4ed095ef406a6e",
  "size": 3068
}

added `/files/modules~1reporting-engine~1scripts~1check_compatibility.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "edae39a15858bedfb260ca3b0c6f4cbadb0e9aa1f3bc660cb9a3c066dd0490cf",
  "size": 37885
}

added `/files/modules~1reporting-engine~1scripts~1check_dependencies.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e35544e87537ac9afeb033745946471505477ad99c705ca679fa1e924c3c3078",
  "size": 2757
}

added `/files/modules~1reporting-engine~1scripts~1compile_execution.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a4917e9b8b6c6cf2b7aa42d2b181b91e3d497b6aac8f9476709cf76a42d62d4b",
  "size": 8694
}

added `/files/modules~1reporting-engine~1scripts~1dataset_intake.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b712213f606b9aa7dd4f5e0aeb1551f0a64f62accc84f01c6b53959e9922154c",
  "size": 14649
}

added `/files/modules~1reporting-engine~1scripts~1dataset_snapshot.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1befb4b705f976bd19b81a32cf3abb31faf559823f7b9515a92693d214bc0e91",
  "size": 1443
}

added `/files/modules~1reporting-engine~1scripts~1mechanical_acceptance.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e64d8153a877b4799ccd26715276d2c5f44bee527980030ebfa2add6d50333a0",
  "size": 41826
}

added `/files/modules~1reporting-engine~1scripts~1profile_dataset.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "54e58c3a9ddac1c59d7b123ea3065d1d8f3b813cb16b74174828bbe5c292f0c4",
  "size": 46551
}

added `/files/modules~1reporting-engine~1scripts~1render_capability.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "51caedd3ab4d86906abb267d94952403def39a4500c83c82b8f7ec67b6970fab",
  "size": 57039
}

added `/files/modules~1reporting-engine~1scripts~1render_contract_registry.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e20ca3ed1f29e57ce70f0c7014aea0425e147caa8664d9de24bd5d539fde2803",
  "size": 9545
}

added `/files/modules~1reporting-engine~1scripts~1reporting_adapters.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d33dfa1f4bd029e2033c8444d4c5c09444d082bd54a9f67e279cf11e49013104",
  "size": 14408
}

added `/files/modules~1reporting-engine~1scripts~1reporting_contract.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "00aa88c9c4b531deab0db7d4312d6c8657982a468c48d090f3819ec7825a323d",
  "size": 11659
}

added `/files/modules~1reporting-engine~1scripts~1reporting_delivery.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "15ba136a9582249b5f55618144fee660fdaeefaaf6d8b5973c248629e9c4ff01",
  "size": 5773
}

added `/files/modules~1reporting-engine~1scripts~1run_capability.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dce589a03af3b5c568ce86b0c531a4b89354c00abc73067fafc06aac2b77f1a3",
  "size": 12299
}

added `/files/modules~1reporting-engine~1scripts~1semantic_execution.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b8e5094012bcd29be708933abf220b3d195a33d19e5526ffa5c210a81cd42453",
  "size": 6403
}

added `/files/modules~1reporting-engine~1scripts~1semantic_layer.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e993b1bf66d46054ef7a29406721f8c410ef183352ee7bc4c4bfc94caadfd73e",
  "size": 121962
}

added `/files/modules~1scatter-bubble-analysis~1.codex-plugin~1plugin.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "a92c7168ee9170e82f82825f2d2334983ccc5963c2ddca5717f43f373d5e7bda",
  "size": 2167
}

added `/files/modules~1scatter-bubble-analysis~1README.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "a4ef90b9cee7000afa1a8f0117445aea443737fbfcd710dee13f60a90d67e22f",
  "size": 1715
}

added `/files/modules~1scatter-bubble-analysis~1assets~1icon.svg`

BEFORE

Field was absent

AFTER

{
  "sha256": "a37ce03358a219ed11724b398ec59597996a8c3761c19cb10f0e41cb616a8c05",
  "size": 647
}

added `/files/modules~1scatter-bubble-analysis~1evals~1trigger_fixtures.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "16b061ad6cf5a77161ed3ecadfee5f9b76828959fc47b400653bc8bb9805ff9b",
  "size": 903
}

added `/files/modules~1scatter-bubble-analysis~1mcp~1server.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "1ea1a27fb88ea755cd70e9d1fb87fd11a9b43d1203aceb24aa63a01735f5add1",
  "size": 65673
}

added `/files/modules~1scatter-bubble-analysis~1references~1legacy_inventory.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "0d6015be1c3c65ecea34c76524522209b778de0019bf1270be6a4af2e393c037",
  "size": 808
}

added `/files/modules~1scatter-bubble-analysis~1requirements.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "7112d66937eab052100ce81d1a4e534099b2929ffdd4c4d1f1b3887284ff5ec3",
  "size": 116
}

added `/files/modules~1scatter-bubble-analysis~1scripts~1check_dependencies.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "72251db311385e5a66aa602f4738b8d55f3325c4f1a3633965dff97fe82f76c8",
  "size": 4459
}

added `/files/modules~1scatter-bubble-analysis~1scripts~1inspect_inputs.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fe31ad71b2b7646ddff2e724db6661526293e188c438b03ab10200f2b30436fa",
  "size": 2499
}

added `/files/modules~1scatter-bubble-analysis~1scripts~1legacy_scatter_bubble_charting.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2fe9e69039b874dc1c24645fdc3b9c0bd4a49216741c3455f446a15bdcd20f59",
  "size": 67754
}

added `/files/modules~1scatter-bubble-analysis~1scripts~1review_session.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1dc2e5ac1aa4dd4bbe86d73da0d0c85cb058d4223e5d96c0c6efaa3e1197543b",
  "size": 26339
}

added `/files/modules~1scatter-bubble-analysis~1scripts~1run_scatter_bubble.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f0068c9ff806c172743340b846ea1bae0933f5a26e787c1866271a1bddfab394",
  "size": 1678
}

added `/files/modules~1scatter-bubble-analysis~1scripts~1scatter_bubble_core.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1b6436a2e412303a7f9d12a1f30af529914dff505dae426c55c76e93f6de53ed",
  "size": 65398
}

added `/files/modules~1scatter-bubble-analysis~1skills~1scatter-bubble-analysis~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "016ce55ca53b4eceb59be297086ff57a1b9093c3b116701f097df757fcfc738c",
  "size": 9973
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1auth~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1auth~1config.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7e95dfe02a16f254346f49ae981890d5641ca11fa6c32e1ba92269c6e04327a9",
  "size": 4441
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1auth~1google_identity.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bc33a5cacf88ab073c72171640c7067429c6884927ab1628f5fece503262dd9e",
  "size": 5521
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1auth~1session.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "554cb2902d1ad2ee3ce232dd5c06422cd23232d0995489e18c25be61778ae42b",
  "size": 3849
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1chart_harness~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "64040e09b08b176a94cee3a65971c649479d7bc2d47a7a48c0fed0bf00c65dc5",
  "size": 4699
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1chart_harness~1analysis_context.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b1a530fffe1f9ae963950e779dd409920d94a168289f3faafef6cc93c8c2985e",
  "size": 10800
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1chart_harness~1artifacts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "190476ae688368778b08804e049244e595461edb7206f3525a0a1baec1f5b5e6",
  "size": 22039
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1chart_harness~1date_parsing.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "175f17c295b0029db1bb895876aaa4f66d9a3e19b924cfffbbf22af42879a087",
  "size": 1104
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1chart_harness~1metric_semantics.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "10849cdef532699ff323233f4f699eddee7fba7836075984199657c5c8d41f5a",
  "size": 12757
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1chart_harness~1period_contract.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1d04dd1a23808ecda086a53f3d76a492a2600c2b58917a63cd272a0b330e1384",
  "size": 11110
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1chart_harness~1period_derivations.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dfbe2252a94f7a264c1431a82fcf6cedd664756496399ad3090d9ee05c7fe614",
  "size": 30445
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1chart_harness~1period_label_policy.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e03d299651e00918a803e39c135eaeeeda9d972b77336fc8032daf7a068d946b",
  "size": 10567
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1chart_harness~1recipe_filters.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7a5bf6afab4cada57bb7093b517351c2ebeeb586c1524ae4b5a0d265fdc26792",
  "size": 13543
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1chart_harness~1reporting_titles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b60bd2d5d20ed1f05fb1ce41c2a6807b139fc147789b22dde516de72f5fd830f",
  "size": 15842
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "23163594f883b6262202001df66075390e9e30e23df2a858cff3b9b116d841e6",
  "size": 620
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1adjust_position.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "aa92efb668a3f805b6a00759d6f933886c0d881d63a7a4c38247b90775707bc5",
  "size": 24574
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1area_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "47c2b23ba566d76fe253aaa31d32f021827eb56a7005eb7191fa60cff7b5b40b",
  "size": 21316
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1bubble_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f7367dc5809ef5bde6c31b58029c620bd50f582a243cfe90dd38b63df2f5e541",
  "size": 5782
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1chart_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3828d367f5ad4299a4b3e71c06c6517127ec4ffde171b82cf260b74b3567f686",
  "size": 48060
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1chart_primitives.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "38a3ccbac651300f21aae8f8025870aae7bebfd04e28db9f7fd27d6c38e99bf4",
  "size": 94051
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1draw_bubble.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "da11bef92f80038c86a80aa009835d6bb27d20323cc9c813b023546078aaab16",
  "size": 39099
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1draw_charts_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dac0fd1fc0e7c43d997c37213cd62948a38f73bc291e86d0fd22bdf9e90fac0f",
  "size": 156824
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1draw_distribution.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fdb8b8308913e63563dbd8e629b56f0e17dbe43af4e60bfa2a13d583d8f9f474",
  "size": 16947
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1draw_multitier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "79bf120e05207e156ad2103e6be6756ca129352cc496acd8db7867542237d319",
  "size": 97915
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1draw_other_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4a9a5f0cd900619047d1f923859decc99b16a5839b74ad4b896d0cd39b7b4e23",
  "size": 38354
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1draw_pareto.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "318b897545148615807e122073e6247a9f31ad142c87921725ac8a09c1b5fd66",
  "size": 23834
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1draw_scatter.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b24d0b34245382c710f30a230fd7555c7b13b03a84645d5a9c5aa822f0182292",
  "size": 42871
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1draw_timeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "0b812d1fd53ab4ce4baf40e5cd293fd9ee702838e1b8aef528ea39e6289d6dfe",
  "size": 34282
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1draw_venn_upset.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9f87901443c040780033b340bdc7f581d9e79b3dc3f871ff607ba7f23662ad69",
  "size": 9244
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1draw_waterfall.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e4e39337e67efa4f5398b39fda99a096d8453ee7e68fb455f50039b5f2f567e",
  "size": 44354
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1draw_width_and_stacked_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "0ff2a1f0492c01e86176157fa8f2974a434b8dfd3e0de2af5672c091189e211e",
  "size": 115738
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1legacy_draw_waterfall.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6a14e69341f1b1e37bb65fc0b090bfac72ac1951e05a0611507deb739a98ce14",
  "size": 44022
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1logic.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e616f6d339939ffe2131f7eb9cdc5d05d97a144a9ea1114aacd36a6e60a84e08",
  "size": 881
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1make_titles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "338445e55ea08d31a0a153a4737171a175ae6b56306add64ffae82d10558dfde",
  "size": 45352
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1mekko_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d7229676db87f714c77d02df808256e7a835e01c771ac1452c3076722028a62d",
  "size": 41054
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1palettes.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a6ad512a80dff49c70c7b3c44aa7c8b160f9b1a1bf7b7c6d81e3bd45c88beb89",
  "size": 51874
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1plot_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5468db22b976f4eeb76b23bc83e9ae994fb2cc861dc19ce584ebaec8f47fedb4",
  "size": 143629
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1plot_horizontal_bar.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7c407e19d49ff436220e465bdf0e20107ef421a7cc0e8497abe6bfe04eb821c8",
  "size": 1241
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1plotting_utilities.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "62a9e8e68fb02c56949b7e3b67822242fdbca5eb4ad5d05aa39f0b8fe51beb06",
  "size": 45111
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1polars_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b0ba28065a01feaa1e0ca5230a1127b847dbd6cac2cacf321825fc4e423a3ab2",
  "size": 7601
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1prepare_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3421d495f5aabcaffd20572285bc5b8e97bcd3ffe22c15f30ee68a91818984d6",
  "size": 36776
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1run_charting.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "cffeddeed5f075773d58b7947b1365f4acd8f91f8f7f0f5ddc5ce87811ea5ea4",
  "size": 28749
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1scatter_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "da9560c49177b5d8954e82fc8340bd45ab6ae8fb19349f830fdb43cab3e0479a",
  "size": 4831
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1setup_fig.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c4c72ad57df1cc5bda6b71d2cab4aaa9e4128741da4c01c655b5b68b97e99f02",
  "size": 26104
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1small_multiples_ordering.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bd90f35e9fbb8eb5f3ef25a2ee743a4acc0ecda48781435e0522b2b382a6b816",
  "size": 2523
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1stacked_column_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a0bd93e94ec98e8f1a2484e9df813f3154c8117ffb6c6fc3b158922c6b04b66d",
  "size": 27156
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1static_export.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dfe6d915a5b171d018d58472764c9e9431eb6d567093eefea2872e04138bd6d6",
  "size": 1131
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1update_layouts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "05f81b40ed4298d07c51d9465576ebc1b6b4a53689f99319501fe89390cf64c9",
  "size": 60908
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1upset_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c7ef21bbe353280653a5983f5a972a6f406aecbd5a7c024b0bec2a7088447b3f",
  "size": 362
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1charting~1upset_plot.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "494ae1d6c14de66e730ff7d4685a2e0638b7f715895aa82e89899cd930c64fb0",
  "size": 9905
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1data~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
  "size": 1
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1data~1cohort_processing.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c400326ca69007552cd5a23ef5e483b28d3362b4886e859528d32017456d3b91",
  "size": 16284
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1data~1common_data_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6d1da1d46c3194f2531a4a016e6983663be68ef681c35c14d6f87c08a4b014da",
  "size": 132890
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1data~1data_cleaning.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "65c0b486a2c44d7bdef6f5893591313a800c86e103ab7b7d564717aadd7a3b01",
  "size": 33497
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1data~1identify_columns.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "99503c3b78f9292a3886c0dce06763f114b4014552f062fd1f244328fe35b6ad",
  "size": 110631
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1data~1merge_data.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e6db2448e376169026e2f3771ebe7a09fda2de3b28ed3278faf38a4978693da",
  "size": 7151
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1data~1misc_charts_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e93f9b58864160fcacd11d2bf68ddf2f2363d412a496a9b4583ef962f50ca30d",
  "size": 38571
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1data~1multidimensional_charts_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "59a572198611659b84d3a338e8e0b9f581b9a339202ebd1a6bdea579c07d98e6",
  "size": 76808
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1data~1time_series_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6f9fdbfdfc1efef268f14f443b3fbe516661782fa96adfca73a2d64525af36be",
  "size": 4425
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1data~1waterfall_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f78b45dc9ec4073c7f27d864bf790e1572dce80bce3f6d1b45c96dd94c4abd27",
  "size": 55834
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1layout~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1layout~1core~1ui_adapter.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "76b429c2939fe46aea274d84d3100d74ce491b4efef77f5daed0c88a943d3182",
  "size": 3870
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1layout~1core~1widget_state.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "981c40c7692385a2759846de4c95e98e2d9966ac956e33dce4346d62047c1538",
  "size": 3426
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1layout~1layout_data.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "87cf31d1387ad2d7845aa9ecc212feae1bfc6206cc50db9b67b8b72d63574523",
  "size": 2064
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1layout~1layout_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "62b1dae0b4881d9194d4cd10e339417a161b159b76d78d8bde0b1d3efd13c3a4",
  "size": 31815
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1layout~1memoization.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ead4a46d07b43ea84aba55fe0555ee41408e2ba142c0557f0f8d1be91e931ba3",
  "size": 13439
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1layout~1performance.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4996b586dff3692252ec885e66d36a7327070c781c680f41dc5489c171531616",
  "size": 930
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1layout~1session_manager.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e2d8bcc45065741009c314209239be57270455203d22176784dd084e49910f4",
  "size": 1105
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1layout~1set_up_widgets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d12359ef6f67d0be4908a5e849a89935e6aee580897442609f8f71a29d78a5e5",
  "size": 761
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1layout~1widgets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a4c5d79b664bc303080e083850ac0941ce66a0527e9e5858fec66e21aef0f6c0",
  "size": 923
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1llm~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e416198937f477b64f1d2857ae2c442ae0fd5142def500be486a160c2a3d5340",
  "size": 51
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1llm~1confirm_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8d14b250f446893c6266d689f26a40ed8c275ab96fcd2b474a49cd6b60e6bacb",
  "size": 693
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1llm~1interpret_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2a594115f304474e9f55308ab91563645bcfe3b14f24cca416c001d5f45bab68",
  "size": 628
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1llm~1prompt_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f15b08a346138fc64b662d53905d369a00069ae5c67aa51575371b0915d4006e",
  "size": 498
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1plan~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8ca432b4acd188c61581e22655212589661f36359f6f409ea6b9faca4c018a20",
  "size": 72
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1plan~1plan_dataset.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e7827dcf76ea64047d30bd1831745e219719c0bfcb76c0d588715322fed69fe3",
  "size": 601
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1utilities~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1utilities~1config.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b4e7c75e766a2619ab768d2e79e8934b3238083bcfd260fc2a7375b3198aeef1",
  "size": 233980
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1utilities~1date_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ddb2041be93ed08476f4a6c5fad67d6d59d94076cfc20d14c2d89a28b04aaba3",
  "size": 1930
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1utilities~1error_messages.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "87828173f92a862ef37a88181d813ed39a3c1255ff2a6e5ab4a6d6d63d926315",
  "size": 19248
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1utilities~1helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "43c2c6083ad0635ab84664c7c6c8402780363aa718ea239e694785cf98ce29f7",
  "size": 105016
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1utilities~1logging_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e78581502d65120f8a76560769a460702817206fbaf6226f95fdac94eb8e3f84",
  "size": 2551
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1utilities~1notifier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5bcd244b4d319381b9cf67e8f1d6d7a9764891c32fd589801dd1ae5d98846b08",
  "size": 1020
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1utilities~1session_context.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "93399e3e3c8ae812269304f6c3d5325f524baf3f8ce25835391108d158445b3c",
  "size": 8820
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1utilities~1ui_notifier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "918c62f85ff5ddd16337c608d8325b68a356573c54492ac0607a5316b09239cf",
  "size": 7212
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1utilities~1utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e8a7d350a40c9eedd864771c0327b6f1ddac4b40d434c96cbc778df849788b58",
  "size": 11296
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1utils~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1utils~1polars_excel_writer.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c70e202ca92489ee3411bddfa266a786c6838b6b7a9b512c80212f07c737def4",
  "size": 2688
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1variance~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1variance~1index_handling.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d7e578c8dd5cf2a008469d6aee132ca19d0fc416c19761f9f9af4cf9a61ac449",
  "size": 76257
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1variance~1variance_decomposition.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "769cbf8b2096398fa1d9df6ad045f26085b3b0e331cc71f77d2ddde3ded373fe",
  "size": 60557
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1variance~1variance_formulas.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "af95c36e55a861585a1e8e59b2a247f2b1a11cdc747c5a9d561a63b0a7f3e947",
  "size": 92461
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1variance~1variance_orchestrator.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5a1176d5a5ed9a4e97b1d7bd953de68f57a7fde2170480fbd4dfffa5bd92b5c9",
  "size": 83371
}

added `/files/modules~1scatter-bubble-analysis~1vendor~1modules~1variance~1variance_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "60b50dd739ff11f1d1b098fcc3c340974ed0825033df0a204fa54980fc6667cf",
  "size": 51623
}

added `/files/modules~1set-overlap-analysis~1.codex-plugin~1plugin.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "7a34ebc85e41df334f049376f3d5a0ecf8e7b89f4ee4ffced99d6a7df25a1301",
  "size": 1888
}

added `/files/modules~1set-overlap-analysis~1README.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "85656c5c084bc3bd8748e81741b2f0780a409542870d21967c6f2f7979f3b0d5",
  "size": 4990
}

added `/files/modules~1set-overlap-analysis~1assets~1icon.svg`

BEFORE

Field was absent

AFTER

{
  "sha256": "ef6ab5fc33dbba954e1be8024f4390aea2700290f6212e6e08c33fbdffa84c3b",
  "size": 641
}

added `/files/modules~1set-overlap-analysis~1evals~1trigger_fixtures.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "d0918b820d94161f95f684b00df1b4a9dfdb34541e3209f939c32b87efa314d2",
  "size": 841
}

added `/files/modules~1set-overlap-analysis~1mcp~1server.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "807bed26bfd1ae416fa4e0a2cf0fad720168a3a36bfe2f057ac3de9e5725bb85",
  "size": 64473
}

added `/files/modules~1set-overlap-analysis~1references~1legacy_inventory.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "d3d41f6bd7b14988cc961f90bb455f9f6dcd695c66d0ee35d24688bd49be87ef",
  "size": 918
}

added `/files/modules~1set-overlap-analysis~1references~1legacy_mapping.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "a31bf9cf7bda3d5ee2250f03af8f398926d0f237ed7dbd65dfcbde2cff41969f",
  "size": 1274
}

added `/files/modules~1set-overlap-analysis~1requirements.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "434ae2f248f4cc90c02fa57fb6978bf3025670d79cbc14d0075ce319d53aa479",
  "size": 123
}

added `/files/modules~1set-overlap-analysis~1scripts~1check_dependencies.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "992faed479cd02fa8ebe8a09c914a917f083f082423163a9295f74c2a0e7b045",
  "size": 4416
}

added `/files/modules~1set-overlap-analysis~1scripts~1inspect_inputs.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7b459aa64ebddd9eefcaed1806b5379e02ec08769735a926b83f5eeffaa86619",
  "size": 1568
}

added `/files/modules~1set-overlap-analysis~1scripts~1review_session.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "74571d8511d0d80676a56fa0b665200abe2016855987eec69b5b907c61bdc5a0",
  "size": 27781
}

added `/files/modules~1set-overlap-analysis~1scripts~1run_set_overlap.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "967ef3256b27f6b618b409a50823519bdc9646defefa3a5cd91f353f46d2919a",
  "size": 1553
}

added `/files/modules~1set-overlap-analysis~1scripts~1set_overlap_core.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f759bb0d3394a824bf47c7b5815333c3ee284bad9b85a1875198c0abebfd1929",
  "size": 61531
}

added `/files/modules~1set-overlap-analysis~1skills~1set-overlap-analysis~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "40a9f48db0499ad3f1836f821069f23990bece6d6c70327c4d7155d9d227fdf8",
  "size": 7693
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1auth~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1auth~1config.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7e95dfe02a16f254346f49ae981890d5641ca11fa6c32e1ba92269c6e04327a9",
  "size": 4441
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1auth~1google_identity.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bc33a5cacf88ab073c72171640c7067429c6884927ab1628f5fece503262dd9e",
  "size": 5521
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1auth~1session.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "554cb2902d1ad2ee3ce232dd5c06422cd23232d0995489e18c25be61778ae42b",
  "size": 3849
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1chart_harness~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "64040e09b08b176a94cee3a65971c649479d7bc2d47a7a48c0fed0bf00c65dc5",
  "size": 4699
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1chart_harness~1analysis_context.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b1a530fffe1f9ae963950e779dd409920d94a168289f3faafef6cc93c8c2985e",
  "size": 10800
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1chart_harness~1artifacts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "190476ae688368778b08804e049244e595461edb7206f3525a0a1baec1f5b5e6",
  "size": 22039
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1chart_harness~1date_parsing.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "175f17c295b0029db1bb895876aaa4f66d9a3e19b924cfffbbf22af42879a087",
  "size": 1104
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1chart_harness~1metric_semantics.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "10849cdef532699ff323233f4f699eddee7fba7836075984199657c5c8d41f5a",
  "size": 12757
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1chart_harness~1period_contract.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1d04dd1a23808ecda086a53f3d76a492a2600c2b58917a63cd272a0b330e1384",
  "size": 11110
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1chart_harness~1period_derivations.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dfbe2252a94f7a264c1431a82fcf6cedd664756496399ad3090d9ee05c7fe614",
  "size": 30445
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1chart_harness~1period_label_policy.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e03d299651e00918a803e39c135eaeeeda9d972b77336fc8032daf7a068d946b",
  "size": 10567
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1chart_harness~1recipe_filters.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7a5bf6afab4cada57bb7093b517351c2ebeeb586c1524ae4b5a0d265fdc26792",
  "size": 13543
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1chart_harness~1reporting_titles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b60bd2d5d20ed1f05fb1ce41c2a6807b139fc147789b22dde516de72f5fd830f",
  "size": 15842
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "23163594f883b6262202001df66075390e9e30e23df2a858cff3b9b116d841e6",
  "size": 620
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1adjust_position.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "aa92efb668a3f805b6a00759d6f933886c0d881d63a7a4c38247b90775707bc5",
  "size": 24574
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1area_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "47c2b23ba566d76fe253aaa31d32f021827eb56a7005eb7191fa60cff7b5b40b",
  "size": 21316
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1bubble_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f7367dc5809ef5bde6c31b58029c620bd50f582a243cfe90dd38b63df2f5e541",
  "size": 5782
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1chart_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3828d367f5ad4299a4b3e71c06c6517127ec4ffde171b82cf260b74b3567f686",
  "size": 48060
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1chart_primitives.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "38a3ccbac651300f21aae8f8025870aae7bebfd04e28db9f7fd27d6c38e99bf4",
  "size": 94051
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1draw_bubble.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "da11bef92f80038c86a80aa009835d6bb27d20323cc9c813b023546078aaab16",
  "size": 39099
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1draw_charts_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dac0fd1fc0e7c43d997c37213cd62948a38f73bc291e86d0fd22bdf9e90fac0f",
  "size": 156824
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1draw_distribution.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fdb8b8308913e63563dbd8e629b56f0e17dbe43af4e60bfa2a13d583d8f9f474",
  "size": 16947
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1draw_multitier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "79bf120e05207e156ad2103e6be6756ca129352cc496acd8db7867542237d319",
  "size": 97915
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1draw_other_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4a9a5f0cd900619047d1f923859decc99b16a5839b74ad4b896d0cd39b7b4e23",
  "size": 38354
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1draw_pareto.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "318b897545148615807e122073e6247a9f31ad142c87921725ac8a09c1b5fd66",
  "size": 23834
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1draw_scatter.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b24d0b34245382c710f30a230fd7555c7b13b03a84645d5a9c5aa822f0182292",
  "size": 42871
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1draw_timeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "0b812d1fd53ab4ce4baf40e5cd293fd9ee702838e1b8aef528ea39e6289d6dfe",
  "size": 34282
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1draw_venn_upset.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9f87901443c040780033b340bdc7f581d9e79b3dc3f871ff607ba7f23662ad69",
  "size": 9244
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1draw_waterfall.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e4e39337e67efa4f5398b39fda99a096d8453ee7e68fb455f50039b5f2f567e",
  "size": 44354
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1draw_width_and_stacked_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "0ff2a1f0492c01e86176157fa8f2974a434b8dfd3e0de2af5672c091189e211e",
  "size": 115738
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1legacy_draw_waterfall.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6a14e69341f1b1e37bb65fc0b090bfac72ac1951e05a0611507deb739a98ce14",
  "size": 44022
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1logic.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e616f6d339939ffe2131f7eb9cdc5d05d97a144a9ea1114aacd36a6e60a84e08",
  "size": 881
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1make_titles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "338445e55ea08d31a0a153a4737171a175ae6b56306add64ffae82d10558dfde",
  "size": 45352
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1mekko_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d7229676db87f714c77d02df808256e7a835e01c771ac1452c3076722028a62d",
  "size": 41054
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1palettes.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a6ad512a80dff49c70c7b3c44aa7c8b160f9b1a1bf7b7c6d81e3bd45c88beb89",
  "size": 51874
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1plot_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5468db22b976f4eeb76b23bc83e9ae994fb2cc861dc19ce584ebaec8f47fedb4",
  "size": 143629
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1plot_horizontal_bar.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7c407e19d49ff436220e465bdf0e20107ef421a7cc0e8497abe6bfe04eb821c8",
  "size": 1241
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1plotting_utilities.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "62a9e8e68fb02c56949b7e3b67822242fdbca5eb4ad5d05aa39f0b8fe51beb06",
  "size": 45111
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1polars_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b0ba28065a01feaa1e0ca5230a1127b847dbd6cac2cacf321825fc4e423a3ab2",
  "size": 7601
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1prepare_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3421d495f5aabcaffd20572285bc5b8e97bcd3ffe22c15f30ee68a91818984d6",
  "size": 36776
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1run_charting.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "cffeddeed5f075773d58b7947b1365f4acd8f91f8f7f0f5ddc5ce87811ea5ea4",
  "size": 28749
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1scatter_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "da9560c49177b5d8954e82fc8340bd45ab6ae8fb19349f830fdb43cab3e0479a",
  "size": 4831
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1setup_fig.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c4c72ad57df1cc5bda6b71d2cab4aaa9e4128741da4c01c655b5b68b97e99f02",
  "size": 26104
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1small_multiples_ordering.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bd90f35e9fbb8eb5f3ef25a2ee743a4acc0ecda48781435e0522b2b382a6b816",
  "size": 2523
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1stacked_column_pipeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a0bd93e94ec98e8f1a2484e9df813f3154c8117ffb6c6fc3b158922c6b04b66d",
  "size": 27156
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1static_export.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dfe6d915a5b171d018d58472764c9e9431eb6d567093eefea2872e04138bd6d6",
  "size": 1131
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1update_layouts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "05f81b40ed4298d07c51d9465576ebc1b6b4a53689f99319501fe89390cf64c9",
  "size": 60908
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1upset_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c7ef21bbe353280653a5983f5a972a6f406aecbd5a7c024b0bec2a7088447b3f",
  "size": 362
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1charting~1upset_plot.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "494ae1d6c14de66e730ff7d4685a2e0638b7f715895aa82e89899cd930c64fb0",
  "size": 9905
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1data~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
  "size": 1
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1data~1cohort_processing.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c400326ca69007552cd5a23ef5e483b28d3362b4886e859528d32017456d3b91",
  "size": 16284
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1data~1common_data_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6d1da1d46c3194f2531a4a016e6983663be68ef681c35c14d6f87c08a4b014da",
  "size": 132890
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1data~1data_cleaning.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "65c0b486a2c44d7bdef6f5893591313a800c86e103ab7b7d564717aadd7a3b01",
  "size": 33497
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1data~1identify_columns.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "99503c3b78f9292a3886c0dce06763f114b4014552f062fd1f244328fe35b6ad",
  "size": 110631
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1data~1merge_data.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e6db2448e376169026e2f3771ebe7a09fda2de3b28ed3278faf38a4978693da",
  "size": 7151
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1data~1misc_charts_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e93f9b58864160fcacd11d2bf68ddf2f2363d412a496a9b4583ef962f50ca30d",
  "size": 38571
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1data~1multidimensional_charts_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "59a572198611659b84d3a338e8e0b9f581b9a339202ebd1a6bdea579c07d98e6",
  "size": 76808
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1data~1time_series_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6f9fdbfdfc1efef268f14f443b3fbe516661782fa96adfca73a2d64525af36be",
  "size": 4425
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1data~1waterfall_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f78b45dc9ec4073c7f27d864bf790e1572dce80bce3f6d1b45c96dd94c4abd27",
  "size": 55834
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1layout~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1layout~1core~1ui_adapter.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "76b429c2939fe46aea274d84d3100d74ce491b4efef77f5daed0c88a943d3182",
  "size": 3870
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1layout~1core~1widget_state.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "981c40c7692385a2759846de4c95e98e2d9966ac956e33dce4346d62047c1538",
  "size": 3426
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1layout~1layout_data.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "87cf31d1387ad2d7845aa9ecc212feae1bfc6206cc50db9b67b8b72d63574523",
  "size": 2064
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1layout~1layout_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "62b1dae0b4881d9194d4cd10e339417a161b159b76d78d8bde0b1d3efd13c3a4",
  "size": 31815
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1layout~1memoization.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ead4a46d07b43ea84aba55fe0555ee41408e2ba142c0557f0f8d1be91e931ba3",
  "size": 13439
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1layout~1performance.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4996b586dff3692252ec885e66d36a7327070c781c680f41dc5489c171531616",
  "size": 930
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1layout~1session_manager.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e2d8bcc45065741009c314209239be57270455203d22176784dd084e49910f4",
  "size": 1105
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1layout~1set_up_widgets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d12359ef6f67d0be4908a5e849a89935e6aee580897442609f8f71a29d78a5e5",
  "size": 761
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1layout~1widgets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a4c5d79b664bc303080e083850ac0941ce66a0527e9e5858fec66e21aef0f6c0",
  "size": 923
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1llm~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e416198937f477b64f1d2857ae2c442ae0fd5142def500be486a160c2a3d5340",
  "size": 51
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1llm~1confirm_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8d14b250f446893c6266d689f26a40ed8c275ab96fcd2b474a49cd6b60e6bacb",
  "size": 693
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1llm~1interpret_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2a594115f304474e9f55308ab91563645bcfe3b14f24cca416c001d5f45bab68",
  "size": 628
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1llm~1prompt_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f15b08a346138fc64b662d53905d369a00069ae5c67aa51575371b0915d4006e",
  "size": 498
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1plan~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8ca432b4acd188c61581e22655212589661f36359f6f409ea6b9faca4c018a20",
  "size": 72
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1plan~1plan_dataset.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e7827dcf76ea64047d30bd1831745e219719c0bfcb76c0d588715322fed69fe3",
  "size": 601
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1utilities~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1utilities~1config.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b4e7c75e766a2619ab768d2e79e8934b3238083bcfd260fc2a7375b3198aeef1",
  "size": 233980
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1utilities~1date_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ddb2041be93ed08476f4a6c5fad67d6d59d94076cfc20d14c2d89a28b04aaba3",
  "size": 1930
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1utilities~1error_messages.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "87828173f92a862ef37a88181d813ed39a3c1255ff2a6e5ab4a6d6d63d926315",
  "size": 19248
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1utilities~1helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "43c2c6083ad0635ab84664c7c6c8402780363aa718ea239e694785cf98ce29f7",
  "size": 105016
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1utilities~1logging_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e78581502d65120f8a76560769a460702817206fbaf6226f95fdac94eb8e3f84",
  "size": 2551
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1utilities~1notifier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5bcd244b4d319381b9cf67e8f1d6d7a9764891c32fd589801dd1ae5d98846b08",
  "size": 1020
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1utilities~1session_context.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "93399e3e3c8ae812269304f6c3d5325f524baf3f8ce25835391108d158445b3c",
  "size": 8820
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1utilities~1ui_notifier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "918c62f85ff5ddd16337c608d8325b68a356573c54492ac0607a5316b09239cf",
  "size": 7212
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1utilities~1utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e8a7d350a40c9eedd864771c0327b6f1ddac4b40d434c96cbc778df849788b58",
  "size": 11296
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1utils~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1utils~1polars_excel_writer.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c70e202ca92489ee3411bddfa266a786c6838b6b7a9b512c80212f07c737def4",
  "size": 2688
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1variance~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1variance~1index_handling.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d7e578c8dd5cf2a008469d6aee132ca19d0fc416c19761f9f9af4cf9a61ac449",
  "size": 76257
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1variance~1variance_decomposition.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "769cbf8b2096398fa1d9df6ad045f26085b3b0e331cc71f77d2ddde3ded373fe",
  "size": 60557
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1variance~1variance_formulas.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "af95c36e55a861585a1e8e59b2a247f2b1a11cdc747c5a9d561a63b0a7f3e947",
  "size": 92461
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1variance~1variance_orchestrator.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5a1176d5a5ed9a4e97b1d7bd953de68f57a7fde2170480fbd4dfffa5bd92b5c9",
  "size": 83371
}

added `/files/modules~1set-overlap-analysis~1vendor~1modules~1variance~1variance_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "60b50dd739ff11f1d1b098fcc3c340974ed0825033df0a204fa54980fc6667cf",
  "size": 51623
}

added `/files/modules~1statement-analysis~1.codex-plugin~1plugin.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "a3d67783145a8068c1f9ab1b04ba34193ebae98aa9212d57763541ff14f4fd24",
  "size": 1862
}

added `/files/modules~1statement-analysis~1README.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "fa7ab8303d55ad978bb6bfeb106af0ffd25fa0e83d33af3912f534fef7e7630a",
  "size": 540
}

added `/files/modules~1statement-analysis~1assets~1icon.svg`

BEFORE

Field was absent

AFTER

{
  "sha256": "d3d1f2063dcfab34ac4f142572af0fc26d0becbe226fc58aa7a0b4689d66b57e",
  "size": 651
}

added `/files/modules~1statement-analysis~1evals~1trigger_fixtures.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "a96969c3449938375ee703e1c089e614ba684488b325755d85ee0c33d9bd9c81",
  "size": 959
}

added `/files/modules~1statement-analysis~1requirements.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "df9f2fabe756b2206d3f6e2b6f99d6cc7381a51c497a4e5a13abcd978fad40c2",
  "size": 40
}

added `/files/modules~1statement-analysis~1scripts~1check_dependencies.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b8e5bf73fe98264fa7d48718ffd33137e4997a7da7fbdd915d30e6b71ffe5550",
  "size": 4212
}

added `/files/modules~1statement-analysis~1scripts~1run_statement_analysis.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "492f010cde65c3204ce05358a98549950c9229e763f8acfa70cfd0f74cc7520b",
  "size": 1417
}

added `/files/modules~1statement-analysis~1scripts~1statement_core.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "57284712498865e9fbda685e9d6f32cd9500cf3cc8a560736b764735ec7590be",
  "size": 28129
}

added `/files/modules~1statement-analysis~1skills~1statement-analysis~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "ead12bdb520d9313526ec51248d88245980ae6c4c1b500fba28422a42a639742",
  "size": 5606
}

added `/files/modules~1variance-analysis~1.codex-plugin~1plugin.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "c89280ad441c57c8d1bf52d8571d612bf740c664f8c5b74a5734fe446be9cc10",
  "size": 2433
}

added `/files/modules~1variance-analysis~1README.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "0696a1531885687beec637bcd9362701608992de89e78535e937ae992f84a628",
  "size": 5024
}

added `/files/modules~1variance-analysis~1assets~1icon.svg`

BEFORE

Field was absent

AFTER

{
  "sha256": "b0d8e14b9b0087908ac190c8e626838c43f2f81f84b4dbe542c0ce2a19c0b912",
  "size": 687
}

added `/files/modules~1variance-analysis~1evals~1trigger_fixtures.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "3ba963431f09efad4819284ac032348d1f229306c0472954a5b62526c512e3c1",
  "size": 1122
}

added `/files/modules~1variance-analysis~1mcp~1server.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "9fd3f83c0507dd1152646c8ea30f7a4cfca48f4131383f780dd0bca46f4094c9",
  "size": 75448
}

added `/files/modules~1variance-analysis~1references~1legacy_inventory.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "40245a5dabf9448d8221662f3e20710bda51925b263b7f365e0faaa680a8d2f1",
  "size": 2007
}

added `/files/modules~1variance-analysis~1requirements.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "618fe34637ae3b61e4c951ced96c40c294bfcd1ba2f4872b26f82b9fd6fa498f",
  "size": 167
}

added `/files/modules~1variance-analysis~1scripts~1accounting_controls.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f7c21784fd9e554fc6aebc1aacf025c9aafde8f57af44d3a7e0b5e9c8538c716",
  "size": 7895
}

added `/files/modules~1variance-analysis~1scripts~1check_dependencies.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "25f791ee0aef388b8bd33ca01a2733943cd62c2e1d19824b987ef1ea5b81970f",
  "size": 8336
}

added `/files/modules~1variance-analysis~1scripts~1exploded_variance_bridge_chart.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4d02401b7e442bc5f158c4ba18e2897ecf7c12689db0d6389296fe632f72dd5b",
  "size": 43769
}

added `/files/modules~1variance-analysis~1scripts~1ibcs_titles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "975437bb11fc7b1fe874a06fbf33500c85bb19b8ac3825820235e3cea5a997cd",
  "size": 17283
}

added `/files/modules~1variance-analysis~1scripts~1inspect_column_values.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5f90106c17a98384028bab042e9e58e861d8ef970e072aef34267506dde1872c",
  "size": 4443
}

added `/files/modules~1variance-analysis~1scripts~1inspect_inputs.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "745ccd8fea09237621cf08838141da530d39b9d5e1eedc1c866520b8d813c9f1",
  "size": 3884
}

added `/files/modules~1variance-analysis~1scripts~1legacy_adapter.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2a78bbf9e98ee3649e8e2979a248ca58dc993282433b92376a3bc13789d6a1e3",
  "size": 68779
}

added `/files/modules~1variance-analysis~1scripts~1legacy_plotting.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3b376668b97a3ff7cb9770bc0cab3113210b4cb096b07c90a02b0ed1c34217b6",
  "size": 22176
}

added `/files/modules~1variance-analysis~1scripts~1model_use.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "630e8c31dffa23073bbd80394ac8098362afce20ee9dac327af00e9087a710b0",
  "size": 17147
}

added `/files/modules~1variance-analysis~1scripts~1report_locales.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d2fe7b6bab9ea0c3dcf35ecf7a28bc4c02bc3b51d862f35be63f95eed37fd071",
  "size": 22354
}

added `/files/modules~1variance-analysis~1scripts~1review_preflight.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "84ce5aeeb28ec3cdbe865d37a340e43bfbb7bdf59eceeaeee16be031249f0f0c",
  "size": 1751
}

added `/files/modules~1variance-analysis~1scripts~1review_session.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e28d2930c245cff073c9a7ee75453a691c2a70653ec969f54aeff4e66c888093",
  "size": 42060
}

added `/files/modules~1variance-analysis~1scripts~1root_cause_bridge_chart.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bc9c536a0d95a6fd000d3e00a5d9710c60deb5544a87a1cfae4c082a6250c518",
  "size": 49467
}

added `/files/modules~1variance-analysis~1scripts~1root_cause_client_report.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b3247c253b5185d82e4d9650a48fc7d9fea9754b56c69a338df5f57ebb3d89fc",
  "size": 84547
}

added `/files/modules~1variance-analysis~1scripts~1run_variance.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e7b67974a4af889ca856778f601ae55fea93613d1eda21b0a59cc287b0d1c079",
  "size": 13201
}

added `/files/modules~1variance-analysis~1scripts~1total_by_dimension_bridge_chart.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "46f2e755a0ae1e26bfd39fb050afffa9c4d610df994eb4571b98ab7ec950aafe",
  "size": 31165
}

added `/files/modules~1variance-analysis~1scripts~1variance_core.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b51f6fdbb81b6833c3146e123cbb5a9a506b01ecec6c8ed82f29005a84540b1f",
  "size": 214820
}

added `/files/modules~1variance-analysis~1skills~1variance-analysis~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "8cf715e0b42d23d5cbe0420cc2a7f6b1790436ed461c53a832ff6c0e497631fe",
  "size": 33306
}

added `/files/modules~1variance-analysis~1vendor~1modules~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1variance-analysis~1vendor~1modules~1auth~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1variance-analysis~1vendor~1modules~1auth~1config.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7e95dfe02a16f254346f49ae981890d5641ca11fa6c32e1ba92269c6e04327a9",
  "size": 4441
}

added `/files/modules~1variance-analysis~1vendor~1modules~1auth~1google_identity.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bc33a5cacf88ab073c72171640c7067429c6884927ab1628f5fece503262dd9e",
  "size": 5521
}

added `/files/modules~1variance-analysis~1vendor~1modules~1auth~1session.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "554cb2902d1ad2ee3ce232dd5c06422cd23232d0995489e18c25be61778ae42b",
  "size": 3849
}

added `/files/modules~1variance-analysis~1vendor~1modules~1chart_harness~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "64040e09b08b176a94cee3a65971c649479d7bc2d47a7a48c0fed0bf00c65dc5",
  "size": 4699
}

added `/files/modules~1variance-analysis~1vendor~1modules~1chart_harness~1analysis_context.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b1a530fffe1f9ae963950e779dd409920d94a168289f3faafef6cc93c8c2985e",
  "size": 10800
}

added `/files/modules~1variance-analysis~1vendor~1modules~1chart_harness~1artifacts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "190476ae688368778b08804e049244e595461edb7206f3525a0a1baec1f5b5e6",
  "size": 22039
}

added `/files/modules~1variance-analysis~1vendor~1modules~1chart_harness~1date_parsing.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "175f17c295b0029db1bb895876aaa4f66d9a3e19b924cfffbbf22af42879a087",
  "size": 1104
}

added `/files/modules~1variance-analysis~1vendor~1modules~1chart_harness~1metric_semantics.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "10849cdef532699ff323233f4f699eddee7fba7836075984199657c5c8d41f5a",
  "size": 12757
}

added `/files/modules~1variance-analysis~1vendor~1modules~1chart_harness~1period_contract.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1d04dd1a23808ecda086a53f3d76a492a2600c2b58917a63cd272a0b330e1384",
  "size": 11110
}

added `/files/modules~1variance-analysis~1vendor~1modules~1chart_harness~1period_derivations.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dfbe2252a94f7a264c1431a82fcf6cedd664756496399ad3090d9ee05c7fe614",
  "size": 30445
}

added `/files/modules~1variance-analysis~1vendor~1modules~1chart_harness~1period_label_policy.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e03d299651e00918a803e39c135eaeeeda9d972b77336fc8032daf7a068d946b",
  "size": 10567
}

added `/files/modules~1variance-analysis~1vendor~1modules~1chart_harness~1recipe_filters.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7a5bf6afab4cada57bb7093b517351c2ebeeb586c1524ae4b5a0d265fdc26792",
  "size": 13543
}

added `/files/modules~1variance-analysis~1vendor~1modules~1chart_harness~1reporting_titles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b60bd2d5d20ed1f05fb1ce41c2a6807b139fc147789b22dde516de72f5fd830f",
  "size": 15842
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "69b6ac2411dd762e4bcf7e0a4040dc61a0deadebfd03515245824eaf8c877688",
  "size": 75
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1adjust_position.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "751380954c931e84368ac95bce9398f7f15638bb98f80d6a9a78366c17541d83",
  "size": 24403
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1chart_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c9b4a573bbc69a3797e42e53824415eecaa7bbb8f57347d8ead8f40e65936cf5",
  "size": 46648
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1chart_primitives.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b7d556e52c4d251f6cf5ffce438d2ae77d53fc8442f734134d7581c17e0502d6",
  "size": 91244
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1draw_charts_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "739fc6ae318b25ef6834a4f25a0c15510fd52cc280c02bd8e8e832c13156c4f8",
  "size": 140272
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1draw_multitier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c76b8f9d8baced6008b723540ffa680ef188002a759c3f2e6c459d83b8087373",
  "size": 86234
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1draw_waterfall.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7e41511d19bec2fb18cbac66038e223b7c4c8ab2f31723c680efe8c73f0223ff",
  "size": 71224
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1legacy_draw_waterfall.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6a14e69341f1b1e37bb65fc0b090bfac72ac1951e05a0611507deb739a98ce14",
  "size": 44022
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1make_titles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "68f8e95febbe5f9b59ac77d58c943410d97d5f2010d53651ffed1277046710dc",
  "size": 44550
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1plot_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "90c05ad9535fd2fd9747d108bdaf93f21c78262b865bbb68f0bc4dad38d54fd8",
  "size": 19222
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1polars_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e1fc52cbc2a85c9516ae1c090a832c91e7aa4817dfe6222736c4d6e4d42fd0d",
  "size": 7535
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1prepare_charts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ed24ed55fd080dfd7cf0f78e89bde614eda97052928b4f8004a813d0047db729",
  "size": 36762
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1setup_fig.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c0664e65ca9eb8ca5855eb26863bd57e8905124fadbc93b8f73905f2ceb2bc",
  "size": 26218
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1update_layouts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "92a28c57fe5544c1a6ad64115d6da94056e36372ecb48eb9fc986d4cacfa6d12",
  "size": 59443
}

added `/files/modules~1variance-analysis~1vendor~1modules~1charting~1upset_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c7ef21bbe353280653a5983f5a972a6f406aecbd5a7c024b0bec2a7088447b3f",
  "size": 362
}

added `/files/modules~1variance-analysis~1vendor~1modules~1data~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1variance-analysis~1vendor~1modules~1data~1common_data_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "da96c6e826750bc3515d8582a64bb5690f6603725dc5b1f579e5a939c8ad85fc",
  "size": 131279
}

added `/files/modules~1variance-analysis~1vendor~1modules~1data~1misc_charts_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b7d10cf0b3836c50a99e256ae8a8630ecb6ca786cf6cf6be06e189f04ffbf463",
  "size": 37898
}

added `/files/modules~1variance-analysis~1vendor~1modules~1data~1multidimensional_charts_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6935e57d40d71a8ee4723955bded6c5153188140f3d031ee7c08b307435aa784",
  "size": 74793
}

added `/files/modules~1variance-analysis~1vendor~1modules~1data~1waterfall_data_prep.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ec2b6bf7b4193eeb6ba25a6ee6789aa25cb163a730322e787d53bc190421a7a6",
  "size": 55829
}

added `/files/modules~1variance-analysis~1vendor~1modules~1layout~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1variance-analysis~1vendor~1modules~1layout~1core~1ui_adapter.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "76b429c2939fe46aea274d84d3100d74ce491b4efef77f5daed0c88a943d3182",
  "size": 3870
}

added `/files/modules~1variance-analysis~1vendor~1modules~1layout~1core~1widget_state.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "981c40c7692385a2759846de4c95e98e2d9966ac956e33dce4346d62047c1538",
  "size": 3426
}

added `/files/modules~1variance-analysis~1vendor~1modules~1layout~1layout_data.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "87cf31d1387ad2d7845aa9ecc212feae1bfc6206cc50db9b67b8b72d63574523",
  "size": 2064
}

added `/files/modules~1variance-analysis~1vendor~1modules~1layout~1layout_helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "62b1dae0b4881d9194d4cd10e339417a161b159b76d78d8bde0b1d3efd13c3a4",
  "size": 31815
}

added `/files/modules~1variance-analysis~1vendor~1modules~1layout~1memoization.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ead4a46d07b43ea84aba55fe0555ee41408e2ba142c0557f0f8d1be91e931ba3",
  "size": 13439
}

added `/files/modules~1variance-analysis~1vendor~1modules~1layout~1session_manager.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e2d8bcc45065741009c314209239be57270455203d22176784dd084e49910f4",
  "size": 1105
}

added `/files/modules~1variance-analysis~1vendor~1modules~1layout~1set_up_widgets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d12359ef6f67d0be4908a5e849a89935e6aee580897442609f8f71a29d78a5e5",
  "size": 761
}

added `/files/modules~1variance-analysis~1vendor~1modules~1layout~1widgets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a4c5d79b664bc303080e083850ac0941ce66a0527e9e5858fec66e21aef0f6c0",
  "size": 923
}

added `/files/modules~1variance-analysis~1vendor~1modules~1llm~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e416198937f477b64f1d2857ae2c442ae0fd5142def500be486a160c2a3d5340",
  "size": 51
}

added `/files/modules~1variance-analysis~1vendor~1modules~1llm~1confirm_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8d14b250f446893c6266d689f26a40ed8c275ab96fcd2b474a49cd6b60e6bacb",
  "size": 693
}

added `/files/modules~1variance-analysis~1vendor~1modules~1llm~1interpret_plots.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e31c4f09ee2b1881fe9b5bbb2105da7a903714e70b469e34e4f61752e0ea90d3",
  "size": 568
}

added `/files/modules~1variance-analysis~1vendor~1modules~1plan~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8ca432b4acd188c61581e22655212589661f36359f6f409ea6b9faca4c018a20",
  "size": 72
}

added `/files/modules~1variance-analysis~1vendor~1modules~1plan~1plan_dataset.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b45b85a3af41ac3496cdd4ca165ebe529e7bd31c312abaaaf3bc96af4cbc752f",
  "size": 316
}

added `/files/modules~1variance-analysis~1vendor~1modules~1utilities~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1variance-analysis~1vendor~1modules~1utilities~1config.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d139c54ec4880ef91db4674dd0d093cb795c62072a5e89a1a8a0246af3f1fc33",
  "size": 233948
}

added `/files/modules~1variance-analysis~1vendor~1modules~1utilities~1error_messages.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "87828173f92a862ef37a88181d813ed39a3c1255ff2a6e5ab4a6d6d63d926315",
  "size": 19248
}

added `/files/modules~1variance-analysis~1vendor~1modules~1utilities~1helpers.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "43c2c6083ad0635ab84664c7c6c8402780363aa718ea239e694785cf98ce29f7",
  "size": 105016
}

added `/files/modules~1variance-analysis~1vendor~1modules~1utilities~1logging_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e78581502d65120f8a76560769a460702817206fbaf6226f95fdac94eb8e3f84",
  "size": 2551
}

added `/files/modules~1variance-analysis~1vendor~1modules~1utilities~1notifier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5bcd244b4d319381b9cf67e8f1d6d7a9764891c32fd589801dd1ae5d98846b08",
  "size": 1020
}

added `/files/modules~1variance-analysis~1vendor~1modules~1utilities~1session_context.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "93399e3e3c8ae812269304f6c3d5325f524baf3f8ce25835391108d158445b3c",
  "size": 8820
}

added `/files/modules~1variance-analysis~1vendor~1modules~1utilities~1ui_notifier.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "918c62f85ff5ddd16337c608d8325b68a356573c54492ac0607a5316b09239cf",
  "size": 7212
}

added `/files/modules~1variance-analysis~1vendor~1modules~1utilities~1utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "568d9bbc77d8c01afcb868f3816d3839d346f60121be148acca1bd5b8c5a4900",
  "size": 7512
}

added `/files/modules~1variance-analysis~1vendor~1modules~1utils~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1variance-analysis~1vendor~1modules~1utils~1polars_excel_writer.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c70e202ca92489ee3411bddfa266a786c6838b6b7a9b512c80212f07c737def4",
  "size": 2688
}

added `/files/modules~1variance-analysis~1vendor~1modules~1variance~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/modules~1variance-analysis~1vendor~1modules~1variance~1index_handling.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d7e578c8dd5cf2a008469d6aee132ca19d0fc416c19761f9f9af4cf9a61ac449",
  "size": 76257
}

added `/files/modules~1variance-analysis~1vendor~1modules~1variance~1variance_decomposition.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6791a44d9f8ef9574701a4309f5b7a55d1bcc0a1330fc26d51d5bcc192d22c4a",
  "size": 60860
}

added `/files/modules~1variance-analysis~1vendor~1modules~1variance~1variance_formulas.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "af95c36e55a861585a1e8e59b2a247f2b1a11cdc747c5a9d561a63b0a7f3e947",
  "size": 92461
}

added `/files/modules~1variance-analysis~1vendor~1modules~1variance~1variance_orchestrator.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5a1176d5a5ed9a4e97b1d7bd953de68f57a7fde2170480fbd4dfffa5bd92b5c9",
  "size": 83371
}

added `/files/modules~1variance-analysis~1vendor~1modules~1variance~1variance_utils.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "60b50dd739ff11f1d1b098fcc3c340974ed0825033df0a204fa54980fc6667cf",
  "size": 51623
}

added `/files/modules~1variance-analysis~1vendor~1modules~1vera_assurance~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e7c525a93ec80ec01a6134527f33a17d07f61cccafd90b33d26bdb96d8e1281f",
  "size": 2710
}

added `/files/modules~1variance-analysis~1vendor~1modules~1vera_assurance~1contracts.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8203378c30262e1dfc568099a34a444cb33130343abf17d4a2eea8da107d7cb0",
  "size": 93104
}

added `/files/modules~1variance-analysis~1vendor~1modules~1vera_assurance~1decisions.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "28b62f4932997aa50d4d5b099383823096c203a035f1fdbb94ec97b0ce7fe63b",
  "size": 6397
}

added `/files/modules~1variance-analysis~1vendor~1modules~1vera_assurance~1envelope.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "80f9b005b190a2607ab3a12ad9c508174c8de100d7b9752f87644c62db070358",
  "size": 18987
}

added `/files/modules~1variance-analysis~1vendor~1modules~1vera_assurance~1jurisdiction.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9bbf63c917cad41f2d2f516c7400b092d1a5a020e8e6e83831fbacc31968ebf1",
  "size": 7887
}

added `/files/modules~1variance-analysis~1vendor~1modules~1vera_assurance~1money.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "a2064acd368ae921fc37156e88711ed9afef4c7b8de7a374be552fa644a52431",
  "size": 10967
}

added `/files/modules~1variance-analysis~1vendor~1modules~1vera_assurance~1recovery.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fbc5402144b405057deb92005580923f7b2ab67cfd439fe2af977a49f96f1715",
  "size": 21592
}

added `/files/modules~1variance-analysis~1vendor~1modules~1vera_assurance~1relationships.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bfadd997d33e764f414e55d967933a7745ba0a9032df21addf8fed076400a085",
  "size": 15349
}

added `/files/modules~1variance-analysis~1vendor~1modules~1vera_assurance~1review_output_transaction.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "63075c6c3b0eff1d3a6706aa59d0dd1e00c558f9a4b51dcf952e881caccfa348",
  "size": 41618
}

added `/files/modules~1variance-analysis~1vendor~1modules~1vera_assurance~1serialization.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8fdbb590830d8a41b6bb3271ceb0abf9874237d0151028b994b9e5521077141f",
  "size": 11043
}

added `/files/playbook~1clara_kickoff_playbook.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "987e6dceb6f12bd54e2594047b20e5044be424eb0c9a488584bb928b0c221e35",
  "size": 2762
}

changed `/files/plugin.json/sha256`

BEFORE

"46aeea11e52a8fd91dcc9f474097815971444a7717fc19f29ba554e36ff8c5ed"

AFTER

"13eca6d1811f0cab1d497ecced113e1fa802e0dea5f45fab1d71b20092ef98b7"

changed `/files/plugin.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1advisory-brief-planner.json/sha256`

BEFORE

"6fd0b85d87f26a9ccfc6255c1404751a1aab47f5b39d642107e855fc804fad56"

AFTER

"5906939c39543e1a1646fe169ab2dcac0e0461fa55b66bc7f22a2f3f5a4408b4"

changed `/files/privacy~1contracts~1advisory-brief-planner.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1advisory-case-director.json/sha256`

BEFORE

"2a3ce89b7aa6514789c836549e4fcd09b48dcf52544f79aa0998d699a0f1eeaa"

AFTER

"439c7ef3ab57a27c680d5cf881cab7970dfb9444c771b2f41b4aba96fce4f0f2"

changed `/files/privacy~1contracts~1advisory-case-director.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1advisory-deliverable-validator.json/sha256`

BEFORE

"7c394ff4df41c1f76fb1e534241f465ae00694176ad24d1bac7e782da49bfc00"

AFTER

"f665b67af25db71ed5a1cdfcaf37309ea8583159ff92c7d2ed5c295798c7f3e0"

changed `/files/privacy~1contracts~1advisory-deliverable-validator.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1attribute-reporting.json/sha256`

BEFORE

"c5d2ee9a3439b39f298e39503de7d086935b5cf8a8d5f68654124875ec5084a6"

AFTER

"259c2e4cea1d8593e8dfc6c0f801557eeb6583c1766912a6c65e815d78306d4c"

changed `/files/privacy~1contracts~1attribute-reporting.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1brand-fit.json/sha256`

BEFORE

"36b7915c8537b98cbb7408ad685dd9d09c0cbeb1af88d21ca7096acd42183462"

AFTER

"a320c5266e0a8aa397c94a2b77611374af2118c1493497dbdd9948166c4fabec"

changed `/files/privacy~1contracts~1brand-fit.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1business-planning.json/sha256`

BEFORE

"3e61805cfe5ffc8cd7cfaa5aac49180aa60fba9c7326db80d5d3ffdb03c2e88f"

AFTER

"08b1fdd999763f0415df7e357a11c3118d1231a51ae6bcf9031828e6b22944a5"

changed `/files/privacy~1contracts~1business-planning.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1claim-basis-map.json/sha256`

BEFORE

"e740b427522800bf2cccef3bcc2b6c911171ac1e50142bd65ba38b9b05303dd5"

AFTER

"cc4227b7afaba8feb8f78c870360256a908421bd847551056b28e569c3670491"

changed `/files/privacy~1contracts~1claim-basis-map.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1clara.json/sha256`

BEFORE

"e4ee7c34eb184b2b0e9da2d2c128a206b5817f2220e1eda8fd434480ad6ed939"

AFTER

"9afdd0928b125e9e38142dbfb36f475cb50393e9e68e138dfc62eff9bafed19a"

changed `/files/privacy~1contracts~1clara.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1deck-correction.json/sha256`

BEFORE

"46347b60237ff52a2de66fece6d2b1ff6a3ce4ee3d34b5a8781363a41f972aa6"

AFTER

"21503c7db8b62f19009ff7462e6986fb8d8237a21afdf1810e5f12db4626519d"

changed `/files/privacy~1contracts~1deck-correction.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1distribution-analysis.json/sha256`

BEFORE

"0cf87158b10a849963ff9449f9602b0d473ce05487d017e243b2fdac856540b1"

AFTER

"75629455d771915a733ca9c6cdb265886bdae62c014e5f695e14f052f7a7be39"

changed `/files/privacy~1contracts~1distribution-analysis.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1funnel-analysis.json/sha256`

BEFORE

"758ee99c4b3c5b6aab80584a6145b976263eb305fe80b769605e425e73bb447b"

AFTER

"5f2af8ab5d904bb9836df51c8a8b3f61af0a2bd11bd1f9890a6f00d90d9ec32e"

changed `/files/privacy~1contracts~1funnel-analysis.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1hosted-interview.json/sha256`

BEFORE

"ff59ad1740c5c85a4b147985641931c64ae2e9ca1b7baf94ececb59a5480ad79"

AFTER

"bd98ffed75943ddcf8c7ec49c41592d3c44eba9b62c8df697e3de03571dee737"

changed `/files/privacy~1contracts~1hosted-interview.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1html-deck.json/sha256`

BEFORE

"68edca8ed8e9576256e434e839d440d981ecb927a2e74aafcc2bbb7141a363ad"

AFTER

"8a12624e01a24f88bf30479fae9d7d62702145c5b3d935985af77740baee8c3d"

changed `/files/privacy~1contracts~1html-deck.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1index.json/sha256`

BEFORE

"3d582693f9c5d0a16c30bbbb59886d4b98080e666d50593ca3cba3eea9e07d4e"

AFTER

"ee4dc7570c4df97dadcf9b7cfb04e2486b2c5bb61446af0d8072303f18bfe13f"

changed `/files/privacy~1contracts~1index.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1learn-with-clara.json/sha256`

BEFORE

"2d253f3369b37b6024d6225e8131b2c1630dc81a9087ce62f6571d9fafaa94c6"

AFTER

"0b18b317dc2b136cea1ef9493ed2782db2b76004337000ede4e1d2f30dc4fd79"

changed `/files/privacy~1contracts~1learn-with-clara.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1management-control-pack.json/sha256`

BEFORE

"1beaddcc8eaf43e2e19b5999863e76e2ccb848d3eee26eb34f299ca2526dd7e7"

AFTER

"4e1a34849e4e50b88147dbbbd5531ef792655d47d370cd13cfec6c907193e315"

changed `/files/privacy~1contracts~1management-control-pack.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1mix-contribution-analysis.json/sha256`

BEFORE

"bae1e7ce5c2202ad4645ca649f2b48486efb53b83a1454525397e45917e16a2c"

AFTER

"10b9446b5f34a5f32e9a7b8a7c277b6c89fca762a51f0fa9357f5cd34dd9d7f9"

changed `/files/privacy~1contracts~1mix-contribution-analysis.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1period-comparison.json/sha256`

BEFORE

"83a603c609cf11e5105f3344d7197ebd039c86da37054a2fb9f5f9205152bba2"

AFTER

"09a26375d2928f7440f670569ba34c0375eefcfc4bd3408f355c64c5088d5063"

changed `/files/privacy~1contracts~1period-comparison.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1reporting-engine.json/sha256`

BEFORE

"1ff9b99ba46910aafcc333fea23b3a3f292033fd138a73288c9404f6d69cd1d0"

AFTER

"8e41a09c8147055365c46203e5f9dbe81c42f1233d6578f163867239dc622478"

changed `/files/privacy~1contracts~1reporting-engine.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1research-video.json/sha256`

BEFORE

"6a0655ae3e67229d163b998304fcdb8846ebed4010a5fdce74852f2b7fd1fef6"

AFTER

"3bfc6191d857dbde50b1ec8641a4edb62e3c77edd50704de4f757581379bb9af"

changed `/files/privacy~1contracts~1research-video.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1scatter-bubble-analysis.json/sha256`

BEFORE

"18b0cc3fc71d1ef3a01c4aa9dad423a171fef0b5d5b278072c110ac9f20b6917"

AFTER

"22858dacc84321f99948f9758d8cb37fbfb8a9c615eaedae8461c25e6966a2b7"

changed `/files/privacy~1contracts~1scatter-bubble-analysis.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1set-overlap-analysis.json/sha256`

BEFORE

"81c9dca40620898d85eff5ff9f126ab46b187cf2d400abe6a2a33d6834883988"

AFTER

"d11fedbf164e2b8172eb1164412d4ca12c8ce050f9516408094f3f053412d4b5"

changed `/files/privacy~1contracts~1set-overlap-analysis.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1statement-analysis.json/sha256`

BEFORE

"737989e5f3fab0fc32161fc33e54575c1d7e4b13fbf115a93b54b593d29ac868"

AFTER

"c053ecce309b652cabc65ac133a5a2c47aed0df7fc868f7a038e902764bfcfab"

changed `/files/privacy~1contracts~1statement-analysis.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1transcribe.json/sha256`

BEFORE

"8b3dae7f7d7e3e0311eda833f820863718c1bc86fb262ddc62b46268cbf3517c"

AFTER

"c8ccea4f8ccfc19d925a8143ec52dfcbdda2805d6ee99ef3de0aea199980d46c"

changed `/files/privacy~1contracts~1transcribe.json/size`

BEFORE

AFTER

changed `/files/privacy~1contracts~1variance-analysis.json/sha256`

BEFORE

"91f6a6e79ba9033dc6ea61eb747d7e16bfface2cea912e978efe1e416ed961ea"

AFTER

"351cada0777e08d81b05a7197c57ff05d4ac55b80e657557fb242799798bd8c8"

changed `/files/privacy~1contracts~1variance-analysis.json/size`

BEFORE

AFTER

changed `/files/privacy~1package-projection.json/sha256`

BEFORE

"de141c15d929daa91806c2c4fad4a4a13f681972c47d682921ab30d135e78e71"

AFTER

"cec62a5bbced3ba3b56e2c1b391d246c144a55d1bfc14d97db1e21c747235f33"

changed `/files/privacy~1package-projection.json/size`

BEFORE

AFTER

changed `/files/privacy~1registry.json/sha256`

BEFORE

"ce8ca3e0e67950c4f0330cb38163f1bf32851eb06502d6f19067e38ba97a1314"

AFTER

"55f4f1c3c617b460f3eceb71830fd39636eb8e6f940a28354b111318c51fb026"

changed `/files/privacy~1registry.json/size`

BEFORE

AFTER

changed `/files/privacy~1registry.schema.json/sha256`

BEFORE

"765510af64f89a8bc166e8ae1fa2cc09cce3d52ab7113d309c0298141e69e2d7"

AFTER

"a0d4340647fee6b711089dbcad0c03592902aff38ee58b125c0ee3e876749dd0"

changed `/files/privacy~1registry.schema.json/size`

BEFORE

AFTER

added `/files/privacy~1repository-source-reviews~1hosted-interviews.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "d6440df779a23d7df7ca038619ff5ed0fb1522a162e94c76a4c1b9607bbf0402",
  "size": 29824
}

added `/files/privacy~1repository-source-reviews~1hosted-voice.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "1cb2576cdefc9ebc3119c870215d7f07d7849866abbcf3685b45da0452788aa0",
  "size": 19087
}

changed `/files/privacy~1repository-source-reviews~1managed-python-runtime.json/sha256`

BEFORE

"c2d87040682ebe7b37a5a3b98bd0363519ca278b346e6e31bf1042653c364ab3"

AFTER

"9c947c39c952abcd924c6f7b3ff2e15abca75eefe148aa940b2e49a6c89b05a9"

changed `/files/privacy~1repository-source-reviews~1managed-python-runtime.json/size`

BEFORE

AFTER

added `/files/privacy~1repository-source-reviews~1on-demand-mcp.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "542c3ee622512a06cfeb47121c854e02816b1e11d74f0800067e4efc82452a1e",
  "size": 5385
}

changed `/files/privacy~1repository-source-reviews~1operational-incidents.json/sha256`

BEFORE

"2d05649cc1b40f6fdb5cafbfbb8d6c737d16d98f01fb92d64dbb9ab1b1be5af2"

AFTER

"dc42e4cc12fb6a6022d75ee9b93263531a408586c922898a340d4192a65ce623"

changed `/files/privacy~1repository-source-reviews~1operational-incidents.json/size`

BEFORE

AFTER

added `/files/privacy~1repository-source-reviews~1plugin-feedback.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "744e6d9cec3944dc6b0677f30f6c6bb845371e33b0b08ab62d154f75c32b7a26",
  "size": 23556
}

added `/files/privacy~1repository-source-reviews~1plugin-update-check.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "9c51c5c22458ab29124bfd58d5f272308ae3ffa908298798104d4c2be170354c",
  "size": 5466
}

added `/files/privacy~1repository-source-reviews~1prepared-course-files.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "ccb43f5786936a5f5e30aa001120576d0f3af84c9395e376e0392d18fa7d6f3e",
  "size": 9419
}

added `/files/privacy~1repository-source-reviews~1research-video-voice.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "179ab6b1e342d661641e156224f8984a1689002c382315aede9a9edb0288b0ba",
  "size": 13438
}

added `/files/privacy~1repository-source-reviews~1retail-data.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "7393d0b3e272be5482fd7799c72b0986878fc252b1cc8d18ad891e4aa8951eea",
  "size": 13965
}

changed `/files/privacy~1repository-source-reviews~1run-receipt-stamping.json/sha256`

BEFORE

"e3c31e2e9b6fe20dcfe3572525f911a4af00bf953efde083079a97e66c54a0e1"

AFTER

"05cf3fd1b1712f14f9c3adda265390697801de1657ec984f08165421e68aafcd"

changed `/files/privacy~1repository-source-reviews~1workflow-usage.json/sha256`

BEFORE

"87be0d7017b844c8eac48e013ce52eec16809bc185ee2293c22c8e1bd191f090"

AFTER

"d48b2dd318114ddddf2611b23029448a131c1fb5b24b9e99c6ee43b9be38bf32"

changed `/files/privacy~1repository-source-reviews~1workflow-usage.json/size`

BEFORE

AFTER

added `/files/privacy~1repository-source-reviews~1workstream-business-planning.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "074fcb1413eb4398f16a33ca8615a370dfc59944a8f433177c714fbd7ba5fb8b",
  "size": 32697
}

added `/files/privacy~1repository-source-reviews~1workstream-learn-with-clara.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "a10e25f0b86e60592a5358d71b083ccb8f313b67727fb554dd06e75989547a28",
  "size": 793295
}

added `/files/privacy~1repository-source-reviews~1workstream-management-control-pack.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "b5bc703a7d93c3760f301e7954a7a640f15ebbcea28f095eb98968b9d0a54394",
  "size": 5933
}

added `/files/privacy~1repository-source-reviews~1workstream-reporting-engine.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "dcc77aec98eef8b64f1667310890d9889a62a250b6566407cc06fca194c83276",
  "size": 26182
}

added `/files/privacy~1repository-source-reviews~1workstream-variance-analysis.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "b0f653c06e0714a9136a077be215cd3e5d2e991c35b4b1aa9132cbf6bb874e1b",
  "size": 4190
}

added `/files/privacy~1services~1hosted-interviews.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "f8f726a2c75bc699ce94da6a41428d39355f32d40e255170aaaec47b7b553939",
  "size": 27831
}

added `/files/privacy~1services~1hosted-voice.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "b33da5505e007eb592e5a8817b4d73abf8f1a8fc520d695b0a74de4f7de1c497",
  "size": 17736
}

changed `/files/privacy~1services~1managed-python-runtime.json/sha256`

BEFORE

"c3e8f2871ad96b0d70d6d86d88e6cc1f02985e0f617fc37e248e05debb245ef0"

AFTER

"1dd9fd25e9635750cf331cc9bbf86e1e111e5f8b93513926b2625104be0e326b"

changed `/files/privacy~1services~1managed-python-runtime.json/size`

BEFORE

AFTER

added `/files/privacy~1services~1on-demand-mcp.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "47cdfc47cc4d50114e4011acbf35b372adc6e7ff71a9535a0b667b6727cbade1",
  "size": 4025
}

changed `/files/privacy~1services~1operational-incidents.json/sha256`

BEFORE

"4886862c00e099372e69b510875838b24b31f7215527c739d050e72b6207b883"

AFTER

"2811af819a0f9568ad77acf89dac2fbf6e8446bdcd20f03aa91ba5ece06cba90"

changed `/files/privacy~1services~1operational-incidents.json/size`

BEFORE

AFTER

added `/files/privacy~1services~1plugin-feedback.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "3b9e7de864a86331a1ab5298b9a97252cd63b0e01e44adacc127040094a145bf",
  "size": 22380
}

added `/files/privacy~1services~1plugin-update-check.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "ee557d7d6144ae6402802ea51b49a49fc4ce35b9f3f08e78927c735de08cbbcc",
  "size": 5084
}

added `/files/privacy~1services~1prepared-course-files.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "fb201c4fa8d6c1b3cd3f270edd251ba5a1df3296e157826a022ddafac7da1ed2",
  "size": 4221
}

added `/files/privacy~1services~1research-video-voice.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "859cc924fc925f0d9c5f22f1b024bf7995ee6add822ce1fa6135036d726600fa",
  "size": 12274
}

added `/files/privacy~1services~1retail-data.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "27658f7ce7a3ae1c2b7186fb521fa94d69f8533ce9d5c0ef5c49f9c424603f7c",
  "size": 13249
}

changed `/files/privacy~1services~1run-receipt-stamping.json/sha256`

BEFORE

"e80c5598a639717f239740b0dab5905bc157e7da05fec069e5fc28dc41908adf"

AFTER

"ff49140bf33e630689173e448218839bdc24dcce08d7541bdf033aa296cbe88c"

changed `/files/privacy~1services~1run-receipt-stamping.json/size`

BEFORE

AFTER

changed `/files/privacy~1services~1workflow-usage.json/sha256`

BEFORE

"6f51ede15af0a029ea536b527b823d6336148bffe5c082ba6a0ffa3c0291faa2"

AFTER

"17c5c397811ad2079d293d2045b496e2a51516656954f46868103c9fc9e3cb2d"

changed `/files/privacy~1services~1workflow-usage.json/size`

BEFORE

AFTER

changed `/files/privacy~1workstreams~1advisory-brief-planner.json/sha256`

BEFORE

"137c57d37219490bcd5f289ee2a42b8b1a6f7bda6879b7bce7ca7e7ddcbf578e"

AFTER

"e94cfd9bbc51e533a4fc6e4ee50e7c6829070729b3f2ec7e8d376a38a352eaf8"

added `/files/privacy~1workstreams~1advisory-case-director.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "6503cf005b7a29bc1dd614820846950eed46ed8c355257e384ccf2700e66a370",
  "size": 10918
}

added `/files/privacy~1workstreams~1advisory-deliverable-validator.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "eab4553985d39bdb923f93e99af087dbcd1452ac8bac72436200bf3b76f873f1",
  "size": 25167
}

added `/files/privacy~1workstreams~1attribute-reporting.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "f32a21609d337a07404fd3125bc87fb3e3d843985f163791a24c1f06561562ff",
  "size": 9084
}

added `/files/privacy~1workstreams~1brand-fit.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "57b8cb4a03f6f45401223222671a4aa6ae3ba191e5ca1431deb13bc5bbcac877",
  "size": 9110
}

added `/files/privacy~1workstreams~1business-planning.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "57aa13877b30b0ef5e9763ed2c57dd45ee39facb86896e92528a157fb61df87a",
  "size": 27840
}

changed `/files/privacy~1workstreams~1claim-basis-map.json/sha256`

BEFORE

"9fef131cae3a4aab67145ea8071783fd5ce33552395972e3c5a2ba2344284729"

AFTER

"665282273c248358fc4e584ea6866aa27c4c89fa4dd78f92d58520f8008bf82a"

changed `/files/privacy~1workstreams~1clara.json/sha256`

BEFORE

"92b13e35e3dda43010f4f7c5b112c5c6044c82f27750138c855ed175b2bb2e58"

AFTER

"e0aadad8aa8daa9aa1da4b6431a766132c190d69e70611083d5d7a743a1a8a0b"

changed `/files/privacy~1workstreams~1clara.json/size`

BEFORE

AFTER

added `/files/privacy~1workstreams~1deck-correction.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "a4b33b648dea20ae8e6e731481765923a426985ad61b7b05709e4c53d1e11b92",
  "size": 11565
}

added `/files/privacy~1workstreams~1distribution-analysis.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "1fc80b9bcbfc73429c553574f64224915366722e0952c7a4631794993ff84b06",
  "size": 1569
}

added `/files/privacy~1workstreams~1funnel-analysis.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "3baaab07aa60db95f921acc8d8d8c0a782e0956b8269eaacee395155cb02ee9d",
  "size": 1523
}

added `/files/privacy~1workstreams~1hosted-interview.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "5c70b2f9dd6477d75420ab01f70c11f6ee56d87b9bffff03dbf782b057f002c9",
  "size": 7597
}

changed `/files/privacy~1workstreams~1html-deck.json/sha256`

BEFORE

"78e3340d306bb2f7c01500a5ab67c08bf59254865717fc2cfc05882dec8a2c7b"

AFTER

"93e6c5b7f1db749331486469cdb1c5cb38771678e6ba7e5ef44cf7bc9bf91e98"

changed `/files/privacy~1workstreams~1html-deck.json/size`

BEFORE

AFTER

added `/files/privacy~1workstreams~1learn-with-clara.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "820e10e0a25567e44c8397fcef533d14f0923f600d8fee36a3934d94db51b6e5",
  "size": 13790
}

added `/files/privacy~1workstreams~1management-control-pack.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "a035c32b8983c7fdbfcb417f03d124b7443008e305e02a2ea788ee13e245f8d9",
  "size": 5600
}

added `/files/privacy~1workstreams~1mix-contribution-analysis.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "54f32d676f053f2895a62ba0bb68e2eb764d7fea39949d75fe50bcdb2321bb12",
  "size": 1611
}

added `/files/privacy~1workstreams~1period-comparison.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "8facae9f53032ced8053e9b4833c80ea8866a8330037eef18d6f36c7655272ee",
  "size": 1584
}

added `/files/privacy~1workstreams~1reporting-engine.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "df3bc2a9e9481af04fa0748a48661bc91ce1fd7abd1957aa30c08881005263ff",
  "size": 21599
}

added `/files/privacy~1workstreams~1research-video.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "8112c779a3c15a6617b4f7b65c4e82205aa458f3b1c6d63f36952333691f4240",
  "size": 15090
}

added `/files/privacy~1workstreams~1scatter-bubble-analysis.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "d0ae24f3ba15cdeecb65dd3c318e51505189170134dedaed048b1d0cd55d73fc",
  "size": 1554
}

added `/files/privacy~1workstreams~1set-overlap-analysis.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "7adc0f7077f168ad757bda925391b1738aa51a01179573addfdb14d9d9aeb313",
  "size": 1548
}

added `/files/privacy~1workstreams~1statement-analysis.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "46b644794f14b35e8a57cdaed0a701271a616ded6e851703f521a4955831855c",
  "size": 1569
}

added `/files/privacy~1workstreams~1transcribe.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "e9b497493a6c1cce998a3710626a009afce3a3587df29e030b4b517162124385",
  "size": 12661
}

added `/files/privacy~1workstreams~1variance-analysis.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "91f3f7bc28f2cb79262ff6e70b0a4ae2fd4e8d5bbc294c4d6009f004dc07f03b",
  "size": 3887
}

changed `/files/requirements.txt/sha256`

BEFORE

"74695e405c799280931c0b377914e766b7882f8eaf2abf468dcd43890f935c15"

AFTER

"b149c32297d506492d255ad4b2548bd7f75891b9f56514a52cfa15e7f33d6aea"

changed `/files/requirements.txt/size`

BEFORE

AFTER

added `/files/scripts~1_desktop_teaching.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b4972f05a13c05552dcac0b549e3ac574e5e886ae5cac8a93860e0a23f6d1d46",
  "size": 519
}

changed `/files/scripts~1_managed_python_runtime.py/sha256`

BEFORE

"b7304f07cd296708a5dda686212c7a9deccdac1dccd9814fd85fb6fdb99eeef4"

AFTER

"944934937a005693a026a1509054e21fd8c3cbb7883b55d767c879dae61ecb7d"

changed `/files/scripts~1_managed_python_runtime.py/size`

BEFORE

AFTER

added `/files/scripts~1add_case_file.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5e72eabba1643e5a2b463ede06a9fbf0c7ac77f8ac37938ab8d5a4686154fed4",
  "size": 3694
}

added `/files/scripts~1add_judgement.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "719f0d765b4566bbaf24caad3c54cfcdbdbd9d446d3b2d00bbb08e129c6ca554",
  "size": 3077
}

added `/files/scripts~1add_open_questions.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8234d7bed80a83ba696b10dc62efce126913f421ce8d811969443d6a09ee8283",
  "size": 3708
}

added `/files/scripts~1advisor_case_core.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1102874a9103ce3aa8efb16679b363fe5b25b2df53c92f0091d1815a4e942108",
  "size": 310029
}

added `/files/scripts~1advisory_delivery.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "877d87df4bc1d5b2322e3b96bfc86fd86d6fdb1a7a288ca84f439e104d2c71e8",
  "size": 17052
}

added `/files/scripts~1analyze_deck_revision_materials.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d619d0235be9ffe41e0aa70b583fd7fc071b281b0ccac28c63ccff7a4db9ad75",
  "size": 18716
}

added `/files/scripts~1apply_deck_revision_plan.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "68f48e221fbaecb76851755160c224aea7bc529e75251cb3775a8c079c79fb3d",
  "size": 35671
}

added `/files/scripts~1apply_inclusion_bundles.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "743454d3bd3a6114c7b008bff58ff0e2cfdb0c08df7139e982253340a891efc2",
  "size": 2532
}

added `/files/scripts~1approve_deck_revision_plan.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "066673b928fbbf8a276be2e1d4656d6b783c1ea1df2ce9f647c95b9eafee778e",
  "size": 10548
}

added `/files/scripts~1approve_judgement.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "33bda5ae173803eefc0b12abee0ebe3b916e15b142b467794ed263cf99de39d9",
  "size": 1275
}

added `/files/scripts~1approve_judgements.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "31c259c97fdf447b213a95d34cf2899dc349347e2f96f3af895c7165a4d628ea",
  "size": 10935
}

changed `/files/scripts~1archive_report_measurements.py/sha256`

BEFORE

"d33c8f071a63ef9de0712099454fb4f879f97c25680704f51b95569c2d04a459"

AFTER

"dc6776113459131fbf756dbd8882e622c9441e80200ece7f64f24b259eb94118"

changed `/files/scripts~1archive_report_measurements.py/size`

BEFORE

AFTER

changed `/files/scripts~1archive_report_receipt.py/sha256`

BEFORE

"d4b7cdad03bf1745632cd96087bbf352b89633d442d9ba32f606a85f1cd5662c"

AFTER

"04758e412e1dabdbd63f0b8de8f6018077a00c642a235ac869351df24039796d"

changed `/files/scripts~1archive_report_receipt.py/size`

BEFORE

AFTER

changed `/files/scripts~1archive_report_store.py/sha256`

BEFORE

"71b343484ce0dad7b426449c0d3038cb324dbd8ea3d45b44658e9e7e51fcdff5"

AFTER

"916017ea711652bf12d885725b50a8cc168a2624e7f5ad4cee12297f73822186"

changed `/files/scripts~1archive_report_store.py/size`

BEFORE

AFTER

changed `/files/scripts~1archive_reporting.py/sha256`

BEFORE

"8685fcef4d35e040746b5662354b33e6b14f3b3d4b768a50753500cb7301de25"

AFTER

"67013369177f82f56645f5529fb604cc6ee044def8bceef12a36db94e3607b6a"

changed `/files/scripts~1archive_reporting.py/size`

BEFORE

AFTER

changed `/files/scripts~1archive_reporting_failure.py/sha256`

BEFORE

"3705b3118295be6c25f125560baf1db7312c4c83e5d41cdff6f3cb661c893f5f"

AFTER

"3a618de9edb0678412ba6d5d47ddef5ccfdcb9f022cf81055647e242d94fff24"

changed `/files/scripts~1archive_reporting_failure.py/size`

BEFORE

AFTER

added `/files/scripts~1auto_attribute_hosted_transcript.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1bd1a85dd8f64e7be9f698bcf3f9df290e4c9135482c090a936a105276fa3566",
  "size": 20618
}

added `/files/scripts~1build_case_brief.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "517da956e087df1121002971c31dd3acc2c6f3be986be5fceeb96398d7e9a1fa",
  "size": 1757
}

added `/files/scripts~1build_clara_kickoff_deck.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f7bdf18c0f2c8cd1a2db9f7d873398dde26ad5241e93729b2902824f4c04c972",
  "size": 1803
}

added `/files/scripts~1build_clara_partner_brief.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b1d88d99947187f8e29089666d0978be2b8b1e409ff7b834e9f46fed6cea877c",
  "size": 1806
}

added `/files/scripts~1build_decision_pack.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "290816d360f8d17654f6ba93e91c6020fb29d537fbdcab2cc04317feed733786",
  "size": 1893
}

added `/files/scripts~1build_deck_revision_execution_packets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "aa888eb6776800297fc90a9f617a306732fc281413823f0ca7a24f295dca3067",
  "size": 21940
}

added `/files/scripts~1build_deck_revision_execution_plan.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fcc3707a7d7eeab55ef4e754f657c2f2120c1497657907b4f5dc7bfc7a9f4033",
  "size": 14021
}

added `/files/scripts~1build_deck_revision_interpretation_packets.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "61fed12e4f43e821eb69cc3b2a1354d5752ac5ed133ded11a9d55209124bd3ed",
  "size": 17822
}

added `/files/scripts~1build_deck_revision_quote_candidate_matrix.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e8855ad6f298f414c4c0d59aaf4f16860dbf704745a08fc09ee80f658243f6cf",
  "size": 17389
}

added `/files/scripts~1build_deck_revision_workbench.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9ae9564d4f913d67af7deb27ca289e127ea7fd8858300948930b37df1c2c1c0e",
  "size": 36308
}

added `/files/scripts~1build_inclusion_review.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6bcc76433ce9602746bf1b50de202668335c55cda87db6b6c8d82f8e0864501a",
  "size": 2099
}

added `/files/scripts~1build_public_truth_audit_envelope.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "cb497451e6d5502c7027760a720d224fe872008efe38e8e51eb0513c344565f4",
  "size": 21431
}

added `/files/scripts~1build_real_data_pilot_error_summary.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2e09c688910f46a82db9881e2789a5c33eea25d2101d64917721aa010cebf750",
  "size": 33534
}

added `/files/scripts~1build_real_general_ledger_audit_envelope.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8822298cb91005b58c88e71eeeb929baef379491f93c0a12ccc9da327a831d1e",
  "size": 46338
}

added `/files/scripts~1build_voice_feedback_timeline.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9421c1e2cefe599a25a15490e1b792005220d69019b9cab327cf2c66e9a0619b",
  "size": 27183
}

added `/files/scripts~1capture_advisory_web_evidence.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4fa2abd98b581cc0fac46b77b158baa43dc1fdae03ad51fb24823e246a6eec08",
  "size": 10713
}

added `/files/scripts~1change_requests.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "0e39b7acd69e0c374e50a34d3eb58acf5abe8a243de571e46485dc9d1beed63c",
  "size": 55963
}

added `/files/scripts~1check_change_requests.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7c402fd323145342c40678fbfcc78c1cc0021717a6149dc55a69ecb0a613acd4",
  "size": 848
}

changed `/files/scripts~1check_dependencies.py/sha256`

BEFORE

"787a60f5f99bfc846a420965ad2a9f443af8ec09ef1d818c35bad4c1334c1586"

AFTER

"d104fdd6c54e52f09e42f63fdbb6254a901cea1a79ef5f4ae65c467c990e514d"

changed `/files/scripts~1check_dependencies.py/size`

BEFORE

AFTER

added `/files/scripts~1check_for_update.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "76ba154b77b43e280f550bd26c9ff194dedd29320978ce4f71306ec812f1590f",
  "size": 9285
}

added `/files/scripts~1commit_advisory_workpaper.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1a3f0ea7271385efc38cd7d4ae7ceeb814766b73045c3ba851194c6ea2cf24c4",
  "size": 2107
}

added `/files/scripts~1commit_decision_narrative.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "12a4e046d0f9af44d6d3ca21bb1088e3c8f1868f509898a836877ca0d3a60470",
  "size": 1860
}

added `/files/scripts~1complete_deck_revision_output_review.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "55efcc9bacf86e432aaa136c257355430c6a61424022f2ad70d7d32324a3fc3f",
  "size": 15731
}

added `/files/scripts~1course_chat_bridge.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "dc16232b7f072a81de4c2aa1659706da90166e548e43a48ff5d1962001601ada",
  "size": 1237
}

added `/files/scripts~1course_chat_mcp.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "47f287062575db4e69e7cb40f876ada88937d84ec91ebb5d6dcff5bc34cc2d8a",
  "size": 348
}

added `/files/scripts~1decision_narrative.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d596dcb192db69e8ca32e511f99aba371328260ddd916e77c7b7d250b781daf2",
  "size": 3330
}

added `/files/scripts~1deck_revision_execution_contract.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5088e508561027979ed3fce8c758cdbcf1277a0d1ffdd4fb45c6c4eb3035fe3a",
  "size": 2158
}

added `/files/scripts~1deck_revision_text_match.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ca3c2f11197f17727f5bb98d37482fa5bf204ae3b44fb08cacbbb9facc15263a",
  "size": 1107
}

added `/files/scripts~1delete_material.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "40cca4a2c067ee7e928131771e74ddc411c694677445547c7526288bea3d0c80",
  "size": 3350
}

added `/files/scripts~1export_case_update.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "34497af0cfbca51d8b561c209594fcb951117a226b77e10368ab12fb33368f11",
  "size": 2182
}

added `/files/scripts~1export_case_workspace.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9bee0920b913bcd150529130604319af5bb145c4457b51fb0a6ca848281ce46b",
  "size": 2208
}

added `/files/scripts~1finalize_deck_revision_plan.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d20c0aa909a3423ab635fd2a75ecdf5ec68fcecc559c730a1ef5b5a3b8fb27e8",
  "size": 41003
}

added `/files/scripts~1finalize_hosted_transcript.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3aa94262c8139745e394c2bf8234292028a085f20220df76dd61558f3eeca0fe",
  "size": 21522
}

added `/files/scripts~1import_case_update.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ecaf008f915081e8932487194f7c3774f5ccb8461627fadac91a9b9bc7f8397d",
  "size": 2245
}

added `/files/scripts~1import_hosted_voice_bundle.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ed283224bad95bfb500205b7d8590df8a91eee1a4f06195bddd58d66d789af42",
  "size": 57594
}

added `/files/scripts~1import_hosted_voice_bundle_to_folder.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "48b11f2718f0c9aab778710dbc71d4c723d81fd3c5bcde0fae75810da4e07279",
  "size": 45506
}

added `/files/scripts~1import_latest_hosted_voice_bundle.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8e2522669da7c108e28853bc724ae69d523523e6c8b3112c42036cfa0fd3c5d2",
  "size": 5825
}

added `/files/scripts~1incident_host_mcp.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "f4e3913af0c1a7d4f3a5fd2b25ffcc43e7b39e33529e72f8264d7b0b89f86128",
  "size": 14125
}

added `/files/scripts~1incident_tool_schemas.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "b03e28ab99d71867fa61d1fb2f68f9ec64ea908e0703ba6744fda2147b4b093b",
  "size": 26789
}

added `/files/scripts~1index_materials.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9b9d4fb259500abeb26afe0c48ad48f4abc65857736a2fb01c4559b31dcee9e",
  "size": 3140
}

added `/files/scripts~1ingest_notes.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "3cc11da20071c12cc7e9595386d874b1f103f735ac336d50618df2d083f70bf9",
  "size": 2066
}

added `/files/scripts~1init_case.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "cf7ca3c6e63e240a15f6c11aa87b3354a4efdc0eca724269990233b89e924edf",
  "size": 2133
}

added `/files/scripts~1integrate_transcript_review.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d6873e69bcaa63db45217236dba6b45ebb260459c4bcd644e237ae0581c5a993",
  "size": 20617
}

added `/files/scripts~1launch_hosted_voice.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bf73a10f86a388df87737528b9debce56b453a5d1cfa9d70665b85ed688b74b6",
  "size": 13554
}

added `/files/scripts~1local_courses.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b49e56924b9206a393ec4b9a1294ef84183f3e117971a6375e174ed45f6a11d8",
  "size": 920
}

added `/files/scripts~1local_onboarding.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c818e87fd7ad5370b125dbd9858137eb58abaebcd195904f8812bb8ad8c3eedd",
  "size": 595
}

added `/files/scripts~1local_onboarding_case.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "829faa6e911e9ccbdc475e018af48420c65143a86917f037c483725afb6469bf",
  "size": 360
}

added `/files/scripts~1local_teaching.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "fb8966e64495411a3b5204513752d443456f1b99aef500edcc1ad53f6a67befe",
  "size": 637
}

added `/files/scripts~1manage_hosted_interview.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "704bc2c8ede2ec5fd78e35967f72acce18eac2ddf27bd52bcb3df8b6930c9f5b",
  "size": 22914
}

added `/files/scripts~1match_feedback_frames_to_deck_slides.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "05bcb9f30b23e97b0b54907296943c72120040c2d95de422b5ac3b0440b96fda",
  "size": 33671
}

added `/files/scripts~1mcp_service_client.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "d26d891c0448ece8f2eba6a4cd18c9b14c7fac81b550fd33734bd9b1a7e311a8",
  "size": 4196
}

added `/files/scripts~1normalize_legacy_pptx.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e18103f3fce1a90279eb778aca0e59714575b692c533a730962577ab4c618041",
  "size": 3050
}

changed `/files/scripts~1notarized_run_receipt.py/sha256`

BEFORE

"7b32e58c31df7fdbe875407f370e709a14ec4a2d7456b9f75d0eea91c8ccb89b"

AFTER

"6b8cbc5b08a4c23271de61074f5fe435107c8afe3e648f117baba9f0cdfdab5f"

changed `/files/scripts~1notarized_run_receipt.py/size`

BEFORE

AFTER

added `/files/scripts~1on_demand_mcp.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "b175109752e7611776e5d424aad29ff4d1678a9e077a8993f892dc50431f6b54",
  "size": 6881
}

added `/files/scripts~1onboarding_session_start.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "cb6fe047a7029c4d77b60872555507bc23e07f1279038d7ad772fa577b5364a4",
  "size": 2133
}

changed `/files/scripts~1operational_incidents.py/sha256`

BEFORE

"132798f1fd83c607ee91bcac93364ac8dd9cb360b7f91f6300d8d4e24bb9105e"

AFTER

"686ed0140b970aff8b4314a3e53a13e202b1c80af91a95f949613f33f36342d1"

changed `/files/scripts~1operational_incidents.py/size`

BEFORE

AFTER

added `/files/scripts~1parse_commercial_general_journal.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9ee7b702f494bca21193216afdc889f181a87cff6becd6124d29e2b5c3427b49",
  "size": 105083
}

added `/files/scripts~1prepare_clara_kickoff.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "58836f4f6b5dca49be99f27ea887bfdec4db262bec54999832bc42225b05a4b8",
  "size": 2645
}

added `/files/scripts~1prepare_editable_pptx_merge_input.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b31c7a8b2134bd91bb1a0c2d747566ad640db6a5d8007045a7b4ab2957b7e3ee",
  "size": 2630
}

added `/files/scripts~1prepare_support_package.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8639a077b0c6fe12b49f676dd7dc785c4c450911184b62d42af743244ce1c960",
  "size": 2569
}

added `/files/scripts~1prepare_voice_deck_revision.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8d9a22820537a5e2b6aec0f8fd5c74af2f36a15a24b8905c221ef3909dcd68cc",
  "size": 37808
}

added `/files/scripts~1real_data_pilot_output_boundary.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "341495c7abdec121607d1ad48a0b5c61cd0297c0c2f76aae4d8c46e17d49df6d",
  "size": 17423
}

added `/files/scripts~1record_analysis_contribution.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9134df6c408a78eb8404f13ff3758bda26c2ca98e25d1822700f6f7e8a125db4",
  "size": 2996
}

added `/files/scripts~1record_case_direction_return.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9bc960fe45ba6f8ba0e6a5dc19b35f40342d3bc318873d1a257c4257193c4f42",
  "size": 2067
}

added `/files/scripts~1record_reporting_contribution.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "05f0d8e338742e9b04ba98f9e4af4ca336354aea7c40fc16579f177d2b10d4e2",
  "size": 11949
}

added `/files/scripts~1repair_audio_pointer_links.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bea98821df1d30cd78b4f14587846890f22884e2aee500f7eb0c882efa0a3a74",
  "size": 9904
}

added `/files/scripts~1report_mcp.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "d279a1d47130b5bd8cff393aa9772ff7b2958fdd419c423845a590e347aafd75",
  "size": 1128
}

added `/files/scripts~1report_mcp.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "2f602685fdc76252f309a5e2da3b89d5b57a5480619d88963b3cc63b275a021a",
  "size": 7734
}

added `/files/scripts~1run_clara_deck_benchmark.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "109eee8d30426eb97aab0c6d0228292e3e499b5015b73ecdbf760275044b8e00",
  "size": 89480
}

added `/files/scripts~1run_deck_revision.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "44ffa92de9dd6005677595b00f44915aa001bb8fcbe4590abc950de9a9a6e098",
  "size": 14349
}

added `/files/scripts~1run_deck_revision_fixture.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c11a2bfc7b6fd346cda7ecba756ba04d4ef89482fbf7eb18dd5ed8d9fb5339d0",
  "size": 14213
}

added `/files/scripts~1run_real_general_ledger_pilot.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8ceb25e32a39bdd0d7ff915178924ad37bd4a93038f10d90d9dc356b07b2afba",
  "size": 56631
}

added `/files/scripts~1start_deck_feedback.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "608f63e705eedcb0e3b43af6ff624ab8f05587fd3d4f41ff21168564f61618a8",
  "size": 12596
}

added `/files/scripts~1summarize_html_deck_benchmark.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1e792dabdf0398d79f2b40ebb085e56525d4e5e492eff75020f076db2c434a25",
  "size": 50747
}

added `/files/scripts~1upload_hosted_audio.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "439c6d0c453b51285cdc014fe7e17aec109c27fec345173930e866e4386c25c6",
  "size": 37058
}

added `/files/scripts~1upsert_case_issues.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "7101a636234498038f84ede9385ef9d62f9868105758b1c5efad85d598dd83a0",
  "size": 4549
}

added `/files/scripts~1validate_public_truth_benchmark.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d67083f3335fe459aa9eff6d59b064ef921c2717eeaa8188596e3b3ee5f3ccbe",
  "size": 28036
}

added `/files/scripts~1validate_real_data_pilot_intake.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "74f9277e63917895f673868bd5ee596660375b7df6105915f7922a4278490089",
  "size": 58867
}

added `/files/scripts~1validate_real_data_pilot_mechanical_errors.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5269a54c73d491d4129f83a91f8fdb4f79ddda8dae763248da52182786cd54f9",
  "size": 27318
}

added `/files/scripts~1validate_real_data_pilot_semantic_review.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "5f1e55790b7e25ba5f35fd20ee3d2c4c0924889634c15c485568a6b85c6b8edb",
  "size": 36098
}

added `/files/scripts~1validate_workspace.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "aa123af4008591dc1640521974574d7d18052a6606d7f5ecfad861a0b330c1d6",
  "size": 1673
}

changed `/files/scripts~1verified_execution.py/sha256`

BEFORE

"6d6bc49b6075af24e28f36356959b4263ea00c71cbb0b33ab2a6c4beb0c8e3f6"

AFTER

"3f66afd2e1c7004111bb3137cdf4367b759a7f4534de0c38957be67faec8ef01"

changed `/files/scripts~1verified_execution.py/size`

BEFORE

AFTER

added `/files/scripts~1verify_advisory_delivery.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1db20ac24cadf936821244631b51bf6187258efb269c745d61fc6c6261fe950a",
  "size": 1147
}

added `/files/scripts~1verify_advisory_html_delivery.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "771dec6416bb5bd0eb2453caed09fbd9644c1386dab1c187c1d2b859e377d8ef",
  "size": 2406
}

added `/files/scripts~1verify_decision_pack.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9c32fa783af5d65223d284c7b6c23e551d2c92265a0f4f6efc8c0f31eaa4cf83",
  "size": 1890
}

added `/files/scripts~1verify_deck_revision_output.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "4cbe678ce65a5d3f5a65c23b74450184e1740b9e0b967b5b9b91e6c778f3e436",
  "size": 23897
}

added `/files/scripts~1verify_mcp_package.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "aaec0746f25fad9cf9994a7be54924a8c5e89003220195294faa8318ae58de5d",
  "size": 6233
}

changed `/files/skills~1advisory-brief-planner~1SKILL.md/sha256`

BEFORE

"3723e0de536f285206d12c036e6786acae66f57e681e669fc8c74a3f2990a71d"

AFTER

"226d3feb079e9b0cfd8886f607fd64d21a202d8e13fe5545f81ddf67ae44f4ad"

changed `/files/skills~1advisory-brief-planner~1SKILL.md/size`

BEFORE

AFTER

changed `/files/skills~1advisory-brief-planner~1references~1advisory-contract.md/sha256`

BEFORE

"fda83827937ad6d3fbc52a1a598a8f0d78584740d08e80042b8528a052bd84fe"

AFTER

"7e87617d089443530c384c7713a09e78ef1f64d5c6b04e5d890d89e4e47391a6"

changed `/files/skills~1advisory-brief-planner~1references~1advisory-contract.md/size`

BEFORE

AFTER

added `/files/skills~1advisory-case-director~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "f68aea95d06ef3818bb46449edccfdb5dd0ffe4b369a2c3faae373b98820444a",
  "size": 23251
}

added `/files/skills~1advisory-case-director~1agents~1openai.yaml`

BEFORE

Field was absent

AFTER

{
  "sha256": "ba19c16d32453c8f79e260117c964dba9cc77dae9e148308da37fbd047bddf9d",
  "size": 265
}

added `/files/skills~1advisory-case-director~1evals~1case_direction_cases.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "fde4735ac17d4d8be5a62057ddcb1d325cb56ba048d3107c43161b95901a63a8",
  "size": 6764
}

added `/files/skills~1advisory-case-director~1references~1case-direction-return.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "b7a68ee800a7825298dbe645d49a21f3e41b764ae6feb310968989e70ecad5b3",
  "size": 4486
}

added `/files/skills~1advisory-case-director~1references~1operating-model.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "db2f2f43c3bffbf0f53323bae5b64000a1b04971b519402f62e0c4115a3db395",
  "size": 8984
}

added `/files/skills~1advisory-deliverable-validator~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "a958c0d3d6b4f978f73dc2ef7163b3019f28549e1278e00c30845fa187a5f7ca",
  "size": 31467
}

added `/files/skills~1advisory-deliverable-validator~1agents~1openai.yaml`

BEFORE

Field was absent

AFTER

{
  "sha256": "fe37dbe19ea450dd59f0a529cbc552f368bf74b39619debe8556ff0e64bed944",
  "size": 474
}

added `/files/skills~1advisory-deliverable-validator~1evals~1semantic_validation_cases.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "d769d19538f5aee9817fd9586e75a99ac24991a28d73920aa40dcdc437acec01",
  "size": 12196
}

added `/files/skills~1advisory-deliverable-validator~1references~1advisory-contract.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "c34fc34c7a642dc2e08f02c9fd4bc1038f559ccb14114f8a2127fa4d1e71dd79",
  "size": 5117
}

added `/files/skills~1advisory-deliverable-validator~1references~1advisory_validation_review.schema.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "cd2ec050ebbb26ce41e8af0e7498befb381ddd6939d41edc3738a3b2a11399f5",
  "size": 15156
}

added `/files/skills~1advisory-deliverable-validator~1scripts~1advisory_review_render.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "0aed18e4209aa68d5caedf2cf1b3136a4d6a7caf86dd4fc5bf8a844a2c0e6783",
  "size": 21314
}

added `/files/skills~1advisory-deliverable-validator~1scripts~1advisory_validation.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d32fc7f1c14710aa0346f549b1814ae6b6b18ce3340dbbe3e5eab20ff34ed1e4",
  "size": 110423
}

added `/files/skills~1attribute-reporting~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "0f6552a7f3022ff0ba491e16cc0a503100682062e70c12ff9057170f142567ab",
  "size": 5642
}

added `/files/skills~1attribute-reporting~1agents~1openai.yaml`

BEFORE

Field was absent

AFTER

{
  "sha256": "0f9237f5c3b5771fc3ef509ba770ccffa375a1733cfd6dd042c0f644209832dc",
  "size": 355
}

added `/files/skills~1brand-fit~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "bcc076cf716a808bfd0a056fae6f37413c6065d5689f1183ee628e3e7d7e9b1b",
  "size": 5514
}

added `/files/skills~1brand-fit~1agents~1openai.yaml`

BEFORE

Field was absent

AFTER

{
  "sha256": "af9bd10b208edc4e81b8592cb939ac5065ed937264730fab90fbccd740f3c4a0",
  "size": 359
}

added `/files/skills~1business-planning~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "7d573d9ec382e0b24db35c35d81a64aaaffb71fd4ea53b7eed4daedc27bcab0a",
  "size": 5234
}

changed `/files/skills~1claim-basis-map~1SKILL.md/sha256`

BEFORE

"0ff551141c77500257e1515de9b45d8bce27200803a28215666e2d9e89957de4"

AFTER

"a31d3f3c32856f1c4e5fa49f44284c04ddc5b563554574c7c054b1a8948d9c88"

changed `/files/skills~1claim-basis-map~1SKILL.md/size`

BEFORE

AFTER

changed `/files/skills~1clara~1SKILL.md/sha256`

BEFORE

"b608b009c2e03b339f2b71a5a4e3b961d5feafbb6e02b6a08e8fa6eefedb89f7"

AFTER

"40f850e57f5b05164f3972bbf94991136db3f9af27481aac8cc91d97238a5063"

changed `/files/skills~1clara~1SKILL.md/size`

BEFORE

AFTER

added `/files/skills~1clara~1references~1case-operations.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "4f5d1c225b895a88d62e2cd36cdaee2070e7ad72f7177c473f9f3788aab75bc2",
  "size": 44195
}

added `/files/skills~1clara~1references~1cowork-runtime.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "b4e0d0dca102830bd71bed9a28b6145ae70d2099246daf0db171e22556ed5b97",
  "size": 10085
}

changed `/files/skills~1clara~1references~1incident-recovery.md/sha256`

BEFORE

"fe3015f93837bf53562f2a7b00d056152d7afce7306641b1973cc9c0ac3df5c2"

AFTER

"273127ae2c142ad1e0d0abb78e9fa78696bdbd5425b82d8578373963cad88f77"

changed `/files/skills~1clara~1references~1incident-recovery.md/size`

BEFORE

AFTER

added `/files/skills~1clara~1references~1local-onboarding.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "7a4d0c6de74151f5e4256c174945ea16b9d6056f620b24007a5152e4d4a02574",
  "size": 12873
}

changed `/files/skills~1clara~1references~1model-data-report-contract.md/sha256`

BEFORE

"12f8e9ab152241a9be18a60f2da375b2e8f6b32fabab5f85540271969bf34673"

AFTER

"24a6f34082e24ac4affb0d5c585e9805620802097fae6005d99c8061b1cfe56a"

changed `/files/skills~1clara~1references~1model-data-report-contract.md/size`

BEFORE

AFTER

added `/files/skills~1clara~1references~1public-process-page-contract.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "64f8f2b729b4b1c8470539ea7405d2ae51dc1035cf02fd82ab9bc55ce7ac3b43",
  "size": 3876
}

added `/files/skills~1clara~1references~1tutorial-cases.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "289949dff2927469fc96866142732f277b3ddae9d95bfaf020df9fe57c7aa8bb",
  "size": 3211
}

changed `/files/skills~1clara~1references~1workflow-catalog.md/sha256`

BEFORE

"8693ae49e53bbea514d58d6a7227accef2712d0bf92f6fcb16ad619775ca9ef8"

AFTER

"07de6bda987ccaa6367f567f5d52156f685795aef2fad745b41dfc8bc7ef203d"

changed `/files/skills~1clara~1references~1workflow-catalog.md/size`

BEFORE

AFTER

changed `/files/skills~1clara~1references~1workflow-usage.md/sha256`

BEFORE

"3c9b065c0d3a2c1e75fa55919dfed41a990ac61d67649df511381725a3ee0a8e"

AFTER

"87d748ba6c81c2d88aa5e913a993e3e5681805703cd98450c1082ac42b9f4afa"

changed `/files/skills~1clara~1references~1workflow-usage.md/size`

BEFORE

AFTER

added `/files/skills~1deck-correction~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "5b682315f229ffc5e138060010f8ba93e97128bef5f9863b30891fc2a90de3f4",
  "size": 19895
}

added `/files/skills~1deck-correction~1agents~1openai.yaml`

BEFORE

Field was absent

AFTER

{
  "sha256": "90581f521d68cda21d50472d88701c1842a2c619b53caad2e7c3140031265af4",
  "size": 384
}

added `/files/skills~1hosted-interview~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "81b959e3947a3e8cf18fb408b31a2329b295c877fbbd0b8b22fbce958c065390",
  "size": 13603
}

added `/files/skills~1hosted-interview~1agents~1openai.yaml`

BEFORE

Field was absent

AFTER

{
  "sha256": "3f0c5924cc0f51d0e958d6f8c655bda553edc7438248a7a781848ac063e4a9b5",
  "size": 321
}

changed `/files/skills~1html-deck~1SKILL.md/sha256`

BEFORE

"6dc6fcfb820c7d524d5424d6f18ce8f56e57073c7fa39dc4fbccfdee9ec3b0a5"

AFTER

"6a9a8233ba428b218117cbe929ce934644ea6486915a1561e8c855997eb5ea28"

changed `/files/skills~1html-deck~1SKILL.md/size`

BEFORE

AFTER

changed `/files/skills~1html-deck~1assets~1deck-engine~1deck.css/sha256`

BEFORE

"399869cedbb7259ee3db8be47c208868454644288b751b6359e9a271462c228b"

AFTER

"2e381434ad20806b55ebc9e103be0adc74461fca07a547d1fbbacb7871454104"

changed `/files/skills~1html-deck~1assets~1deck-engine~1deck.css/size`

BEFORE

AFTER

changed `/files/skills~1html-deck~1references~1evidence-bindings.md/sha256`

BEFORE

"46a5c15f53edcbf2e0c5b569afb9683f7c4bd783929379cc3fcc50df695a6b45"

AFTER

"d8f83b25430898ff126ee98d67fff63c49b19b965d775e8d8e86d09345c86827"

changed `/files/skills~1html-deck~1references~1evidence-bindings.md/size`

BEFORE

AFTER

changed `/files/skills~1html-deck~1references~1quality-bar.md/sha256`

BEFORE

"3630378d25c710904e4a213313e21255a053876d115b5505f07689b42c601884"

AFTER

"77424a8af1eb619d3b50f2ee31673c340822dc57b0bccfdcf68abc5f5b281604"

changed `/files/skills~1html-deck~1references~1quality-bar.md/size`

BEFORE

AFTER

changed `/files/skills~1html-deck~1scripts~1build_html_deck.py/sha256`

BEFORE

"b797e5a2487d9c43a3a5a595be791d1c4d9ed76b3f04a14f49265c2519fff2d1"

AFTER

"705edb3c88cc94d67350045250807f23d5af661549afaf1fbcc9dc5373159bf8"

changed `/files/skills~1html-deck~1scripts~1build_html_deck.py/size`

BEFORE

AFTER

added `/files/skills~1learn-with-clara~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "19c1d7c1182387d4d10e6583049e9056aa428173f24e79147b1a9ae7d48a2350",
  "size": 23717
}

added `/files/skills~1learn-with-clara~1references~1chat-button.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "81c4078be473b2547fd156b59abfc3ef4734d6bfce9929910e4a34590db62289",
  "size": 3208
}

added `/files/skills~1learn-with-clara~1references~1execution-evidence.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "551ed9f3c464b305295b82192f0c2177ea5fa25c1d30e91ea4fcde03de7f853e",
  "size": 3839
}

added `/files/skills~1learn-with-clara~1references~1file-access.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "4dcd66a6a7ad1f96ab4b74455f9a6427796dfc321056231369a75579e54626f4",
  "size": 9223
}

added `/files/skills~1learn-with-clara~1references~1local-sessions.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "bd084dcb25577abc8a3bf35ebccc5e9a1e2f80cd58b440cbc50fbc7f31ca89ad",
  "size": 6896
}

added `/files/skills~1learn-with-clara~1references~1prepared-courses.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "fe8f6ef9e83e89124307e6f2ce7009c140c8a01f106ae56573c688773a2ec1e5",
  "size": 12357
}

added `/files/skills~1privacy-surface-review~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "705fce66d6605af8c4d0b5316dce5b6645e3fd3b0205b4d5e70113545f5706ee",
  "size": 6323
}

added `/files/skills~1privacy-surface-review~1agents~1openai.yaml`

BEFORE

Field was absent

AFTER

{
  "sha256": "34aa27296dcf9552f12324266a3b18b8989fd42f609d59b691b10d08a5484791",
  "size": 278
}

added `/files/skills~1privacy-surface-review~1references~1manifest-contract.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "476cb69a14d0854b474e73e0c015c4548733a401234380de445de094125855f4",
  "size": 9174
}

added `/files/skills~1privacy-surface-review~1references~1model-data-report-contract.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "24a6f34082e24ac4affb0d5c585e9805620802097fae6005d99c8061b1cfe56a",
  "size": 19725
}

added `/files/skills~1privacy-surface-review~1references~1public-process-page-contract.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "64f8f2b729b4b1c8470539ea7405d2ae51dc1035cf02fd82ab9bc55ce7ac3b43",
  "size": 3876
}

added `/files/skills~1privacy-surface-review~1scripts~1local_helper_environment.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "211b9d29c8085fdcebd89ee6f6ef4ea92e368adf07b35058a8aa67b503c70a01",
  "size": 318
}

added `/files/skills~1privacy-surface-review~1scripts~1local_helper_environment.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "c6352dad75af89133af337159dd5aafcab89c1b21bf55c0c77133321e9d1d0fc",
  "size": 1055
}

added `/files/skills~1privacy-surface-review~1scripts~1validate_privacy_surfaces.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "8780e82205af756d0e71c81311dca110021e6f7f0abc54ebf4840143f9e6afd6",
  "size": 57562
}

added `/files/skills~1reporting-engine~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "3aba7af89899eaea8d91857b58869d62dcf1c3c403cdabe491cbec6c766a9a43",
  "size": 32051
}

added `/files/skills~1reporting-engine~1agents~1openai.yaml`

BEFORE

Field was absent

AFTER

{
  "sha256": "e40b4aca8379751d29dd466f2600aff115b71f4568790594f192433122bed3de",
  "size": 307
}

added `/files/skills~1research-video~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "b946772405fca113ebde3e05c1f54762487d27578e93560c35d0139e361b85fc",
  "size": 20691
}

added `/files/skills~1research-video~1agents~1openai.yaml`

BEFORE

Field was absent

AFTER

{
  "sha256": "51002144f019c307a584c7bf07058768f3106cc6040dcd76293e6343c01f00a0",
  "size": 600
}

added `/files/skills~1research-video~1references~1hosted-voice-bundle.schema.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "18a766c224063c1e375d9e95bf06b3fd20029a85248e8c1200850b0ce1062a63",
  "size": 2297
}

added `/files/skills~1research-video~1references~1scene-plan.schema.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "ced323cf4a01b58b455d6f105ef0581cd5afffbb2911e33ed42158b7f38a1f09",
  "size": 3481
}

added `/files/skills~1research-video~1scripts~1research_video.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "63a94251ab35c88e71fb5808fff62001c33552ff8c28550515d7b4e46e78e718",
  "size": 82049
}

added `/files/skills~1transcribe~1SKILL.md`

BEFORE

Field was absent

AFTER

{
  "sha256": "862d8beacec3777011d1e0d9d1fb4da243521a5f770d4ce750376e19fba4133c",
  "size": 14558
}

added `/files/skills~1transcribe~1agents~1openai.yaml`

BEFORE

Field was absent

AFTER

{
  "sha256": "72b77e25eb8511a596816e3a617bd4a82b7034c4a2e773a5d9828c80b671650a",
  "size": 325
}

added `/files/ui~1report.html`

BEFORE

Field was absent

AFTER

{
  "sha256": "34e5a81f3a95bbd5c7107cd1325bce54ebbb548d4ad3c3a9151222371a3dd2ee",
  "size": 77715
}

added `/files/ui~1retired-browser-interfaces.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "c6934edc13b5a8acb01b29c504f2387e175d0aed847ff7f898bfb8216d5978a6",
  "size": 727
}

added `/files/ui~1theme.css`

BEFORE

Field was absent

AFTER

{
  "sha256": "f22f840af7171e77a49b4ece7d3ceee20016bb20c38536cb7a774fd4d2a02e31",
  "size": 5509
}

changed `/files/usage~1pipelines.json/sha256`

BEFORE

"511cb7c31ae7c0f06ceccf0f9123783177df8cae40b83dd03ab6249c3d5316d2"

AFTER

"4d8e4ca107591e4724e1c24c6f5e55b73159883bf789f9d730ed44dd98e8a177"

changed `/files/usage~1pipelines.json/size`

BEFORE

AFTER

added `/files/vendor~1modules~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
  "size": 72
}

added `/files/vendor~1modules~1courseware~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "79c785f896af8b4cdcedf1210131c62b95fc2914dec135f6d3fe93d392648ec6",
  "size": 204
}

added `/files/vendor~1modules~1courseware~1access.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "bc9bdd5f713e5da54fa5cb803e88f1b481f16b6c945d9cc749d9227aa51e9ace",
  "size": 4599
}

added `/files/vendor~1modules~1courseware~1assets~1InstrumentSans-Regular.ttf`

BEFORE

Field was absent

AFTER

{
  "sha256": "69fd3f7c467c70c1f73b232812407f688f3d87dd7a801ea7281aa97d29cf53d5",
  "size": 86232
}

added `/files/vendor~1modules~1courseware~1assets~1InstrumentSans-SemiBold.ttf`

BEFORE

Field was absent

AFTER

{
  "sha256": "7151cf505f897e17b4e9b956293b5a60046ec39da3923a8feba29ce86fd14e12",
  "size": 87004
}

added `/files/vendor~1modules~1courseware~1assets~1OFL.txt`

BEFORE

Field was absent

AFTER

{
  "sha256": "bc29b497c4e8316b2d248322a9cea670c2f0afc24ae0eb7bbaa54e02e00eebab",
  "size": 4402
}

added `/files/vendor~1modules~1courseware~1assets~1chat.html`

BEFORE

Field was absent

AFTER

{
  "sha256": "a613b3880bf1aa22a89fbcf2a8748633fa39e6d22fe6c6073ece19ca059c1858",
  "size": 6926
}

added `/files/vendor~1modules~1courseware~1assets~1chat.js`

BEFORE

Field was absent

AFTER

{
  "sha256": "b76aa6e2ec27eb98ab12e1f85da933a2de432e915f1cbf96c28c5feab4490098",
  "size": 9747
}

added `/files/vendor~1modules~1courseware~1assets~1course.css`

BEFORE

Field was absent

AFTER

{
  "sha256": "5b28ac597f0a3deaf4cfc907b8a33bb40aae21719206ad0c976b605950f89dc7",
  "size": 6910
}

added `/files/vendor~1modules~1courseware~1assets~1languages.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "507967ae7dcf07ae4e138fff4333adb5fd709484731dcef45d531152c54ede45",
  "size": 68031
}

added `/files/vendor~1modules~1courseware~1assets~1legacy-course.css`

BEFORE

Field was absent

AFTER

{
  "sha256": "1d3097a5f8b2011b1cae5f1916cfc698260bc1ebc1c7e59b3ec91271aa2ee7aa",
  "size": 4819
}

added `/files/vendor~1modules~1courseware~1assets~1legacy-languages.json`

BEFORE

Field was absent

AFTER

{
  "sha256": "bd4a3481deeedf806b1eb1bfe91099a6d7796726bc19eb50eef8dc71692b67e5",
  "size": 16146
}

added `/files/vendor~1modules~1courseware~1chat.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "d9c3f73fc3cd91b9eafc6a058e1a9f09388c166d9268a60082ec3201b4d94b2b",
  "size": 9109
}

added `/files/vendor~1modules~1courseware~1deck_view.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "96f75ea3078c9e0c6e509cdefb0beeb876677e2e7884777d213d9b03c6c27b80",
  "size": 4840
}

added `/files/vendor~1modules~1courseware~1document_view.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "9982c9d6ce83e7feb26165308fa9a136a744891a7e623ce23ff9bb778e6b7403",
  "size": 9465
}

added `/files/vendor~1modules~1courseware~1execution.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "6aa0933970b41ea790d3ef2f92d2e1aa942a490e3cf76225dfe15aaa055dfd29",
  "size": 7793
}

added `/files/vendor~1modules~1courseware~1html_view.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "57280e82460bd8c7982294c4be6e0cff7da969800d4282e6da15059571cce0b1",
  "size": 7122
}

added `/files/vendor~1modules~1courseware~1legacy.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "ba650a5da883f2ea5ea741a1fd5118011c8c9215ff2a06e17f3a41785d004c8f",
  "size": 16358
}

added `/files/vendor~1modules~1courseware~1library.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "e8bacc16c16fbb8a060ec14979c665973f083a38d4cfe3f5edcdb3c8d4947917",
  "size": 68596
}

added `/files/vendor~1modules~1courseware~1native.cjs`

BEFORE

Field was absent

AFTER

{
  "sha256": "b33eb8ee25d94871d220eb22664ab746f8ee30a187212fd7072761cfd15bfe73",
  "size": 7412
}

added `/files/vendor~1modules~1courseware~1policy.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f0c15e7bac029b913d2c80167e6d23591040bf03958923a1a4c68eb0ae8fd8e7",
  "size": 1360
}

added `/files/vendor~1modules~1courseware~1preview.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "1a6e56141cdd554a6510100f47745f7b31472c9d22f45407f4f86ac7981aee10",
  "size": 4056
}

added `/files/vendor~1modules~1courseware~1recovery.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "91edce4ba8fbdda238c506a57d03a839c26390b1a1418fdc225e46d557020dbc",
  "size": 7930
}

added `/files/vendor~1modules~1courseware~1sales_plan_view.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "115977d03c034ed5f363d6fd5c8c82648ed1349067ac61e48d0701b10caa7e7b",
  "size": 3848
}

added `/files/vendor~1modules~1courseware~1theme.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "26501b56d6e6f99573a40343de95221671758db13d23a14a7012590a89ae2631",
  "size": 784
}

added `/files/vendor~1modules~1courseware~1website_view.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "f230f86272201bae7bc34f1868d8cb6013b47ce9ccc8b876acdfb0bc257637d5",
  "size": 3040
}

added `/files/vendor~1modules~1desktop_teaching~1init.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "361dab625f1122781bef9bc5fa04c7d62cf31e6fc55a10433e818a96f4bc4309",
  "size": 78
}

added `/files/vendor~1modules~1desktop_teaching~1cases.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "17c5796df886818346bae0873da3dfd324c55a4e43d37ec5bb2457b9ef2fc2a2",
  "size": 6878
}

added `/files/vendor~1modules~1desktop_teaching~1onboarding.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "065c7b3f8d3376d433fd74d4d0db8d316adb1e20720c1d88e7af7ecb85eecf61",
  "size": 32859
}

added `/files/vendor~1modules~1desktop_teaching~1teaching.py`

BEFORE

Field was absent

AFTER

{
  "sha256": "acd268d54bb7c034f06bd11cd15ccbd17d9a6bafd3e57a0d4897dc08ce06d8ab",
  "size": 25592
}

removed `/files/vendor~1modules~1vera_assurance~1init.py`

BEFORE

{
  "sha256": "e7c525a93ec80ec01a6134527f33a17d07f61cccafd90b33d26bdb96d8e1281f",
  "size": 2710
}

AFTER

Field is absent

removed `/files/vendor~1modules~1vera_assurance~1contracts.py`

BEFORE

{
  "sha256": "3ff2110aa3153c9b2e1cfc25b5febce6ef78155000c60ed76f2779ebcc5dd6df",
  "size": 92645
}

AFTER

Field is absent

removed `/files/vendor~1modules~1vera_assurance~1decisions.py`

BEFORE

{
  "sha256": "28b62f4932997aa50d4d5b099383823096c203a035f1fdbb94ec97b0ce7fe63b",
  "size": 6397
}

AFTER

Field is absent

removed `/files/vendor~1modules~1vera_assurance~1envelope.py`

BEFORE

{
  "sha256": "80f9b005b190a2607ab3a12ad9c508174c8de100d7b9752f87644c62db070358",
  "size": 18987
}

AFTER

Field is absent

removed `/files/vendor~1modules~1vera_assurance~1jurisdiction.py`

BEFORE

{
  "sha256": "9bbf63c917cad41f2d2f516c7400b092d1a5a020e8e6e83831fbacc31968ebf1",
  "size": 7887
}

AFTER

Field is absent

removed `/files/vendor~1modules~1vera_assurance~1money.py`

BEFORE

{
  "sha256": "a2064acd368ae921fc37156e88711ed9afef4c7b8de7a374be552fa644a52431",
  "size": 10967
}

AFTER

Field is absent

removed `/files/vendor~1modules~1vera_assurance~1recovery.py`

BEFORE

{
  "sha256": "9b09d6ac750c7add1574fb1c51d17308a1e4f452839c47839bfe58ddf006d384",
  "size": 20567
}

AFTER

Field is absent

removed `/files/vendor~1modules~1vera_assurance~1relationships.py`

BEFORE

{
  "sha256": "bfadd997d33e764f414e55d967933a7745ba0a9032df21addf8fed076400a085",
  "size": 15349
}

AFTER

Field is absent

removed `/files/vendor~1modules~1vera_assurance~1review_output_transaction.cjs`

BEFORE

{
  "sha256": "92718fc4d3cdd30b7a317a0c9eaa38fedad3981c8383c50c09ec7a93e754e420",
  "size": 31573
}

AFTER

Field is absent

removed `/files/vendor~1modules~1vera_assurance~1serialization.py`

BEFORE

{
  "sha256": "8fdbb590830d8a41b6bb3271ceb0abf9874237d0151028b994b9e5521077141f",
  "size": 11043
}

AFTER

Field is absent

added `/files/website-support~1LICENSE`

BEFORE

Field was absent

AFTER

{
  "sha256": "0d96a4ff68ad6d4b6f1f30f713b18d5184912ba8dd389f86aa7710db079abcb0",
  "size": 34523
}

Full snapshot data

{
  "files": {
    ".agents/skills/advisory-output-shaper/SKILL.md": {
      "sha256": "d265f67f735245b7145b24407080170e0fb29597a0782469b9c153eafefef791",
      "size": 9003
    },
    ".codex-plugin/plugin.json": {
      "sha256": "76d5492467b98c9db450f4233c519a97d762ddb46de9d4af0c02a1555ffd2b65",
      "size": 3921
    },
    "LEGGIMI_INSTALLAZIONE.txt": {
      "sha256": "a954f5a9a8ddfa2afc3a3530a415f4502bf36f06abff08dd4a0c5e1f7c77f678",
      "size": 3130
    },
    "README.md": {
      "sha256": "7aefd0c8bf52dee07ac39df6ee30fe91ec480a83cc2ee16733f22a0b4c8d5068",
      "size": 56771
    },
    "assets/courses/advisory-brief-planner/course.json": {
      "sha256": "9249d651e279c7470c71c0ebdb7b6f4291dc6f90d7d769baa1df8aee2b0f9d9c",
      "size": 32930
    },
    "assets/courses/advisory-case-director/course.json": {
      "sha256": "1c47236906eca13f0212869b08314b5b8e62ae87b796b6fa4e419243e8e1bd4a",
      "size": 30833
    },
    "assets/courses/advisory-deliverable-validator/course.json": {
      "sha256": "19afc42b95ed08b637cc986dac937bd421332d864f2f0c7b3b9fa6573481fd8d",
      "size": 37766
    },
    "assets/courses/attribute-reporting/course.json": {
      "sha256": "3c8f862a4acf16721d06ba306ba83656211ad4a8c899279622d15236ffc23459",
      "size": 42555
    },
    "assets/courses/brand-fit/course.json": {
      "sha256": "57ca324725a2a9e5bd07d2b97cba7433499a99c0f62a726e217240f195aeb0ac",
      "size": 22976
    },
    "assets/courses/business-planning/course.json": {
      "sha256": "b61e8e226c87d6d794b85ec0a8cde07045b7ca19b7d0987fafa85886a047e908",
      "size": 28008
    },
    "assets/courses/deck-correction/course.json": {
      "sha256": "bebe73b2a6a4dd0da6460a5bf09cbe72d816c97325657834626360cf45cb576d",
      "size": 41069
    },
    "assets/courses/hosted-interview/course.json": {
      "sha256": "d7b7e22cb69bd95a3442a1c29cd86bd6b8d9eb25896032e5274a4dfb3d4abeab",
      "size": 18069
    },
    "assets/courses/html-deck/course.json": {
      "sha256": "6c4847c14dd4d2235187043e00976b99361d3d61a141f192f51ff2d0230a7a09",
      "size": 34945
    },
    "assets/courses/index.json": {
      "sha256": "1d2cc75195b9ea0bd61a1a99b7c469a032d278a64248bc131dbc49fac5a8861c",
      "size": 12912
    },
    "assets/courses/remote.json": {
      "sha256": "e46d0ffd70e97f45c2672d28795c38ccea5a5a9c7a5a6d72e10295e3c4df0cc0",
      "size": 52953
    },
    "assets/courses/reporting-engine/course.json": {
      "sha256": "61a0b924afaa68e70775e892d9f8f6a2d18f14f009f4d4983ac8748f30ba2964",
      "size": 38274
    },
    "assets/courses/research-video/course.json": {
      "sha256": "c343f09f4b92125e95b80612247cf54101e359071398800e65c60790c4ea0f11",
      "size": 17393
    },
    "assets/courses/transcribe/course.json": {
      "sha256": "ecd2ea3916490e46e514cccabd07838ea734965c865e62297f658aa49a39d489",
      "size": 35922
    },
    "assets/icon.png": {
      "sha256": "98d12018ac809d7efcf392970d0f32642286fa2b2b3a5965fb52341b82ef7462",
      "size": 26456
    },
    "assets/icon.svg": {
      "sha256": "885ae5a76ac23a0acdac07e5e0999e1c3e5d32335b5fe17840b333bfa4d3bd3f",
      "size": 705
    },
    "assets/onboarding/actual-budget.xlsx": {
      "sha256": "8d6512c94dc0157476844eed608082feac49d89156d832c127525f82b19a839a",
      "size": 5585
    },
    "assets/onboarding/advisory-brief.md": {
      "sha256": "c13640e2a445df703d43eb270a352419520d420ef3ece4802e9fab3b1392cfe4",
      "size": 557
    },
    "components.json": {
      "sha256": "2a7291d3cc577d5c8a4d7598abb55f7f88aa1031780400e99c5555ae29e3cf84",
      "size": 372
    },
    "constraints-shared-macos-py312.txt": {
      "sha256": "589401f304dbdee38a0b61de71efcd1dc98163f7a9c0818c440effcbda168765",
      "size": 3188
    },
    "contracts/advisory_case_direction_return.v1.schema.json": {
      "sha256": "ed165ac93e2d246a3c22493b88d66447806dc0df97e93fdd0f5c3e2fdfe9c4b5",
      "size": 5125
    },
    "contracts/advisory_claim_register.v1.schema.json": {
      "sha256": "cabe2c7a9068336c48ad15ce8286ad9c187058cb735927c30243fab7f514e7f5",
      "size": 5590
    },
    "contracts/advisory_contract.v1.schema.json": {
      "sha256": "f4e09400874f39edddaa473453e829d269a224a0aa6644a8713517d70e8ed078",
      "size": 11559
    },
    "contracts/advisory_evidence_register.v1.schema.json": {
      "sha256": "23e01ec85368cbfe6e89d2f75578dbaf1528d72248baec11821210f67d42a23d",
      "size": 6129
    },
    "contracts/preparation_audit_envelope.v1.schema.json": {
      "sha256": "3e510824ad6fd0f63aac4a3938386a9da6237f41760ee36b6dd360ae4bd1c757",
      "size": 25281
    },
    "contracts/preparation_audit_envelope.v2.schema.json": {
      "sha256": "8502465c354afbbff6071e52b99caabc3a46e52409896a996aa37bdc9e993b02",
      "size": 8147
    },
    "contracts/real_data_pilot_intake.v1.schema.json": {
      "sha256": "bd9ba671ac718277107609df701f5afd92a38b3c46c3a941c74f0f4379a1d3f9",
      "size": 9026
    },
    "contracts/real_data_pilot_intake.v2.schema.json": {
      "sha256": "737008f2ecf919a938653bb552c83b5fb4ff4a3fb33fe9d0a6f7e4f866c716f6",
      "size": 9181
    },
    "contracts/real_data_pilot_intake_receipt.v1.schema.json": {
      "sha256": "e6840e0d17577522e575f2899a53b5e04aaddc7f60a867f8a72f6273bb35fa05",
      "size": 11666
    },
    "contracts/real_data_pilot_intake_receipt.v2.schema.json": {
      "sha256": "e7f974b60da6b74e10817cde240cf934e8bef978745f85d681f5d59781bd6307",
      "size": 11879
    },
    "contracts/real_data_pilot_mechanical_error_register.v1.schema.json": {
      "sha256": "f310c82d677df194f4557487459c575dc6cd93c132f565d5484db11cb05ab6a6",
      "size": 8781
    },
    "contracts/real_data_pilot_retention_approval.v1.schema.json": {
      "sha256": "45bebf3e5fbb314e54959c9183fdd0ec99f8da4383c2255a8ee7af9d330fde30",
      "size": 2485
    },
    "contracts/real_data_pilot_sanitized_error_class_summary.v1.schema.json": {
      "sha256": "9366fcc6e358e72772b5fe4c02b843e9461cf84b59aed2dc41081cd0e8a42ab2",
      "size": 11368
    },
    "contracts/real_data_pilot_sanitized_error_class_summary_candidate.v1.schema.json": {
      "sha256": "c293f458d2625e763c10c5a17104c02bb4cc58de3868fe4ec33ffcee4dc93d09",
      "size": 7392
    },
    "contracts/real_data_pilot_semantic_review.v1.schema.json": {
      "sha256": "457be4c91ebc2f7564b03634cf678fca1ec34d94d4361604b319a8e4b7cb45e7",
      "size": 9323
    },
    "contracts/real_data_pilot_semantic_review_receipt.v1.schema.json": {
      "sha256": "e0f64761ddc4bd0782f91803bf1e5854333da0a25149399bf262939de5468b46",
      "size": 9836
    },
    "contracts/real_general_ledger_preparation_case.v1.schema.json": {
      "sha256": "41fb37ff10ca74eac2a22141104ecdd2e9854b6f5139430b0ccab5e8e9e058e8",
      "size": 7728
    },
    "contracts/real_general_ledger_semantic_decisions.v1.schema.json": {
      "sha256": "b7448565b9a9eb18d6c8559174b6fcd247d1592f505917b03ff386699538b038",
      "size": 6420
    },
    "contracts/reporting_evidence_handoff_receipt.v1.schema.json": {
      "sha256": "0e90e3d5e1e12b22d3230e76ed4dd731567abffd60d3c7eb412cc2d1460e9768",
      "size": 12382
    },
    "docs/specs/pptx_templates/ag-style-spec.md": {
      "sha256": "89b974726837b69188e9416c8c5154733bb728876b899699151fb1c5f9f1a760",
      "size": 5134
    },
    "docs/specs/pptx_templates/bain-style-spec.md": {
      "sha256": "7955c74d8631968006dc6ded2ca5bcb305c84c0e7802f8e103ccf09a00bb7212",
      "size": 1610
    },
    "evals/html_deck_benchmark_protocol.md": {
      "sha256": "c948878da661aed109de87121932aa51ac88f82f2f1f1ab8b0fcbc61c67247eb",
      "size": 7346
    },
    "evals/html_deck_benchmark_runs.schema.json": {
      "sha256": "3064049983e1dbbe83d540cbce44bbf2e37f8228d46d5ea001648029fb6b24f8",
      "size": 11735
    },
    "evals/html_deck_capability_benchmarks.json": {
      "sha256": "41656a784e5a72023d6f3a7aacbedb98a2e231147d83a4a3c628dd3b6fef4205",
      "size": 13282
    },
    "evals/preparation/udc_fy2025_customer_concentration/case.json": {
      "sha256": "4051affdaf72127968dd0a377eec41be2a403c3ea4201e2c03376be871e680e9",
      "size": 5816
    },
    "evals/preparation/udc_fy2025_customer_concentration/exact_control_facts.csv": {
      "sha256": "57a84b89c7172e7f8d1497cf1974ae13860289dd44902d83302deb66812f25f8",
      "size": 771
    },
    "evals/preparation/udc_fy2025_customer_concentration/exact_extracted_facts.csv": {
      "sha256": "784a2785e5f3a17f4c3382ca61a669a9f0680139865a202328eb0339b4806be7",
      "size": 2448
    },
    "evals/preparation/udc_fy2025_customer_concentration/expected/customer_concentration_summary.csv": {
      "sha256": "48c75363a10a4e5339fee4f3f57b9e27d4005430a7faa099d38ca4e4f94a00f2",
      "size": 2595
    },
    "evals/preparation/udc_fy2025_customer_concentration/expected/exceptions.csv": {
      "sha256": "aae96c35ad9098a8580bbc08b841dfb2ae41a374efeb9ce97ad69a7f8eb0b1a3",
      "size": 39
    },
    "evals/preparation/udc_fy2025_customer_concentration/expected/prepared_evidence_manifest.json": {
      "sha256": "f422439cde2c63839b0e812159f91ddddd425d41b4dd19e100200e20ae716120",
      "size": 8735
    },
    "evals/preparation/udc_fy2025_customer_concentration/expected/reconciliation.json": {
      "sha256": "27446774176f313a8a1a7f8d72c615e5bf4267c0770dfa1d063843cb5d6135fa",
      "size": 9628
    },
    "evals/preparation/wd40_fy2025/SOURCE_NOTES.md": {
      "sha256": "7ea069095ffff82bfed4d1643ce3fb53fd8afa0b38f28d570ad91b1f59b23d3a",
      "size": 3770
    },
    "evals/preparation/wd40_fy2025/case.json": {
      "sha256": "16e1454f3d3b6d1ac73269a720bd4f74e6feab9764fe5d795193cd8ead9d6480",
      "size": 7709
    },
    "evals/preparation/wd40_fy2025/expected/monthly_pnl.csv": {
      "sha256": "ad7b2f1b2267ece697d7ec1cce9e0155da68ae10d5a8eeb7100823fda28bf1a0",
      "size": 14892
    },
    "evals/preparation/wd40_fy2025/expected/prepared_evidence_manifest.json": {
      "sha256": "a1784ad9a4ce33ed4090c9e9e6e036382ea4a628080fcd8526ae24d5afe271c3",
      "size": 6901
    },
    "evals/preparation/wd40_fy2025/expected/reconciliation.json": {
      "sha256": "4dd146d25196b79a24f70c9363b73623c55bf600359d4c70239815db2e6126a4",
      "size": 66449
    },
    "evals/preparation/wd40_fy2025/expected/unmapped_accounts.csv": {
      "sha256": "4268cab92c65ff567104c2243854a0cc6722b0eaaa61f9544e57c2bc098c0052",
      "size": 115
    },
    "evals/preparation/wd40_fy2025/monthly_pnl.semantic.json": {
      "sha256": "016535666fcf286057fb4e475f9b5daea12e9c4360f1eab3fba6f6ccd9afbd27",
      "size": 24745
    },
    "evals/preparation/wd40_fy2025/public_statement_facts.csv": {
      "sha256": "91a650591f155dfa5a6722747d95832eb5cbc453353cfa94b00ce374da2c5c42",
      "size": 17627
    },
    "evals/preparation/wd40_fy2025/reporting_handoff_request.json": {
      "sha256": "4ca9586efa32653bf754f7fca4bd12b4f07133329695861476c7c39ffd8dde2b",
      "size": 3141
    },
    "evals/preparation/wd40_fy2025/reviewed_coa_mapping.csv": {
      "sha256": "32a754b6d57a6dd08abaf0f932e8c92399e9ffbdf38ea66bcd4579c4e89025ef",
      "size": 3359
    },
    "evals/preparation/wd40_fy2025/statement_render_recipe.json": {
      "sha256": "493727b2874f005d1d338725fd5c461953397f079c133413b3eab9a4653cd5e8",
      "size": 3239
    },
    "evals/preparation/wd40_fy2025/synthetic_monthly_trial_balance.csv": {
      "sha256": "25f6ddc79de3d03aa58d3e606bbe933768f4584c768e15d9d384d3392618f8a3",
      "size": 25633
    },
    "evals/preparation/wd40_fy2025_working_capital/case.json": {
      "sha256": "a7542faf40a63fe00a1eb16bde128aaad5dbd7653d7d4067a48cd5dedd003518",
      "size": 6394
    },
    "evals/preparation/wd40_fy2025_working_capital/expected/discrete_cash_flow_schedule.csv": {
      "sha256": "37712a663e5020fb9044666596e189e0f102824de18a630a5326b653c469e679",
      "size": 1232
    },
    "evals/preparation/wd40_fy2025_working_capital/expected/exceptions.csv": {
      "sha256": "aae96c35ad9098a8580bbc08b841dfb2ae41a374efeb9ce97ad69a7f8eb0b1a3",
      "size": 39
    },
    "evals/preparation/wd40_fy2025_working_capital/expected/prepared_evidence_manifest.json": {
      "sha256": "eae57ebc0cab265cbbce19461be573626498f4997bdc6a52d8c590fd8494ac1d",
      "size": 5192
    },
    "evals/preparation/wd40_fy2025_working_capital/expected/raw_fact_preservation.csv": {
      "sha256": "dd925bd158142eb3a8b27cecc307c522629edcc8b2514b04416e68ddf31daf65",
      "size": 22852
    },
    "evals/preparation/wd40_fy2025_working_capital/expected/reconciliation.json": {
      "sha256": "6611a4d4e54c42fe2438cc49cee57db9d04b9d8a5e7cebf9d6b70e4af2442806",
      "size": 3356
    },
    "evals/preparation/wd40_fy2025_working_capital/expected/stock_flow_bridge.csv": {
      "sha256": "fbc674450b2eee6db991e59969f4dd08b05982933502dbed02a511f38c2fd210",
      "size": 923
    },
    "evals/preparation/wd40_fy2025_working_capital/expected/working_capital_schedule.csv": {
      "sha256": "08859ba960029c9452242a57ebcfc81ef52b39cba52368b61c3eb16171814127",
      "size": 876
    },
    "evals/preparation/wd40_fy2025_working_capital/public_working_capital_facts.csv": {
      "sha256": "dd925bd158142eb3a8b27cecc307c522629edcc8b2514b04416e68ddf31daf65",
      "size": 22852
    },
    "evals/preparation/wd40_fy2025_working_capital/reviewed_working_capital_policy.json": {
      "sha256": "232661ccf01aff9c6852b8d02de81af708b7f9ab7f70384021cab90c1afa1e80",
      "size": 3306
    },
    "evals/public_truth/fastenal_q1_2025/SOURCE_NOTES.md": {
      "sha256": "adb60c54f821512433d55adcf2c75373ba99ee048a2e9ea82498789850937ef1",
      "size": 1687
    },
    "evals/public_truth/fastenal_q1_2025/benchmark.json": {
      "sha256": "88b859f1e43a2ee6883bb9c6c7b9e61bcae26108de9db7c8deabf77d97dd22fc",
      "size": 6615
    },
    "evals/public_truth/fastenal_q1_2025/expected_prepared_observations.csv": {
      "sha256": "bf27e23960f1050394584f865a8fd59a7f7db1f9cabfa3345be923094fbc6eac",
      "size": 2228
    },
    "evals/public_truth/fastenal_q1_2025/expected_validation_report.json": {
      "sha256": "b2bf3848db2851f4b1b31fd63568af555ab99e174b28705873bfffee2aa1bf74",
      "size": 6928
    },
    "evals/public_truth/fastenal_q1_2025/truth_observations.csv": {
      "sha256": "bf27e23960f1050394584f865a8fd59a7f7db1f9cabfa3345be923094fbc6eac",
      "size": 2228
    },
    "evals/trigger_fixtures.json": {
      "sha256": "0fe442e3c2637722df655d1517fdb73d71fb8d1a25d2e9891ac9cd0202820537",
      "size": 16252
    },
    "execution-files.json": {
      "sha256": "8cbf24474c0c1dd1bb8bc5f095d27b73775adb8c8a86affd7629f694c997bc56",
      "size": 174408
    },
    "marketplace_skill_instructions.json": {
      "sha256": "0927c8c334a1e2a7c367956dc98802ed198e2a43db3eb33940cf28211c5c0249",
      "size": 13445
    },
    "mcp-catalog.json": {
      "sha256": "9d58ce1fac5ef7857cbe49af8373fde37a90883b8dcf9a6bf2f95a32701ac94a",
      "size": 45448
    },
    "mcp-services.json": {
      "sha256": "dee3cd6c891e8cb7641897e57b6b5d649a635e1c11a5fafe5222ceb94dc6e34d",
      "size": 856
    },
    "modules/attribute-reporting/.codex-plugin/plugin.json": {
      "sha256": "bfa6e3e4fb5acd72c7afd674731e1375761e76d79d11670649e510284fa40c98",
      "size": 2548
    },
    "modules/attribute-reporting/README.md": {
      "sha256": "5302d8fbd68b0f1e99d7cad82797fa64d2052cdeb10a25ffb1ae671a07cf7db1",
      "size": 866
    },
    "modules/attribute-reporting/assets/icon.svg": {
      "sha256": "0c1edab1496be5d851dc3bf5a17cce10b612ad74d0f3a8567659b8e69027710d",
      "size": 917
    },
    "modules/attribute-reporting/evals/trigger_fixtures.json": {
      "sha256": "a70f4a8d28086e830d8bea069ed730e231a41aadd95a272f6c04d3e2a52136f4",
      "size": 1810
    },
    "modules/attribute-reporting/requirements.txt": {
      "sha256": "19f93c2e80b6e39003de1131a2fff49f70c5281c3badade0deb10a8fa61a5b9b",
      "size": 34
    },
    "modules/attribute-reporting/scripts/apply_validated_mappings.py": {
      "sha256": "1dcc9ab6bf2e622dcfa78d4dc3fa178f32fa6d87f696f4f12a65b1b3914098fe",
      "size": 16444
    },
    "modules/attribute-reporting/scripts/attribute_reporting.py": {
      "sha256": "dfb71e185cb1a428081cb4e808b4f1410f8878cf140a1e5525e4241831094ad2",
      "size": 246613
    },
    "modules/attribute-reporting/scripts/bind_mapping_images.py": {
      "sha256": "e984adecac352d2281f34b741570be03b6727c1598a0cccc14655f37abbc3f82",
      "size": 1232
    },
    "modules/attribute-reporting/scripts/brand_fit.py": {
      "sha256": "c81792ff92a0f5b6e9e2db435acb5a6a234d013f3cff25e4d9006d1c4a8698a4",
      "size": 135788
    },
    "modules/attribute-reporting/scripts/browser_qa.py": {
      "sha256": "4d57596687f210359858e3a48c5205df63512f18de7a09c60400593d194a9a3b",
      "size": 14721
    },
    "modules/attribute-reporting/scripts/check_brand_fit_report.py": {
      "sha256": "5cfc4465060ceeed8053c5248856c11399fc278266fc982d9d9475c71554abbb",
      "size": 861
    },
    "modules/attribute-reporting/scripts/check_dependencies.py": {
      "sha256": "f1ae4013ca0e4c709dd412bf3a71d490b67d9a22610d27a571ea8fe9c4a3b762",
      "size": 2195
    },
    "modules/attribute-reporting/scripts/check_report.py": {
      "sha256": "a1faa5ddbf2ae31d97eb143dabd1c7483a56d2e8476953ebc529fc16b83782b6",
      "size": 1765
    },
    "modules/attribute-reporting/scripts/create_mapping_tasks.py": {
      "sha256": "3b244f3f99b704ed361b6586d881c329c6c8f293dafe92cdac244656660d63f8",
      "size": 2129
    },
    "modules/attribute-reporting/scripts/hydrate_images.py": {
      "sha256": "b88fa51362b4f7f686e735c7ff869618cadd93f5c8d5fc349a5481932f6fb874",
      "size": 32116
    },
    "modules/attribute-reporting/scripts/mapping_shards.py": {
      "sha256": "c7ea065fa5d28c08e2eb23b08bc80218fe4fd2df216d54544e133acd46eac453",
      "size": 42419
    },
    "modules/attribute-reporting/scripts/prepare_brand_fit_run.py": {
      "sha256": "1b2d148c9e6ecdc102da0fbf2ebbcc6cbd5c2ed73591660aef48c2040f9b7d85",
      "size": 1494
    },
    "modules/attribute-reporting/scripts/prepare_mapping_review.py": {
      "sha256": "cc2b8084b757a51124e2172c9b2427c6ded15ff2b95747264f46d4fe00ae1bcf",
      "size": 2226
    },
    "modules/attribute-reporting/scripts/prepare_run.py": {
      "sha256": "86d2c52270dcc5eeebb4412e94fcf94e542182f7163fb996ed741d932d68204a",
      "size": 3918
    },
    "modules/attribute-reporting/scripts/project_pipeline.py": {
      "sha256": "c5ad8e78591e2304371ff7ade9dbb8a302305bfea956a4ec2e5e50730459f023",
      "size": 7002
    },
    "modules/attribute-reporting/scripts/render_brand_fit_report.py": {
      "sha256": "9de5c11b392e33094ae4af8ac702d6dbe3d43c2be33ac33cd7fcc5bf207f3c0c",
      "size": 727
    },
    "modules/attribute-reporting/scripts/render_report.py": {
      "sha256": "51e198ac847156d978815a2e34dd3307caba827fb0b5bb5a4c89b214fbc27b9e",
      "size": 1796
    },
    "modules/attribute-reporting/scripts/run_state.py": {
      "sha256": "1ce28986e52c0efa18560afc01024fdce03ad6b6ef49ac25b7d4eaabac7d5308",
      "size": 20779
    },
    "modules/attribute-reporting/scripts/server_bridge_client.py": {
      "sha256": "d9ca2aa1ff6ecf7679eb835e40c1f0c56bdc72f1618b82d0cf2671704c5ae1f5",
      "size": 40486
    },
    "modules/attribute-reporting/scripts/validate_mapping_decisions.py": {
      "sha256": "8a90b8ac2b42cb273c11a3b86bf0a0c661c45740936105cc9bec114b0ea6e2d1",
      "size": 1926
    },
    "modules/attribute-reporting/scripts/validate_mapping_review.py": {
      "sha256": "0457715ca2895eab228a854aa58374ec81d3db27872a0b4fbd534f35a93f32d0",
      "size": 2172
    },
    "modules/attribute-reporting/skills/attribute-reporting/SKILL.md": {
      "sha256": "936411e8d0f4aefb76e32fe74b968cb82782f5f1703b0e611178f8c75bee83fd",
      "size": 32571
    },
    "modules/attribute-reporting/skills/attribute-reporting/references/server-boundary.md": {
      "sha256": "c6c0476aaffd73e547a8801573598988c177afa1b96fd099fd6d00cd9609f769",
      "size": 10999
    },
    "modules/attribute-reporting/skills/attribute-reporting/references/workflow-reference.md": {
      "sha256": "765e0a37288e20c148c8dd3f699b53a5fb4239156e0a5592f4da8ef1fd85e8f4",
      "size": 22997
    },
    "modules/attribute-reporting/skills/brand-fit/SKILL.md": {
      "sha256": "692acf92c23bf51e3d7e86b9fd69ff3dbd0b32a5f39947247273a51a4e803e0b",
      "size": 9895
    },
    "modules/attribute-reporting/vendor/modules/__init__.py": {
      "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
      "size": 1
    },
    "modules/attribute-reporting/vendor/modules/pdp/attribute_report_copy.json": {
      "sha256": "c388ee1e2681df6c9cd611a0afcd75b1035a95d07110214da0492179e7eac6dd",
      "size": 47111
    },
    "modules/attribute-reporting/vendor/modules/pdp/attribute_table_catalog.json": {
      "sha256": "5f5a44e1ff0b3c6de6a64f0efe4886b1a103911fbb8e6ee7507a5fdbc5f6c1ad",
      "size": 5608
    },
    "modules/attribute-reporting/vendor/modules/pdp/attribute_table_catalog.py": {
      "sha256": "db3eebe7ce9ded9acf25a9da33bf7ec70c8ee762f36c46512ccc2c471fefedc0",
      "size": 4036
    },
    "modules/attribute-reporting/vendor/modules/pdp/attribute_table_templates.py": {
      "sha256": "4e4a46812fa6a4c04e0e78d18b9f51cfee86bfaa629827abf50e9e0cd93a33f5",
      "size": 44328
    },
    "modules/attribute-reporting/vendor/modules/utilities/utils.py": {
      "sha256": "dfeb4543d1482650e8be2bf6ea9f5ff313abe7dde7fef0539031c95a08a5c56e",
      "size": 7566
    },
    "modules/business-planning/.codex-plugin/plugin.json": {
      "sha256": "1c8b35b2e4a152fa2ebca901df2495f33b5e780c4e5251ccb0934f83ec1402c0",
      "size": 1892
    },
    "modules/business-planning/assets/icon.svg": {
      "sha256": "785402457fc534e9c558bc9320e1495957e4c825399d55db53b516d971f20c51",
      "size": 913
    },
    "modules/business-planning/assets/report-interaction.css": {
      "sha256": "e80e8e85ca62779557d302446c0cdaccad00be2a2220c87adb0cef02ac8cd4b7",
      "size": 1100
    },
    "modules/business-planning/assets/report-interaction.js": {
      "sha256": "3a9809b9b3bf2396fae1ce7fcca96071b517449cb03c8c5d774887fae2485b97",
      "size": 1364
    },
    "modules/business-planning/evals/decision_assessment_cases.md": {
      "sha256": "eb732a7daf3f2d1c9be100ab9058178b9d59c051c19f0a12fdb0bcea8e5cb038",
      "size": 2763
    },
    "modules/business-planning/evals/trigger_fixtures.json": {
      "sha256": "57690c065c7142cf52a85ac1a0d846f1307b0015b46c2f804083762838ab7440",
      "size": 2541
    },
    "modules/business-planning/references/case-contract.md": {
      "sha256": "d26e907e314b421fb72b3d58e9e9bc81f292072ab199eae48dcbe2d558a5ed67",
      "size": 25624
    },
    "modules/business-planning/references/financing-assessment.md": {
      "sha256": "8fca3d1622c56814ddbfe3537adee25c762535a5aac687e43aec140f60d2125d",
      "size": 5129
    },
    "modules/business-planning/references/sites-delivery.md": {
      "sha256": "11eff0e90e80cfb5fa853d509c82cbdfec60ab625a23d501ad9f4ed94e767776",
      "size": 3807
    },
    "modules/business-planning/requirements-pdf.txt": {
      "sha256": "6ab735f53cb40a6cbe0aad3aa4c51187efde50843e206efeaa56dce32c8c5674",
      "size": 166
    },
    "modules/business-planning/requirements.txt": {
      "sha256": "9bba605fd7b6ea23038de15e5a1ae6714b3d3fb14ed2d6e6bedbfb0665ca2122",
      "size": 17
    },
    "modules/business-planning/scripts/business_planning_contribution.py": {
      "sha256": "ad2f1500df8ceb0127ce22aae3bd85ead8b57c84616ebd4db23022795e1f2926",
      "size": 18640
    },
    "modules/business-planning/scripts/business_planning_core.py": {
      "sha256": "28bf6bc3bf03fc6eb7ba05ce38c66b417a6aa5461ffcd0048b5033bf96d67963",
      "size": 53574
    },
    "modules/business-planning/scripts/check_dependencies.py": {
      "sha256": "df7d7c9ab748163f98d50d3514f859594ea89aab65b05b302bb2d7987c8410c2",
      "size": 2303
    },
    "modules/business-planning/scripts/planning_assessment.py": {
      "sha256": "ae5f7075ccad11e35d6a7b0559d5b1a44037efcd9d9eaf3949f7c5dd8374b389",
      "size": 3780
    },
    "modules/business-planning/scripts/planning_cli.py": {
      "sha256": "677242e2a027c0d3c3aeff6cf537cf3e879aedbfc943d2edc6cd7ae4c49874f2",
      "size": 3269
    },
    "modules/business-planning/scripts/planning_commercial.py": {
      "sha256": "5d318e0fc442378a6ac27780e392a1435bfe0ae0f9b04c7f7e04dcdb5f3eed44",
      "size": 5186
    },
    "modules/business-planning/scripts/planning_cycle.py": {
      "sha256": "86ea90f4c52b8b00bd012e6da49d08b337a3a8aac3ac8be072b648e8076b991e",
      "size": 7261
    },
    "modules/business-planning/scripts/planning_decision_report.py": {
      "sha256": "41de252255551ce768c4dd3fb5ae3f86a161d17eaccd3581a69ad6b374ff86d7",
      "size": 4286
    },
    "modules/business-planning/scripts/planning_financing.py": {
      "sha256": "e6c852b3d34817a3b4a111223e7e3071430261301dfba6d509339fe60fdcd25a",
      "size": 6330
    },
    "modules/business-planning/scripts/planning_french.py": {
      "sha256": "3ad166b7f13337280aa13de20da6e56d3167b1ac0f882e763a1f963b338e9780",
      "size": 8037
    },
    "modules/business-planning/scripts/planning_interaction.py": {
      "sha256": "3acf8c8bc7e22042291f8050205bf2c3fcf17c5a66c9d5e3621d61cd236d63bf",
      "size": 4114
    },
    "modules/business-planning/scripts/planning_presentation.py": {
      "sha256": "f9ccfc89c1ecf912e22b989b033bd7abd95964b26c7b5706e213f89464576e3a",
      "size": 28389
    },
    "modules/business-planning/scripts/planning_report.py": {
      "sha256": "077d47c8bb10d28b0dfb5d20140d60da9247d9483d5697dbe0924a69b7992822",
      "size": 43811
    },
    "modules/business-planning/scripts/planning_site.py": {
      "sha256": "2c78c6cba31ce24603582d5b8c739c5fdabe4ed3e5eb14189331a8d69b36af7f",
      "size": 3090
    },
    "modules/business-planning/scripts/planning_workflow.py": {
      "sha256": "44bb1a8ae6193bdea5c7e4a9173181c6cd0fb73dc0cfcc97f72fbf7d6d7ce506",
      "size": 41810
    },
    "modules/business-planning/scripts/prepare_report_site.py": {
      "sha256": "1d49f59d6e493f658902b828048332859edd996dfa3494a7532a31a6e056f38e",
      "size": 1551
    },
    "modules/business-planning/scripts/run_business_plan.py": {
      "sha256": "ce43cb335e342c74b5fe578d2b52558ccc2fef85678cc6ffdf07008a87c5d9c9",
      "size": 1723
    },
    "modules/business-planning/scripts/run_strategic_plan.py": {
      "sha256": "ecf900ef1a32771f53848eac3d530bd908a95b27a0a80227f0aff7cce2cf653c",
      "size": 1726
    },
    "modules/business-planning/scripts/strategic_planning_core.py": {
      "sha256": "7f5360c69a0441de3647e6077fe7b0a876eaa194366afc38c3bf04a7a1b5fb51",
      "size": 44486
    },
    "modules/business-planning/skills/business-planning/SKILL.md": {
      "sha256": "76a7c1d31a6be7be73eb917b33784f513211d6feeae04b8a72584f996c681aea",
      "size": 22842
    },
    "modules/business-planning/skills/business-planning/references/geneva.md": {
      "sha256": "dcc3568a18a17179f0c4b3092beaac512e426e102e1a3ec122094b0619cd3acb",
      "size": 806
    },
    "modules/business-planning/vendor/modules/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/business-planning/vendor/modules/reporting_table.py": {
      "sha256": "99b687b83f4ce62fb2a33c875cf5740edb0854e9a7b094f1c314b1b6198adc1e",
      "size": 17079
    },
    "modules/business-planning/vendor/modules/vera_assurance/__init__.py": {
      "sha256": "e7c525a93ec80ec01a6134527f33a17d07f61cccafd90b33d26bdb96d8e1281f",
      "size": 2710
    },
    "modules/business-planning/vendor/modules/vera_assurance/contracts.py": {
      "sha256": "8203378c30262e1dfc568099a34a444cb33130343abf17d4a2eea8da107d7cb0",
      "size": 93104
    },
    "modules/business-planning/vendor/modules/vera_assurance/decisions.py": {
      "sha256": "28b62f4932997aa50d4d5b099383823096c203a035f1fdbb94ec97b0ce7fe63b",
      "size": 6397
    },
    "modules/business-planning/vendor/modules/vera_assurance/envelope.py": {
      "sha256": "80f9b005b190a2607ab3a12ad9c508174c8de100d7b9752f87644c62db070358",
      "size": 18987
    },
    "modules/business-planning/vendor/modules/vera_assurance/jurisdiction.py": {
      "sha256": "9bbf63c917cad41f2d2f516c7400b092d1a5a020e8e6e83831fbacc31968ebf1",
      "size": 7887
    },
    "modules/business-planning/vendor/modules/vera_assurance/money.py": {
      "sha256": "a2064acd368ae921fc37156e88711ed9afef4c7b8de7a374be552fa644a52431",
      "size": 10967
    },
    "modules/business-planning/vendor/modules/vera_assurance/recovery.py": {
      "sha256": "fbc5402144b405057deb92005580923f7b2ab67cfd439fe2af977a49f96f1715",
      "size": 21592
    },
    "modules/business-planning/vendor/modules/vera_assurance/relationships.py": {
      "sha256": "bfadd997d33e764f414e55d967933a7745ba0a9032df21addf8fed076400a085",
      "size": 15349
    },
    "modules/business-planning/vendor/modules/vera_assurance/review_output_transaction.cjs": {
      "sha256": "63075c6c3b0eff1d3a6706aa59d0dd1e00c558f9a4b51dcf952e881caccfa348",
      "size": 41618
    },
    "modules/business-planning/vendor/modules/vera_assurance/serialization.py": {
      "sha256": "8fdbb590830d8a41b6bb3271ceb0abf9874237d0151028b994b9e5521077141f",
      "size": 11043
    },
    "modules/distribution-analysis/.codex-plugin/plugin.json": {
      "sha256": "c45e0e51efcc5e3230591799ccf77b11d68bd9e936cfce2a1038d6b66f50e9c8",
      "size": 2203
    },
    "modules/distribution-analysis/README.md": {
      "sha256": "42de98fac4adc48922ed4b259a2a3b01f89eeb86fcd4c46a18c2c4405945bbd6",
      "size": 2014
    },
    "modules/distribution-analysis/assets/icon.svg": {
      "sha256": "11a9544c5d33f5243634ea8b3e2064fc2890241646690f05daa4022aac5da2a4",
      "size": 736
    },
    "modules/distribution-analysis/evals/trigger_fixtures.json": {
      "sha256": "d9a48a1570f21e3db9e83746aaaede0eac0e4bc37a475d2c3f75ff9aad69115b",
      "size": 895
    },
    "modules/distribution-analysis/mcp/server.cjs": {
      "sha256": "897f611578c78cf35f66ae350430f3e7e75dcc863d47519b165f11c42f8b04d7",
      "size": 65881
    },
    "modules/distribution-analysis/references/legacy_distribution_inventory.md": {
      "sha256": "2068461b71786e992b8c47fb77c2b832850d258b0e3bd21e7a876ad45ee47403",
      "size": 2343
    },
    "modules/distribution-analysis/references/legacy_inventory.json": {
      "sha256": "26934b40e7127742db193204e40586633c15e625f12c54d9c346c8266fa04768",
      "size": 756
    },
    "modules/distribution-analysis/requirements.txt": {
      "sha256": "ef89688b68ba05bdb864cd0382b15ac2db2210bc6df1a116926fbfe9969639b7",
      "size": 130
    },
    "modules/distribution-analysis/scripts/check_dependencies.py": {
      "sha256": "25b3a413f67ca4bd46516a9dcffb68b1a458cac8622e61051fab9223b7c9a7ca",
      "size": 4068
    },
    "modules/distribution-analysis/scripts/distribution_core.py": {
      "sha256": "1880db72dde1b37e4b8fc5a28bfd864a180d7208db50147095e450ec97ff401d",
      "size": 55886
    },
    "modules/distribution-analysis/scripts/inspect_inputs.py": {
      "sha256": "a4a9411fb0e2fdbb84bd6f52398107d016a823fa79522667b28de6d4ba2ff524",
      "size": 1669
    },
    "modules/distribution-analysis/scripts/legacy_distribution_charting.py": {
      "sha256": "af91327efbc46b31548befe32ae4d01e996cbaac0019349af9fbaa25fde6f5a2",
      "size": 45565
    },
    "modules/distribution-analysis/scripts/review_session.py": {
      "sha256": "454f7606ab331b0eb8b6923cf07b1254ac8bb5fa01474c302c5c200057ce20e3",
      "size": 20030
    },
    "modules/distribution-analysis/scripts/run_distribution.py": {
      "sha256": "a2d510513d7ab0e041cb714d35d513734e070e9e35bc1d1b0634a8af53685133",
      "size": 1665
    },
    "modules/distribution-analysis/skills/distribution-analysis/SKILL.md": {
      "sha256": "67caca336ecd2eff4555b686afcbd46150bb1e7f4d72d3a61952effd646b7da9",
      "size": 10062
    },
    "modules/distribution-analysis/vendor/modules/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/distribution-analysis/vendor/modules/auth/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/distribution-analysis/vendor/modules/auth/config.py": {
      "sha256": "7e95dfe02a16f254346f49ae981890d5641ca11fa6c32e1ba92269c6e04327a9",
      "size": 4441
    },
    "modules/distribution-analysis/vendor/modules/auth/google_identity.py": {
      "sha256": "bc33a5cacf88ab073c72171640c7067429c6884927ab1628f5fece503262dd9e",
      "size": 5521
    },
    "modules/distribution-analysis/vendor/modules/auth/session.py": {
      "sha256": "554cb2902d1ad2ee3ce232dd5c06422cd23232d0995489e18c25be61778ae42b",
      "size": 3849
    },
    "modules/distribution-analysis/vendor/modules/chart_harness/__init__.py": {
      "sha256": "64040e09b08b176a94cee3a65971c649479d7bc2d47a7a48c0fed0bf00c65dc5",
      "size": 4699
    },
    "modules/distribution-analysis/vendor/modules/chart_harness/analysis_context.py": {
      "sha256": "b1a530fffe1f9ae963950e779dd409920d94a168289f3faafef6cc93c8c2985e",
      "size": 10800
    },
    "modules/distribution-analysis/vendor/modules/chart_harness/artifacts.py": {
      "sha256": "190476ae688368778b08804e049244e595461edb7206f3525a0a1baec1f5b5e6",
      "size": 22039
    },
    "modules/distribution-analysis/vendor/modules/chart_harness/date_parsing.py": {
      "sha256": "175f17c295b0029db1bb895876aaa4f66d9a3e19b924cfffbbf22af42879a087",
      "size": 1104
    },
    "modules/distribution-analysis/vendor/modules/chart_harness/metric_semantics.py": {
      "sha256": "10849cdef532699ff323233f4f699eddee7fba7836075984199657c5c8d41f5a",
      "size": 12757
    },
    "modules/distribution-analysis/vendor/modules/chart_harness/period_contract.py": {
      "sha256": "1d04dd1a23808ecda086a53f3d76a492a2600c2b58917a63cd272a0b330e1384",
      "size": 11110
    },
    "modules/distribution-analysis/vendor/modules/chart_harness/period_derivations.py": {
      "sha256": "dfbe2252a94f7a264c1431a82fcf6cedd664756496399ad3090d9ee05c7fe614",
      "size": 30445
    },
    "modules/distribution-analysis/vendor/modules/chart_harness/period_label_policy.py": {
      "sha256": "e03d299651e00918a803e39c135eaeeeda9d972b77336fc8032daf7a068d946b",
      "size": 10567
    },
    "modules/distribution-analysis/vendor/modules/chart_harness/recipe_filters.py": {
      "sha256": "7a5bf6afab4cada57bb7093b517351c2ebeeb586c1524ae4b5a0d265fdc26792",
      "size": 13543
    },
    "modules/distribution-analysis/vendor/modules/chart_harness/reporting_titles.py": {
      "sha256": "b60bd2d5d20ed1f05fb1ce41c2a6807b139fc147789b22dde516de72f5fd830f",
      "size": 15842
    },
    "modules/distribution-analysis/vendor/modules/charting/__init__.py": {
      "sha256": "23163594f883b6262202001df66075390e9e30e23df2a858cff3b9b116d841e6",
      "size": 620
    },
    "modules/distribution-analysis/vendor/modules/charting/adjust_position.py": {
      "sha256": "aa92efb668a3f805b6a00759d6f933886c0d881d63a7a4c38247b90775707bc5",
      "size": 24574
    },
    "modules/distribution-analysis/vendor/modules/charting/area_pipeline.py": {
      "sha256": "47c2b23ba566d76fe253aaa31d32f021827eb56a7005eb7191fa60cff7b5b40b",
      "size": 21316
    },
    "modules/distribution-analysis/vendor/modules/charting/bubble_pipeline.py": {
      "sha256": "f7367dc5809ef5bde6c31b58029c620bd50f582a243cfe90dd38b63df2f5e541",
      "size": 5782
    },
    "modules/distribution-analysis/vendor/modules/charting/chart_helpers.py": {
      "sha256": "3828d367f5ad4299a4b3e71c06c6517127ec4ffde171b82cf260b74b3567f686",
      "size": 48060
    },
    "modules/distribution-analysis/vendor/modules/charting/chart_primitives.py": {
      "sha256": "38a3ccbac651300f21aae8f8025870aae7bebfd04e28db9f7fd27d6c38e99bf4",
      "size": 94051
    },
    "modules/distribution-analysis/vendor/modules/charting/draw_bubble.py": {
      "sha256": "da11bef92f80038c86a80aa009835d6bb27d20323cc9c813b023546078aaab16",
      "size": 39099
    },
    "modules/distribution-analysis/vendor/modules/charting/draw_charts_utils.py": {
      "sha256": "dac0fd1fc0e7c43d997c37213cd62948a38f73bc291e86d0fd22bdf9e90fac0f",
      "size": 156824
    },
    "modules/distribution-analysis/vendor/modules/charting/draw_distribution.py": {
      "sha256": "fdb8b8308913e63563dbd8e629b56f0e17dbe43af4e60bfa2a13d583d8f9f474",
      "size": 16947
    },
    "modules/distribution-analysis/vendor/modules/charting/draw_multitier.py": {
      "sha256": "79bf120e05207e156ad2103e6be6756ca129352cc496acd8db7867542237d319",
      "size": 97915
    },
    "modules/distribution-analysis/vendor/modules/charting/draw_other_charts.py": {
      "sha256": "4a9a5f0cd900619047d1f923859decc99b16a5839b74ad4b896d0cd39b7b4e23",
      "size": 38354
    },
    "modules/distribution-analysis/vendor/modules/charting/draw_pareto.py": {
      "sha256": "318b897545148615807e122073e6247a9f31ad142c87921725ac8a09c1b5fd66",
      "size": 23834
    },
    "modules/distribution-analysis/vendor/modules/charting/draw_scatter.py": {
      "sha256": "b24d0b34245382c710f30a230fd7555c7b13b03a84645d5a9c5aa822f0182292",
      "size": 42871
    },
    "modules/distribution-analysis/vendor/modules/charting/draw_timeline.py": {
      "sha256": "0b812d1fd53ab4ce4baf40e5cd293fd9ee702838e1b8aef528ea39e6289d6dfe",
      "size": 34282
    },
    "modules/distribution-analysis/vendor/modules/charting/draw_venn_upset.py": {
      "sha256": "9f87901443c040780033b340bdc7f581d9e79b3dc3f871ff607ba7f23662ad69",
      "size": 9244
    },
    "modules/distribution-analysis/vendor/modules/charting/draw_waterfall.py": {
      "sha256": "2e4e39337e67efa4f5398b39fda99a096d8453ee7e68fb455f50039b5f2f567e",
      "size": 44354
    },
    "modules/distribution-analysis/vendor/modules/charting/draw_width_and_stacked_plots.py": {
      "sha256": "0ff2a1f0492c01e86176157fa8f2974a434b8dfd3e0de2af5672c091189e211e",
      "size": 115738
    },
    "modules/distribution-analysis/vendor/modules/charting/legacy_draw_waterfall.py": {
      "sha256": "6a14e69341f1b1e37bb65fc0b090bfac72ac1951e05a0611507deb739a98ce14",
      "size": 44022
    },
    "modules/distribution-analysis/vendor/modules/charting/logic.py": {
      "sha256": "e616f6d339939ffe2131f7eb9cdc5d05d97a144a9ea1114aacd36a6e60a84e08",
      "size": 881
    },
    "modules/distribution-analysis/vendor/modules/charting/make_titles.py": {
      "sha256": "338445e55ea08d31a0a153a4737171a175ae6b56306add64ffae82d10558dfde",
      "size": 45352
    },
    "modules/distribution-analysis/vendor/modules/charting/mekko_pipeline.py": {
      "sha256": "d7229676db87f714c77d02df808256e7a835e01c771ac1452c3076722028a62d",
      "size": 41054
    },
    "modules/distribution-analysis/vendor/modules/charting/palettes.py": {
      "sha256": "a6ad512a80dff49c70c7b3c44aa7c8b160f9b1a1bf7b7c6d81e3bd45c88beb89",
      "size": 51874
    },
    "modules/distribution-analysis/vendor/modules/charting/plot_charts.py": {
      "sha256": "5468db22b976f4eeb76b23bc83e9ae994fb2cc861dc19ce584ebaec8f47fedb4",
      "size": 143629
    },
    "modules/distribution-analysis/vendor/modules/charting/plot_horizontal_bar.py": {
      "sha256": "7c407e19d49ff436220e465bdf0e20107ef421a7cc0e8497abe6bfe04eb821c8",
      "size": 1241
    },
    "modules/distribution-analysis/vendor/modules/charting/plotting_utilities.py": {
      "sha256": "62a9e8e68fb02c56949b7e3b67822242fdbca5eb4ad5d05aa39f0b8fe51beb06",
      "size": 45111
    },
    "modules/distribution-analysis/vendor/modules/charting/polars_helpers.py": {
      "sha256": "b0ba28065a01feaa1e0ca5230a1127b847dbd6cac2cacf321825fc4e423a3ab2",
      "size": 7601
    },
    "modules/distribution-analysis/vendor/modules/charting/prepare_charts.py": {
      "sha256": "3421d495f5aabcaffd20572285bc5b8e97bcd3ffe22c15f30ee68a91818984d6",
      "size": 36776
    },
    "modules/distribution-analysis/vendor/modules/charting/run_charting.py": {
      "sha256": "cffeddeed5f075773d58b7947b1365f4acd8f91f8f7f0f5ddc5ce87811ea5ea4",
      "size": 28749
    },
    "modules/distribution-analysis/vendor/modules/charting/scatter_pipeline.py": {
      "sha256": "da9560c49177b5d8954e82fc8340bd45ab6ae8fb19349f830fdb43cab3e0479a",
      "size": 4831
    },
    "modules/distribution-analysis/vendor/modules/charting/setup_fig.py": {
      "sha256": "c4c72ad57df1cc5bda6b71d2cab4aaa9e4128741da4c01c655b5b68b97e99f02",
      "size": 26104
    },
    "modules/distribution-analysis/vendor/modules/charting/small_multiples_ordering.py": {
      "sha256": "bd90f35e9fbb8eb5f3ef25a2ee743a4acc0ecda48781435e0522b2b382a6b816",
      "size": 2523
    },
    "modules/distribution-analysis/vendor/modules/charting/stacked_column_pipeline.py": {
      "sha256": "a0bd93e94ec98e8f1a2484e9df813f3154c8117ffb6c6fc3b158922c6b04b66d",
      "size": 27156
    },
    "modules/distribution-analysis/vendor/modules/charting/static_export.py": {
      "sha256": "dfe6d915a5b171d018d58472764c9e9431eb6d567093eefea2872e04138bd6d6",
      "size": 1131
    },
    "modules/distribution-analysis/vendor/modules/charting/update_layouts.py": {
      "sha256": "05f81b40ed4298d07c51d9465576ebc1b6b4a53689f99319501fe89390cf64c9",
      "size": 60908
    },
    "modules/distribution-analysis/vendor/modules/charting/upset_helpers.py": {
      "sha256": "c7ef21bbe353280653a5983f5a972a6f406aecbd5a7c024b0bec2a7088447b3f",
      "size": 362
    },
    "modules/distribution-analysis/vendor/modules/charting/upset_plot.py": {
      "sha256": "494ae1d6c14de66e730ff7d4685a2e0638b7f715895aa82e89899cd930c64fb0",
      "size": 9905
    },
    "modules/distribution-analysis/vendor/modules/data/__init__.py": {
      "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
      "size": 1
    },
    "modules/distribution-analysis/vendor/modules/data/cohort_processing.py": {
      "sha256": "c400326ca69007552cd5a23ef5e483b28d3362b4886e859528d32017456d3b91",
      "size": 16284
    },
    "modules/distribution-analysis/vendor/modules/data/common_data_utils.py": {
      "sha256": "6d1da1d46c3194f2531a4a016e6983663be68ef681c35c14d6f87c08a4b014da",
      "size": 132890
    },
    "modules/distribution-analysis/vendor/modules/data/data_cleaning.py": {
      "sha256": "65c0b486a2c44d7bdef6f5893591313a800c86e103ab7b7d564717aadd7a3b01",
      "size": 33497
    },
    "modules/distribution-analysis/vendor/modules/data/identify_columns.py": {
      "sha256": "99503c3b78f9292a3886c0dce06763f114b4014552f062fd1f244328fe35b6ad",
      "size": 110631
    },
    "modules/distribution-analysis/vendor/modules/data/merge_data.py": {
      "sha256": "2e6db2448e376169026e2f3771ebe7a09fda2de3b28ed3278faf38a4978693da",
      "size": 7151
    },
    "modules/distribution-analysis/vendor/modules/data/misc_charts_data_prep.py": {
      "sha256": "e93f9b58864160fcacd11d2bf68ddf2f2363d412a496a9b4583ef962f50ca30d",
      "size": 38571
    },
    "modules/distribution-analysis/vendor/modules/data/multidimensional_charts_prep.py": {
      "sha256": "59a572198611659b84d3a338e8e0b9f581b9a339202ebd1a6bdea579c07d98e6",
      "size": 76808
    },
    "modules/distribution-analysis/vendor/modules/data/time_series_data_prep.py": {
      "sha256": "6f9fdbfdfc1efef268f14f443b3fbe516661782fa96adfca73a2d64525af36be",
      "size": 4425
    },
    "modules/distribution-analysis/vendor/modules/data/waterfall_data_prep.py": {
      "sha256": "f78b45dc9ec4073c7f27d864bf790e1572dce80bce3f6d1b45c96dd94c4abd27",
      "size": 55834
    },
    "modules/distribution-analysis/vendor/modules/layout/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/distribution-analysis/vendor/modules/layout/core/ui_adapter.py": {
      "sha256": "76b429c2939fe46aea274d84d3100d74ce491b4efef77f5daed0c88a943d3182",
      "size": 3870
    },
    "modules/distribution-analysis/vendor/modules/layout/core/widget_state.py": {
      "sha256": "981c40c7692385a2759846de4c95e98e2d9966ac956e33dce4346d62047c1538",
      "size": 3426
    },
    "modules/distribution-analysis/vendor/modules/layout/layout_data.py": {
      "sha256": "87cf31d1387ad2d7845aa9ecc212feae1bfc6206cc50db9b67b8b72d63574523",
      "size": 2064
    },
    "modules/distribution-analysis/vendor/modules/layout/layout_helpers.py": {
      "sha256": "62b1dae0b4881d9194d4cd10e339417a161b159b76d78d8bde0b1d3efd13c3a4",
      "size": 31815
    },
    "modules/distribution-analysis/vendor/modules/layout/memoization.py": {
      "sha256": "ead4a46d07b43ea84aba55fe0555ee41408e2ba142c0557f0f8d1be91e931ba3",
      "size": 13439
    },
    "modules/distribution-analysis/vendor/modules/layout/performance.py": {
      "sha256": "4996b586dff3692252ec885e66d36a7327070c781c680f41dc5489c171531616",
      "size": 930
    },
    "modules/distribution-analysis/vendor/modules/layout/session_manager.py": {
      "sha256": "2e2d8bcc45065741009c314209239be57270455203d22176784dd084e49910f4",
      "size": 1105
    },
    "modules/distribution-analysis/vendor/modules/layout/set_up_widgets.py": {
      "sha256": "d12359ef6f67d0be4908a5e849a89935e6aee580897442609f8f71a29d78a5e5",
      "size": 761
    },
    "modules/distribution-analysis/vendor/modules/layout/widgets.py": {
      "sha256": "a4c5d79b664bc303080e083850ac0941ce66a0527e9e5858fec66e21aef0f6c0",
      "size": 923
    },
    "modules/distribution-analysis/vendor/modules/llm/__init__.py": {
      "sha256": "e416198937f477b64f1d2857ae2c442ae0fd5142def500be486a160c2a3d5340",
      "size": 51
    },
    "modules/distribution-analysis/vendor/modules/llm/confirm_plots.py": {
      "sha256": "8d14b250f446893c6266d689f26a40ed8c275ab96fcd2b474a49cd6b60e6bacb",
      "size": 693
    },
    "modules/distribution-analysis/vendor/modules/llm/interpret_plots.py": {
      "sha256": "2a594115f304474e9f55308ab91563645bcfe3b14f24cca416c001d5f45bab68",
      "size": 628
    },
    "modules/distribution-analysis/vendor/modules/llm/prompt_helpers.py": {
      "sha256": "f15b08a346138fc64b662d53905d369a00069ae5c67aa51575371b0915d4006e",
      "size": 498
    },
    "modules/distribution-analysis/vendor/modules/plan/__init__.py": {
      "sha256": "8ca432b4acd188c61581e22655212589661f36359f6f409ea6b9faca4c018a20",
      "size": 72
    },
    "modules/distribution-analysis/vendor/modules/plan/plan_dataset.py": {
      "sha256": "e7827dcf76ea64047d30bd1831745e219719c0bfcb76c0d588715322fed69fe3",
      "size": 601
    },
    "modules/distribution-analysis/vendor/modules/utilities/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/distribution-analysis/vendor/modules/utilities/config.py": {
      "sha256": "b4e7c75e766a2619ab768d2e79e8934b3238083bcfd260fc2a7375b3198aeef1",
      "size": 233980
    },
    "modules/distribution-analysis/vendor/modules/utilities/date_utils.py": {
      "sha256": "ddb2041be93ed08476f4a6c5fad67d6d59d94076cfc20d14c2d89a28b04aaba3",
      "size": 1930
    },
    "modules/distribution-analysis/vendor/modules/utilities/error_messages.py": {
      "sha256": "87828173f92a862ef37a88181d813ed39a3c1255ff2a6e5ab4a6d6d63d926315",
      "size": 19248
    },
    "modules/distribution-analysis/vendor/modules/utilities/helpers.py": {
      "sha256": "43c2c6083ad0635ab84664c7c6c8402780363aa718ea239e694785cf98ce29f7",
      "size": 105016
    },
    "modules/distribution-analysis/vendor/modules/utilities/logging_utils.py": {
      "sha256": "e78581502d65120f8a76560769a460702817206fbaf6226f95fdac94eb8e3f84",
      "size": 2551
    },
    "modules/distribution-analysis/vendor/modules/utilities/notifier.py": {
      "sha256": "5bcd244b4d319381b9cf67e8f1d6d7a9764891c32fd589801dd1ae5d98846b08",
      "size": 1020
    },
    "modules/distribution-analysis/vendor/modules/utilities/session_context.py": {
      "sha256": "93399e3e3c8ae812269304f6c3d5325f524baf3f8ce25835391108d158445b3c",
      "size": 8820
    },
    "modules/distribution-analysis/vendor/modules/utilities/ui_notifier.py": {
      "sha256": "918c62f85ff5ddd16337c608d8325b68a356573c54492ac0607a5316b09239cf",
      "size": 7212
    },
    "modules/distribution-analysis/vendor/modules/utilities/utils.py": {
      "sha256": "e8a7d350a40c9eedd864771c0327b6f1ddac4b40d434c96cbc778df849788b58",
      "size": 11296
    },
    "modules/distribution-analysis/vendor/modules/utils/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/distribution-analysis/vendor/modules/utils/polars_excel_writer.py": {
      "sha256": "c70e202ca92489ee3411bddfa266a786c6838b6b7a9b512c80212f07c737def4",
      "size": 2688
    },
    "modules/distribution-analysis/vendor/modules/variance/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/distribution-analysis/vendor/modules/variance/index_handling.py": {
      "sha256": "d7e578c8dd5cf2a008469d6aee132ca19d0fc416c19761f9f9af4cf9a61ac449",
      "size": 76257
    },
    "modules/distribution-analysis/vendor/modules/variance/variance_decomposition.py": {
      "sha256": "769cbf8b2096398fa1d9df6ad045f26085b3b0e331cc71f77d2ddde3ded373fe",
      "size": 60557
    },
    "modules/distribution-analysis/vendor/modules/variance/variance_formulas.py": {
      "sha256": "af95c36e55a861585a1e8e59b2a247f2b1a11cdc747c5a9d561a63b0a7f3e947",
      "size": 92461
    },
    "modules/distribution-analysis/vendor/modules/variance/variance_orchestrator.py": {
      "sha256": "5a1176d5a5ed9a4e97b1d7bd953de68f57a7fde2170480fbd4dfffa5bd92b5c9",
      "size": 83371
    },
    "modules/distribution-analysis/vendor/modules/variance/variance_utils.py": {
      "sha256": "60b50dd739ff11f1d1b098fcc3c340974ed0825033df0a204fa54980fc6667cf",
      "size": 51623
    },
    "modules/funnel-analysis/.codex-plugin/plugin.json": {
      "sha256": "e8b31027d2a6fbaffadcd760579501996fb7cf26c0c54cccda0325bd14a48649",
      "size": 1828
    },
    "modules/funnel-analysis/README.md": {
      "sha256": "a07d2976601beb9e75f5e8373139cf2737cb717e6bb1c849a5fe070043edda7c",
      "size": 547
    },
    "modules/funnel-analysis/assets/icon.svg": {
      "sha256": "3c528c545f2c1a9bb6510fea8ad5454561adb740e0041580b273b42be862ca91",
      "size": 706
    },
    "modules/funnel-analysis/evals/trigger_fixtures.json": {
      "sha256": "a45d42b87dfa52e08003f2397bd6c1676e6a8dd6928320dda9315ff6eed19a07",
      "size": 978
    },
    "modules/funnel-analysis/requirements.txt": {
      "sha256": "df9f2fabe756b2206d3f6e2b6f99d6cc7381a51c497a4e5a13abcd978fad40c2",
      "size": 40
    },
    "modules/funnel-analysis/scripts/check_dependencies.py": {
      "sha256": "fb07cb441aa91c50cef407e58fdd866f9d567f40b9417689edca486136993b04",
      "size": 4206
    },
    "modules/funnel-analysis/scripts/funnel_core.py": {
      "sha256": "970b4664ca91d9382a314499287cf71db574c7bf226fc6dc3323cd97f32fce5d",
      "size": 29465
    },
    "modules/funnel-analysis/scripts/run_funnel_analysis.py": {
      "sha256": "8b315f87ec629bbd66d483736f13209dcec3e9e16d7de82388bc50e96c36a977",
      "size": 1414
    },
    "modules/funnel-analysis/skills/funnel-analysis/SKILL.md": {
      "sha256": "123307632c952defbb102e3bc653d001637624c8519f267c60bdfd159190758c",
      "size": 5613
    },
    "modules/management-control-pack/.codex-plugin/plugin.json": {
      "sha256": "9728c5f22f8b208a96515e64f460e203cc4606822f28496d8d3dfebb13528430",
      "size": 2533
    },
    "modules/management-control-pack/assets/budget-report.css": {
      "sha256": "708ebf8bc1867002287453273982e1e709a8979bce7935027196559485415bce",
      "size": 999
    },
    "modules/management-control-pack/assets/budget-report.js": {
      "sha256": "290f329589411bd18c956ef9d9f908a785cc6775e0e66049063519fc5e6c559b",
      "size": 836
    },
    "modules/management-control-pack/assets/icon.svg": {
      "sha256": "8242353d7b5b73e94c302432ec362ea06a36a7acd1682e6b84c9d67bd292ae96",
      "size": 780
    },
    "modules/management-control-pack/assets/management-report-copy.json": {
      "sha256": "1214b0fd2646a5a13db85ccebf1ef233f0cb2cb1f8ce3daf28cb681f4244db94",
      "size": 45270
    },
    "modules/management-control-pack/evals/trigger_fixtures.json": {
      "sha256": "8c3cd34abc56eddeb611c39c582c0ac3b1c0f1c07b5c75952517c2e88cc79b94",
      "size": 1036
    },
    "modules/management-control-pack/references/costing.md": {
      "sha256": "32c07ec98dcb04d9393285c441e3eb1abe926ca5a9baa5a4e0a66e83c026dee2",
      "size": 10183
    },
    "modules/management-control-pack/requirements.txt": {
      "sha256": "9bba605fd7b6ea23038de15e5a1ae6714b3d3fb14ed2d6e6bedbfb0665ca2122",
      "size": 17
    },
    "modules/management-control-pack/scripts/budget_presentation.py": {
      "sha256": "f28a72487e3c7e726ffc98ee995309d6446469d07feb04ea42b9eb3761e1378d",
      "size": 6629
    },
    "modules/management-control-pack/scripts/check_dependencies.py": {
      "sha256": "edbc9f16d57800b1110eb94c9c6d68d94e2713bd2da7120cb5c8bc33186e17a5",
      "size": 1782
    },
    "modules/management-control-pack/scripts/costing_core.py": {
      "sha256": "4bfdc57844dad015bd4506ece3d322a1f25fecff1a57f04fbe4d1fe56d1fa6eb",
      "size": 20298
    },
    "modules/management-control-pack/scripts/costing_pack.py": {
      "sha256": "8d83ea5cf28a22a0f08aaf427a7022452a92a92b045cbd4765f9cea51cc9f9d2",
      "size": 10382
    },
    "modules/management-control-pack/scripts/costing_report.py": {
      "sha256": "5163f73c6e780b5923e4304140530defd05c82725fbc1b3fd67c630b1a93161d",
      "size": 15423
    },
    "modules/management-control-pack/scripts/finalize_pack.py": {
      "sha256": "acd51df1fc944ca307527d3509c2641f75ba9746963bd780c8c991562e70fb63",
      "size": 3357
    },
    "modules/management-control-pack/scripts/inspect_inputs.py": {
      "sha256": "cfbd14235a96796befa1170918bf2cd8bf230a04c4c2015012d07de7083e3e62",
      "size": 2401
    },
    "modules/management-control-pack/scripts/management_control_core.py": {
      "sha256": "6014b9222498ea75fdacdbaa4baca0188b7f1faf383e80de588a7ce51df4c088",
      "size": 97843
    },
    "modules/management-control-pack/scripts/management_delivery.py": {
      "sha256": "4f0defc123841a3ed85d69b5dbdb7ea360363a7ef32aba0dac174bce707ce6ef",
      "size": 4505
    },
    "modules/management-control-pack/scripts/management_report_copy.py": {
      "sha256": "4d972ac51f9d101f954fa4b3aaff645747fa51b7bef9fac4e88fb44a678c7e63",
      "size": 1415
    },
    "modules/management-control-pack/scripts/management_site.py": {
      "sha256": "5001e888310f865a2d226770a3c1438e4d0f5fdd90f5c4f157a876d9c9828f81",
      "size": 2717
    },
    "modules/management-control-pack/scripts/prepare_report_site.py": {
      "sha256": "81b222612685768843dc76d914b59b0df2a58dbe0abbf41185ccd550cbabbbb1",
      "size": 3366
    },
    "modules/management-control-pack/scripts/report_preview.py": {
      "sha256": "fbe325749fe1377222d571666b90e5c40cdf3bf66d111b68bea46b3384518cf7",
      "size": 2494
    },
    "modules/management-control-pack/scripts/run_costing.py": {
      "sha256": "d41bd9be497e090d2fc8e057e44d79f115fcce17e610d3d54e76a6fec75ae303",
      "size": 3774
    },
    "modules/management-control-pack/scripts/run_pack.py": {
      "sha256": "52e3e8deb4c2236261c6b00384ced92b0dc00eaf33a2d242726c4b404ab09ac4",
      "size": 2443
    },
    "modules/management-control-pack/skills/management-control-pack/SKILL.md": {
      "sha256": "98203ff2637c939093c705eb50203e3d427e732a898b47407b5d2e1de20aa602",
      "size": 14496
    },
    "modules/management-control-pack/skills/management-control-pack/references/sites-delivery.md": {
      "sha256": "bd4dd0328b0f8b2f7bb5e244c50ff6ef66664934416894e4d453d071177d92e8",
      "size": 2517
    },
    "modules/management-control-pack/vendor/modules/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/management-control-pack/vendor/modules/reporting_table.py": {
      "sha256": "99b687b83f4ce62fb2a33c875cf5740edb0854e9a7b094f1c314b1b6198adc1e",
      "size": 17079
    },
    "modules/management-control-pack/vendor/modules/vera_assurance/__init__.py": {
      "sha256": "e7c525a93ec80ec01a6134527f33a17d07f61cccafd90b33d26bdb96d8e1281f",
      "size": 2710
    },
    "modules/management-control-pack/vendor/modules/vera_assurance/contracts.py": {
      "sha256": "8203378c30262e1dfc568099a34a444cb33130343abf17d4a2eea8da107d7cb0",
      "size": 93104
    },
    "modules/management-control-pack/vendor/modules/vera_assurance/decisions.py": {
      "sha256": "28b62f4932997aa50d4d5b099383823096c203a035f1fdbb94ec97b0ce7fe63b",
      "size": 6397
    },
    "modules/management-control-pack/vendor/modules/vera_assurance/envelope.py": {
      "sha256": "80f9b005b190a2607ab3a12ad9c508174c8de100d7b9752f87644c62db070358",
      "size": 18987
    },
    "modules/management-control-pack/vendor/modules/vera_assurance/jurisdiction.py": {
      "sha256": "9bbf63c917cad41f2d2f516c7400b092d1a5a020e8e6e83831fbacc31968ebf1",
      "size": 7887
    },
    "modules/management-control-pack/vendor/modules/vera_assurance/money.py": {
      "sha256": "a2064acd368ae921fc37156e88711ed9afef4c7b8de7a374be552fa644a52431",
      "size": 10967
    },
    "modules/management-control-pack/vendor/modules/vera_assurance/recovery.py": {
      "sha256": "fbc5402144b405057deb92005580923f7b2ab67cfd439fe2af977a49f96f1715",
      "size": 21592
    },
    "modules/management-control-pack/vendor/modules/vera_assurance/relationships.py": {
      "sha256": "bfadd997d33e764f414e55d967933a7745ba0a9032df21addf8fed076400a085",
      "size": 15349
    },
    "modules/management-control-pack/vendor/modules/vera_assurance/review_output_transaction.cjs": {
      "sha256": "63075c6c3b0eff1d3a6706aa59d0dd1e00c558f9a4b51dcf952e881caccfa348",
      "size": 41618
    },
    "modules/management-control-pack/vendor/modules/vera_assurance/serialization.py": {
      "sha256": "8fdbb590830d8a41b6bb3271ceb0abf9874237d0151028b994b9e5521077141f",
      "size": 11043
    },
    "modules/mix-contribution-analysis/.codex-plugin/plugin.json": {
      "sha256": "9ddbcf93e085483d530b5b4d7c1097e9e2a7eeb2dc2cb79e3544dea8f105fa90",
      "size": 2407
    },
    "modules/mix-contribution-analysis/README.md": {
      "sha256": "4833ad89d60437848945aade01fa39e5bc1eb2799d6bca1618b32faf397359ff",
      "size": 2105
    },
    "modules/mix-contribution-analysis/assets/icon.svg": {
      "sha256": "49c8e9ec27ffc80d7606f8b5f23c60967669e561b8a0c19cf0c587c287862289",
      "size": 772
    },
    "modules/mix-contribution-analysis/evals/trigger_fixtures.json": {
      "sha256": "7726024e3aa346a84d2cafcafea557306abfb0fedf34fac53d3beb82c0730735",
      "size": 1128
    },
    "modules/mix-contribution-analysis/mcp/server.cjs": {
      "sha256": "0d5e84940e4fb285d4ef62565b02da0b2d6950c089e0701ebf04a92aea04eb93",
      "size": 66062
    },
    "modules/mix-contribution-analysis/references/legacy_inventory.json": {
      "sha256": "738dab5fd7fcb2a72b9e951174079db2ed031d0baaed89cd2ddb4435fe1ddc85",
      "size": 2524
    },
    "modules/mix-contribution-analysis/requirements.txt": {
      "sha256": "b4fdaff17d8edfeace9bca4b5601bcde6ceddb7c21e660e0f812281fa240a799",
      "size": 98
    },
    "modules/mix-contribution-analysis/scripts/check_dependencies.py": {
      "sha256": "744d438a2804e811d983be0b40b1274ab8efd3f48b97127629983f8211dddfec",
      "size": 4057
    },
    "modules/mix-contribution-analysis/scripts/inspect_inputs.py": {
      "sha256": "b6c055cedbe913bf0a49ad02603acd78a1265577a52a54faed9a67459ca59a1e",
      "size": 1475
    },
    "modules/mix-contribution-analysis/scripts/legacy_mix_charting.py": {
      "sha256": "52d2aa4815cd8a22898480f7d5ed357e1677e93750655be4f8e09127b146084a",
      "size": 281903
    },
    "modules/mix-contribution-analysis/scripts/mix_core.py": {
      "sha256": "475031f5f5c47ff83c37657a8b29781cfc47461b0c4873118e09560505828357",
      "size": 139473
    },
    "modules/mix-contribution-analysis/scripts/review_session.py": {
      "sha256": "589fe6a07bba0e67ce1c89f1ac07f3706bb78656fcfff6eaf98456070786af5d",
      "size": 21603
    },
    "modules/mix-contribution-analysis/scripts/run_mix_contribution.py": {
      "sha256": "64bd3244ca84e42e718a8740c2c8f1bd8627655b2871d889ca056e574fa41ce9",
      "size": 1589
    },
    "modules/mix-contribution-analysis/skills/mix-contribution-analysis/SKILL.md": {
      "sha256": "f6a59d03e4914d2598bfa5eb9f693d2e52f4a311b0e746b976adb7462d8d30cf",
      "size": 9247
    },
    "modules/mix-contribution-analysis/vendor/modules/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/mix-contribution-analysis/vendor/modules/auth/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/mix-contribution-analysis/vendor/modules/auth/config.py": {
      "sha256": "7e95dfe02a16f254346f49ae981890d5641ca11fa6c32e1ba92269c6e04327a9",
      "size": 4441
    },
    "modules/mix-contribution-analysis/vendor/modules/auth/google_identity.py": {
      "sha256": "bc33a5cacf88ab073c72171640c7067429c6884927ab1628f5fece503262dd9e",
      "size": 5521
    },
    "modules/mix-contribution-analysis/vendor/modules/auth/session.py": {
      "sha256": "554cb2902d1ad2ee3ce232dd5c06422cd23232d0995489e18c25be61778ae42b",
      "size": 3849
    },
    "modules/mix-contribution-analysis/vendor/modules/chart_harness/__init__.py": {
      "sha256": "64040e09b08b176a94cee3a65971c649479d7bc2d47a7a48c0fed0bf00c65dc5",
      "size": 4699
    },
    "modules/mix-contribution-analysis/vendor/modules/chart_harness/analysis_context.py": {
      "sha256": "b1a530fffe1f9ae963950e779dd409920d94a168289f3faafef6cc93c8c2985e",
      "size": 10800
    },
    "modules/mix-contribution-analysis/vendor/modules/chart_harness/artifacts.py": {
      "sha256": "190476ae688368778b08804e049244e595461edb7206f3525a0a1baec1f5b5e6",
      "size": 22039
    },
    "modules/mix-contribution-analysis/vendor/modules/chart_harness/date_parsing.py": {
      "sha256": "175f17c295b0029db1bb895876aaa4f66d9a3e19b924cfffbbf22af42879a087",
      "size": 1104
    },
    "modules/mix-contribution-analysis/vendor/modules/chart_harness/metric_semantics.py": {
      "sha256": "10849cdef532699ff323233f4f699eddee7fba7836075984199657c5c8d41f5a",
      "size": 12757
    },
    "modules/mix-contribution-analysis/vendor/modules/chart_harness/period_contract.py": {
      "sha256": "1d04dd1a23808ecda086a53f3d76a492a2600c2b58917a63cd272a0b330e1384",
      "size": 11110
    },
    "modules/mix-contribution-analysis/vendor/modules/chart_harness/period_derivations.py": {
      "sha256": "dfbe2252a94f7a264c1431a82fcf6cedd664756496399ad3090d9ee05c7fe614",
      "size": 30445
    },
    "modules/mix-contribution-analysis/vendor/modules/chart_harness/period_label_policy.py": {
      "sha256": "e03d299651e00918a803e39c135eaeeeda9d972b77336fc8032daf7a068d946b",
      "size": 10567
    },
    "modules/mix-contribution-analysis/vendor/modules/chart_harness/recipe_filters.py": {
      "sha256": "7a5bf6afab4cada57bb7093b517351c2ebeeb586c1524ae4b5a0d265fdc26792",
      "size": 13543
    },
    "modules/mix-contribution-analysis/vendor/modules/chart_harness/reporting_titles.py": {
      "sha256": "b60bd2d5d20ed1f05fb1ce41c2a6807b139fc147789b22dde516de72f5fd830f",
      "size": 15842
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/__init__.py": {
      "sha256": "23163594f883b6262202001df66075390e9e30e23df2a858cff3b9b116d841e6",
      "size": 620
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/adjust_position.py": {
      "sha256": "aa92efb668a3f805b6a00759d6f933886c0d881d63a7a4c38247b90775707bc5",
      "size": 24574
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/area_pipeline.py": {
      "sha256": "47c2b23ba566d76fe253aaa31d32f021827eb56a7005eb7191fa60cff7b5b40b",
      "size": 21316
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/bubble_pipeline.py": {
      "sha256": "f7367dc5809ef5bde6c31b58029c620bd50f582a243cfe90dd38b63df2f5e541",
      "size": 5782
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/chart_helpers.py": {
      "sha256": "3828d367f5ad4299a4b3e71c06c6517127ec4ffde171b82cf260b74b3567f686",
      "size": 48060
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/chart_primitives.py": {
      "sha256": "38a3ccbac651300f21aae8f8025870aae7bebfd04e28db9f7fd27d6c38e99bf4",
      "size": 94051
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/draw_bubble.py": {
      "sha256": "da11bef92f80038c86a80aa009835d6bb27d20323cc9c813b023546078aaab16",
      "size": 39099
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/draw_charts_utils.py": {
      "sha256": "dac0fd1fc0e7c43d997c37213cd62948a38f73bc291e86d0fd22bdf9e90fac0f",
      "size": 156824
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/draw_distribution.py": {
      "sha256": "fdb8b8308913e63563dbd8e629b56f0e17dbe43af4e60bfa2a13d583d8f9f474",
      "size": 16947
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/draw_multitier.py": {
      "sha256": "79bf120e05207e156ad2103e6be6756ca129352cc496acd8db7867542237d319",
      "size": 97915
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/draw_other_charts.py": {
      "sha256": "4a9a5f0cd900619047d1f923859decc99b16a5839b74ad4b896d0cd39b7b4e23",
      "size": 38354
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/draw_pareto.py": {
      "sha256": "318b897545148615807e122073e6247a9f31ad142c87921725ac8a09c1b5fd66",
      "size": 23834
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/draw_scatter.py": {
      "sha256": "b24d0b34245382c710f30a230fd7555c7b13b03a84645d5a9c5aa822f0182292",
      "size": 42871
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/draw_timeline.py": {
      "sha256": "0b812d1fd53ab4ce4baf40e5cd293fd9ee702838e1b8aef528ea39e6289d6dfe",
      "size": 34282
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/draw_venn_upset.py": {
      "sha256": "9f87901443c040780033b340bdc7f581d9e79b3dc3f871ff607ba7f23662ad69",
      "size": 9244
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/draw_waterfall.py": {
      "sha256": "2e4e39337e67efa4f5398b39fda99a096d8453ee7e68fb455f50039b5f2f567e",
      "size": 44354
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/draw_width_and_stacked_plots.py": {
      "sha256": "0ff2a1f0492c01e86176157fa8f2974a434b8dfd3e0de2af5672c091189e211e",
      "size": 115738
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/legacy_draw_waterfall.py": {
      "sha256": "6a14e69341f1b1e37bb65fc0b090bfac72ac1951e05a0611507deb739a98ce14",
      "size": 44022
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/logic.py": {
      "sha256": "e616f6d339939ffe2131f7eb9cdc5d05d97a144a9ea1114aacd36a6e60a84e08",
      "size": 881
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/make_titles.py": {
      "sha256": "338445e55ea08d31a0a153a4737171a175ae6b56306add64ffae82d10558dfde",
      "size": 45352
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/mekko_pipeline.py": {
      "sha256": "d7229676db87f714c77d02df808256e7a835e01c771ac1452c3076722028a62d",
      "size": 41054
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/palettes.py": {
      "sha256": "a6ad512a80dff49c70c7b3c44aa7c8b160f9b1a1bf7b7c6d81e3bd45c88beb89",
      "size": 51874
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/plot_charts.py": {
      "sha256": "5468db22b976f4eeb76b23bc83e9ae994fb2cc861dc19ce584ebaec8f47fedb4",
      "size": 143629
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/plot_horizontal_bar.py": {
      "sha256": "7c407e19d49ff436220e465bdf0e20107ef421a7cc0e8497abe6bfe04eb821c8",
      "size": 1241
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/plotting_utilities.py": {
      "sha256": "62a9e8e68fb02c56949b7e3b67822242fdbca5eb4ad5d05aa39f0b8fe51beb06",
      "size": 45111
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/polars_helpers.py": {
      "sha256": "b0ba28065a01feaa1e0ca5230a1127b847dbd6cac2cacf321825fc4e423a3ab2",
      "size": 7601
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/prepare_charts.py": {
      "sha256": "3421d495f5aabcaffd20572285bc5b8e97bcd3ffe22c15f30ee68a91818984d6",
      "size": 36776
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/run_charting.py": {
      "sha256": "cffeddeed5f075773d58b7947b1365f4acd8f91f8f7f0f5ddc5ce87811ea5ea4",
      "size": 28749
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/scatter_pipeline.py": {
      "sha256": "da9560c49177b5d8954e82fc8340bd45ab6ae8fb19349f830fdb43cab3e0479a",
      "size": 4831
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/setup_fig.py": {
      "sha256": "c4c72ad57df1cc5bda6b71d2cab4aaa9e4128741da4c01c655b5b68b97e99f02",
      "size": 26104
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/small_multiples_ordering.py": {
      "sha256": "bd90f35e9fbb8eb5f3ef25a2ee743a4acc0ecda48781435e0522b2b382a6b816",
      "size": 2523
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/stacked_column_pipeline.py": {
      "sha256": "a0bd93e94ec98e8f1a2484e9df813f3154c8117ffb6c6fc3b158922c6b04b66d",
      "size": 27156
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/static_export.py": {
      "sha256": "dfe6d915a5b171d018d58472764c9e9431eb6d567093eefea2872e04138bd6d6",
      "size": 1131
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/update_layouts.py": {
      "sha256": "05f81b40ed4298d07c51d9465576ebc1b6b4a53689f99319501fe89390cf64c9",
      "size": 60908
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/upset_helpers.py": {
      "sha256": "c7ef21bbe353280653a5983f5a972a6f406aecbd5a7c024b0bec2a7088447b3f",
      "size": 362
    },
    "modules/mix-contribution-analysis/vendor/modules/charting/upset_plot.py": {
      "sha256": "494ae1d6c14de66e730ff7d4685a2e0638b7f715895aa82e89899cd930c64fb0",
      "size": 9905
    },
    "modules/mix-contribution-analysis/vendor/modules/data/__init__.py": {
      "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
      "size": 1
    },
    "modules/mix-contribution-analysis/vendor/modules/data/cohort_processing.py": {
      "sha256": "c400326ca69007552cd5a23ef5e483b28d3362b4886e859528d32017456d3b91",
      "size": 16284
    },
    "modules/mix-contribution-analysis/vendor/modules/data/common_data_utils.py": {
      "sha256": "6d1da1d46c3194f2531a4a016e6983663be68ef681c35c14d6f87c08a4b014da",
      "size": 132890
    },
    "modules/mix-contribution-analysis/vendor/modules/data/data_cleaning.py": {
      "sha256": "65c0b486a2c44d7bdef6f5893591313a800c86e103ab7b7d564717aadd7a3b01",
      "size": 33497
    },
    "modules/mix-contribution-analysis/vendor/modules/data/identify_columns.py": {
      "sha256": "99503c3b78f9292a3886c0dce06763f114b4014552f062fd1f244328fe35b6ad",
      "size": 110631
    },
    "modules/mix-contribution-analysis/vendor/modules/data/merge_data.py": {
      "sha256": "2e6db2448e376169026e2f3771ebe7a09fda2de3b28ed3278faf38a4978693da",
      "size": 7151
    },
    "modules/mix-contribution-analysis/vendor/modules/data/misc_charts_data_prep.py": {
      "sha256": "e93f9b58864160fcacd11d2bf68ddf2f2363d412a496a9b4583ef962f50ca30d",
      "size": 38571
    },
    "modules/mix-contribution-analysis/vendor/modules/data/multidimensional_charts_prep.py": {
      "sha256": "59a572198611659b84d3a338e8e0b9f581b9a339202ebd1a6bdea579c07d98e6",
      "size": 76808
    },
    "modules/mix-contribution-analysis/vendor/modules/data/time_series_data_prep.py": {
      "sha256": "6f9fdbfdfc1efef268f14f443b3fbe516661782fa96adfca73a2d64525af36be",
      "size": 4425
    },
    "modules/mix-contribution-analysis/vendor/modules/data/waterfall_data_prep.py": {
      "sha256": "f78b45dc9ec4073c7f27d864bf790e1572dce80bce3f6d1b45c96dd94c4abd27",
      "size": 55834
    },
    "modules/mix-contribution-analysis/vendor/modules/layout/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/mix-contribution-analysis/vendor/modules/layout/core/ui_adapter.py": {
      "sha256": "76b429c2939fe46aea274d84d3100d74ce491b4efef77f5daed0c88a943d3182",
      "size": 3870
    },
    "modules/mix-contribution-analysis/vendor/modules/layout/core/widget_state.py": {
      "sha256": "981c40c7692385a2759846de4c95e98e2d9966ac956e33dce4346d62047c1538",
      "size": 3426
    },
    "modules/mix-contribution-analysis/vendor/modules/layout/layout_data.py": {
      "sha256": "87cf31d1387ad2d7845aa9ecc212feae1bfc6206cc50db9b67b8b72d63574523",
      "size": 2064
    },
    "modules/mix-contribution-analysis/vendor/modules/layout/layout_helpers.py": {
      "sha256": "62b1dae0b4881d9194d4cd10e339417a161b159b76d78d8bde0b1d3efd13c3a4",
      "size": 31815
    },
    "modules/mix-contribution-analysis/vendor/modules/layout/memoization.py": {
      "sha256": "ead4a46d07b43ea84aba55fe0555ee41408e2ba142c0557f0f8d1be91e931ba3",
      "size": 13439
    },
    "modules/mix-contribution-analysis/vendor/modules/layout/performance.py": {
      "sha256": "4996b586dff3692252ec885e66d36a7327070c781c680f41dc5489c171531616",
      "size": 930
    },
    "modules/mix-contribution-analysis/vendor/modules/layout/session_manager.py": {
      "sha256": "2e2d8bcc45065741009c314209239be57270455203d22176784dd084e49910f4",
      "size": 1105
    },
    "modules/mix-contribution-analysis/vendor/modules/layout/set_up_widgets.py": {
      "sha256": "d12359ef6f67d0be4908a5e849a89935e6aee580897442609f8f71a29d78a5e5",
      "size": 761
    },
    "modules/mix-contribution-analysis/vendor/modules/layout/widgets.py": {
      "sha256": "a4c5d79b664bc303080e083850ac0941ce66a0527e9e5858fec66e21aef0f6c0",
      "size": 923
    },
    "modules/mix-contribution-analysis/vendor/modules/llm/__init__.py": {
      "sha256": "e416198937f477b64f1d2857ae2c442ae0fd5142def500be486a160c2a3d5340",
      "size": 51
    },
    "modules/mix-contribution-analysis/vendor/modules/llm/confirm_plots.py": {
      "sha256": "8d14b250f446893c6266d689f26a40ed8c275ab96fcd2b474a49cd6b60e6bacb",
      "size": 693
    },
    "modules/mix-contribution-analysis/vendor/modules/llm/interpret_plots.py": {
      "sha256": "2a594115f304474e9f55308ab91563645bcfe3b14f24cca416c001d5f45bab68",
      "size": 628
    },
    "modules/mix-contribution-analysis/vendor/modules/llm/prompt_helpers.py": {
      "sha256": "f15b08a346138fc64b662d53905d369a00069ae5c67aa51575371b0915d4006e",
      "size": 498
    },
    "modules/mix-contribution-analysis/vendor/modules/plan/__init__.py": {
      "sha256": "8ca432b4acd188c61581e22655212589661f36359f6f409ea6b9faca4c018a20",
      "size": 72
    },
    "modules/mix-contribution-analysis/vendor/modules/plan/plan_dataset.py": {
      "sha256": "e7827dcf76ea64047d30bd1831745e219719c0bfcb76c0d588715322fed69fe3",
      "size": 601
    },
    "modules/mix-contribution-analysis/vendor/modules/utilities/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/mix-contribution-analysis/vendor/modules/utilities/config.py": {
      "sha256": "b4e7c75e766a2619ab768d2e79e8934b3238083bcfd260fc2a7375b3198aeef1",
      "size": 233980
    },
    "modules/mix-contribution-analysis/vendor/modules/utilities/date_utils.py": {
      "sha256": "ddb2041be93ed08476f4a6c5fad67d6d59d94076cfc20d14c2d89a28b04aaba3",
      "size": 1930
    },
    "modules/mix-contribution-analysis/vendor/modules/utilities/error_messages.py": {
      "sha256": "87828173f92a862ef37a88181d813ed39a3c1255ff2a6e5ab4a6d6d63d926315",
      "size": 19248
    },
    "modules/mix-contribution-analysis/vendor/modules/utilities/helpers.py": {
      "sha256": "43c2c6083ad0635ab84664c7c6c8402780363aa718ea239e694785cf98ce29f7",
      "size": 105016
    },
    "modules/mix-contribution-analysis/vendor/modules/utilities/logging_utils.py": {
      "sha256": "e78581502d65120f8a76560769a460702817206fbaf6226f95fdac94eb8e3f84",
      "size": 2551
    },
    "modules/mix-contribution-analysis/vendor/modules/utilities/notifier.py": {
      "sha256": "5bcd244b4d319381b9cf67e8f1d6d7a9764891c32fd589801dd1ae5d98846b08",
      "size": 1020
    },
    "modules/mix-contribution-analysis/vendor/modules/utilities/session_context.py": {
      "sha256": "93399e3e3c8ae812269304f6c3d5325f524baf3f8ce25835391108d158445b3c",
      "size": 8820
    },
    "modules/mix-contribution-analysis/vendor/modules/utilities/ui_notifier.py": {
      "sha256": "918c62f85ff5ddd16337c608d8325b68a356573c54492ac0607a5316b09239cf",
      "size": 7212
    },
    "modules/mix-contribution-analysis/vendor/modules/utilities/utils.py": {
      "sha256": "e8a7d350a40c9eedd864771c0327b6f1ddac4b40d434c96cbc778df849788b58",
      "size": 11296
    },
    "modules/mix-contribution-analysis/vendor/modules/utils/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/mix-contribution-analysis/vendor/modules/utils/polars_excel_writer.py": {
      "sha256": "c70e202ca92489ee3411bddfa266a786c6838b6b7a9b512c80212f07c737def4",
      "size": 2688
    },
    "modules/mix-contribution-analysis/vendor/modules/variance/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/mix-contribution-analysis/vendor/modules/variance/index_handling.py": {
      "sha256": "d7e578c8dd5cf2a008469d6aee132ca19d0fc416c19761f9f9af4cf9a61ac449",
      "size": 76257
    },
    "modules/mix-contribution-analysis/vendor/modules/variance/variance_decomposition.py": {
      "sha256": "769cbf8b2096398fa1d9df6ad045f26085b3b0e331cc71f77d2ddde3ded373fe",
      "size": 60557
    },
    "modules/mix-contribution-analysis/vendor/modules/variance/variance_formulas.py": {
      "sha256": "af95c36e55a861585a1e8e59b2a247f2b1a11cdc747c5a9d561a63b0a7f3e947",
      "size": 92461
    },
    "modules/mix-contribution-analysis/vendor/modules/variance/variance_orchestrator.py": {
      "sha256": "5a1176d5a5ed9a4e97b1d7bd953de68f57a7fde2170480fbd4dfffa5bd92b5c9",
      "size": 83371
    },
    "modules/mix-contribution-analysis/vendor/modules/variance/variance_utils.py": {
      "sha256": "60b50dd739ff11f1d1b098fcc3c340974ed0825033df0a204fa54980fc6667cf",
      "size": 51623
    },
    "modules/period-comparison/.codex-plugin/plugin.json": {
      "sha256": "ca8bbb0ae738503a578dc7fdaa18657fd7e2bf3f204a38c27ce19d16ecb9e6d3",
      "size": 2227
    },
    "modules/period-comparison/README.md": {
      "sha256": "e2232ec7830a25285826dbd83a48ed1f6e07702c4076246a987e3f13713a35c9",
      "size": 3282
    },
    "modules/period-comparison/assets/icon.svg": {
      "sha256": "48ef17d28bea5644b1ba2963ee31b084c41307e3f451553fefc3809302133081",
      "size": 727
    },
    "modules/period-comparison/evals/trigger_fixtures.json": {
      "sha256": "d58870fb00562b83996b6bb02ca5ef2a2c8d22bf14241ce1f84a9578fff7f127",
      "size": 1163
    },
    "modules/period-comparison/mcp/server.cjs": {
      "sha256": "8a7e3d26e437be9d3e3c06a8d9e6fd96e14823dbfaefb6fad6426d90ee5328db",
      "size": 66111
    },
    "modules/period-comparison/references/legacy_inventory.json": {
      "sha256": "896e9c615464e9a7a1ec84763773a8ac7a28b0215fa8c5cc53dbeb11484ab02e",
      "size": 2136
    },
    "modules/period-comparison/requirements.txt": {
      "sha256": "faa585f0f884edc202fee8f266310fb5c0d69b996e40c72b5853acd7778f20b8",
      "size": 143
    },
    "modules/period-comparison/scripts/check_dependencies.py": {
      "sha256": "71e3a978ecde7ba912fc6ab7a4409c15e21a39415006bd70eb13cc32adaa7ca3",
      "size": 4044
    },
    "modules/period-comparison/scripts/inspect_inputs.py": {
      "sha256": "f9ea6c0a06fa43a9dae49045e3ad4e092a6132a77fe2013040c4cbf8bc7fbeca",
      "size": 1525
    },
    "modules/period-comparison/scripts/legacy_charting.py": {
      "sha256": "d435e7e2426273eb9b86385e3ae4f28bf6c6c96b23ae7ff1156ec2cdb3ed3322",
      "size": 67479
    },
    "modules/period-comparison/scripts/period_core.py": {
      "sha256": "7b790b4e3a0e2c11e14da7d5ab8db50e3bafffba82d5958fac2af827cbcc494e",
      "size": 81684
    },
    "modules/period-comparison/scripts/review_session.py": {
      "sha256": "bb7bf29c1504da342e9d6fa92577c79b2594d5f9bc0b3999fdc6b812c9170d6e",
      "size": 21876
    },
    "modules/period-comparison/scripts/run_period_comparison.py": {
      "sha256": "fa537e3a80e794ce07107ae5ac6d9882841416015d1071e919939ade4e3351aa",
      "size": 1597
    },
    "modules/period-comparison/skills/period-comparison/SKILL.md": {
      "sha256": "a6416de337c67064cb35010fc19fd769c8e38b6936cd23f27339e479569d8a6d",
      "size": 11373
    },
    "modules/period-comparison/vendor/modules/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/period-comparison/vendor/modules/auth/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/period-comparison/vendor/modules/auth/config.py": {
      "sha256": "7e95dfe02a16f254346f49ae981890d5641ca11fa6c32e1ba92269c6e04327a9",
      "size": 4441
    },
    "modules/period-comparison/vendor/modules/auth/google_identity.py": {
      "sha256": "bc33a5cacf88ab073c72171640c7067429c6884927ab1628f5fece503262dd9e",
      "size": 5521
    },
    "modules/period-comparison/vendor/modules/auth/session.py": {
      "sha256": "554cb2902d1ad2ee3ce232dd5c06422cd23232d0995489e18c25be61778ae42b",
      "size": 3849
    },
    "modules/period-comparison/vendor/modules/chart_harness/__init__.py": {
      "sha256": "64040e09b08b176a94cee3a65971c649479d7bc2d47a7a48c0fed0bf00c65dc5",
      "size": 4699
    },
    "modules/period-comparison/vendor/modules/chart_harness/analysis_context.py": {
      "sha256": "b1a530fffe1f9ae963950e779dd409920d94a168289f3faafef6cc93c8c2985e",
      "size": 10800
    },
    "modules/period-comparison/vendor/modules/chart_harness/artifacts.py": {
      "sha256": "190476ae688368778b08804e049244e595461edb7206f3525a0a1baec1f5b5e6",
      "size": 22039
    },
    "modules/period-comparison/vendor/modules/chart_harness/date_parsing.py": {
      "sha256": "175f17c295b0029db1bb895876aaa4f66d9a3e19b924cfffbbf22af42879a087",
      "size": 1104
    },
    "modules/period-comparison/vendor/modules/chart_harness/metric_semantics.py": {
      "sha256": "10849cdef532699ff323233f4f699eddee7fba7836075984199657c5c8d41f5a",
      "size": 12757
    },
    "modules/period-comparison/vendor/modules/chart_harness/period_contract.py": {
      "sha256": "1d04dd1a23808ecda086a53f3d76a492a2600c2b58917a63cd272a0b330e1384",
      "size": 11110
    },
    "modules/period-comparison/vendor/modules/chart_harness/period_derivations.py": {
      "sha256": "dfbe2252a94f7a264c1431a82fcf6cedd664756496399ad3090d9ee05c7fe614",
      "size": 30445
    },
    "modules/period-comparison/vendor/modules/chart_harness/period_label_policy.py": {
      "sha256": "e03d299651e00918a803e39c135eaeeeda9d972b77336fc8032daf7a068d946b",
      "size": 10567
    },
    "modules/period-comparison/vendor/modules/chart_harness/recipe_filters.py": {
      "sha256": "7a5bf6afab4cada57bb7093b517351c2ebeeb586c1524ae4b5a0d265fdc26792",
      "size": 13543
    },
    "modules/period-comparison/vendor/modules/chart_harness/reporting_titles.py": {
      "sha256": "b60bd2d5d20ed1f05fb1ce41c2a6807b139fc147789b22dde516de72f5fd830f",
      "size": 15842
    },
    "modules/period-comparison/vendor/modules/charting/__init__.py": {
      "sha256": "23163594f883b6262202001df66075390e9e30e23df2a858cff3b9b116d841e6",
      "size": 620
    },
    "modules/period-comparison/vendor/modules/charting/adjust_position.py": {
      "sha256": "aa92efb668a3f805b6a00759d6f933886c0d881d63a7a4c38247b90775707bc5",
      "size": 24574
    },
    "modules/period-comparison/vendor/modules/charting/area_pipeline.py": {
      "sha256": "47c2b23ba566d76fe253aaa31d32f021827eb56a7005eb7191fa60cff7b5b40b",
      "size": 21316
    },
    "modules/period-comparison/vendor/modules/charting/bubble_pipeline.py": {
      "sha256": "f7367dc5809ef5bde6c31b58029c620bd50f582a243cfe90dd38b63df2f5e541",
      "size": 5782
    },
    "modules/period-comparison/vendor/modules/charting/chart_helpers.py": {
      "sha256": "3828d367f5ad4299a4b3e71c06c6517127ec4ffde171b82cf260b74b3567f686",
      "size": 48060
    },
    "modules/period-comparison/vendor/modules/charting/chart_primitives.py": {
      "sha256": "38a3ccbac651300f21aae8f8025870aae7bebfd04e28db9f7fd27d6c38e99bf4",
      "size": 94051
    },
    "modules/period-comparison/vendor/modules/charting/draw_bubble.py": {
      "sha256": "da11bef92f80038c86a80aa009835d6bb27d20323cc9c813b023546078aaab16",
      "size": 39099
    },
    "modules/period-comparison/vendor/modules/charting/draw_charts_utils.py": {
      "sha256": "dac0fd1fc0e7c43d997c37213cd62948a38f73bc291e86d0fd22bdf9e90fac0f",
      "size": 156824
    },
    "modules/period-comparison/vendor/modules/charting/draw_distribution.py": {
      "sha256": "fdb8b8308913e63563dbd8e629b56f0e17dbe43af4e60bfa2a13d583d8f9f474",
      "size": 16947
    },
    "modules/period-comparison/vendor/modules/charting/draw_multitier.py": {
      "sha256": "79bf120e05207e156ad2103e6be6756ca129352cc496acd8db7867542237d319",
      "size": 97915
    },
    "modules/period-comparison/vendor/modules/charting/draw_other_charts.py": {
      "sha256": "4a9a5f0cd900619047d1f923859decc99b16a5839b74ad4b896d0cd39b7b4e23",
      "size": 38354
    },
    "modules/period-comparison/vendor/modules/charting/draw_pareto.py": {
      "sha256": "318b897545148615807e122073e6247a9f31ad142c87921725ac8a09c1b5fd66",
      "size": 23834
    },
    "modules/period-comparison/vendor/modules/charting/draw_scatter.py": {
      "sha256": "b24d0b34245382c710f30a230fd7555c7b13b03a84645d5a9c5aa822f0182292",
      "size": 42871
    },
    "modules/period-comparison/vendor/modules/charting/draw_timeline.py": {
      "sha256": "0b812d1fd53ab4ce4baf40e5cd293fd9ee702838e1b8aef528ea39e6289d6dfe",
      "size": 34282
    },
    "modules/period-comparison/vendor/modules/charting/draw_venn_upset.py": {
      "sha256": "9f87901443c040780033b340bdc7f581d9e79b3dc3f871ff607ba7f23662ad69",
      "size": 9244
    },
    "modules/period-comparison/vendor/modules/charting/draw_waterfall.py": {
      "sha256": "2e4e39337e67efa4f5398b39fda99a096d8453ee7e68fb455f50039b5f2f567e",
      "size": 44354
    },
    "modules/period-comparison/vendor/modules/charting/draw_width_and_stacked_plots.py": {
      "sha256": "0ff2a1f0492c01e86176157fa8f2974a434b8dfd3e0de2af5672c091189e211e",
      "size": 115738
    },
    "modules/period-comparison/vendor/modules/charting/legacy_draw_waterfall.py": {
      "sha256": "6a14e69341f1b1e37bb65fc0b090bfac72ac1951e05a0611507deb739a98ce14",
      "size": 44022
    },
    "modules/period-comparison/vendor/modules/charting/logic.py": {
      "sha256": "e616f6d339939ffe2131f7eb9cdc5d05d97a144a9ea1114aacd36a6e60a84e08",
      "size": 881
    },
    "modules/period-comparison/vendor/modules/charting/make_titles.py": {
      "sha256": "338445e55ea08d31a0a153a4737171a175ae6b56306add64ffae82d10558dfde",
      "size": 45352
    },
    "modules/period-comparison/vendor/modules/charting/mekko_pipeline.py": {
      "sha256": "d7229676db87f714c77d02df808256e7a835e01c771ac1452c3076722028a62d",
      "size": 41054
    },
    "modules/period-comparison/vendor/modules/charting/palettes.py": {
      "sha256": "a6ad512a80dff49c70c7b3c44aa7c8b160f9b1a1bf7b7c6d81e3bd45c88beb89",
      "size": 51874
    },
    "modules/period-comparison/vendor/modules/charting/plot_charts.py": {
      "sha256": "5468db22b976f4eeb76b23bc83e9ae994fb2cc861dc19ce584ebaec8f47fedb4",
      "size": 143629
    },
    "modules/period-comparison/vendor/modules/charting/plot_horizontal_bar.py": {
      "sha256": "7c407e19d49ff436220e465bdf0e20107ef421a7cc0e8497abe6bfe04eb821c8",
      "size": 1241
    },
    "modules/period-comparison/vendor/modules/charting/plotting_utilities.py": {
      "sha256": "62a9e8e68fb02c56949b7e3b67822242fdbca5eb4ad5d05aa39f0b8fe51beb06",
      "size": 45111
    },
    "modules/period-comparison/vendor/modules/charting/polars_helpers.py": {
      "sha256": "b0ba28065a01feaa1e0ca5230a1127b847dbd6cac2cacf321825fc4e423a3ab2",
      "size": 7601
    },
    "modules/period-comparison/vendor/modules/charting/prepare_charts.py": {
      "sha256": "3421d495f5aabcaffd20572285bc5b8e97bcd3ffe22c15f30ee68a91818984d6",
      "size": 36776
    },
    "modules/period-comparison/vendor/modules/charting/run_charting.py": {
      "sha256": "cffeddeed5f075773d58b7947b1365f4acd8f91f8f7f0f5ddc5ce87811ea5ea4",
      "size": 28749
    },
    "modules/period-comparison/vendor/modules/charting/scatter_pipeline.py": {
      "sha256": "da9560c49177b5d8954e82fc8340bd45ab6ae8fb19349f830fdb43cab3e0479a",
      "size": 4831
    },
    "modules/period-comparison/vendor/modules/charting/setup_fig.py": {
      "sha256": "c4c72ad57df1cc5bda6b71d2cab4aaa9e4128741da4c01c655b5b68b97e99f02",
      "size": 26104
    },
    "modules/period-comparison/vendor/modules/charting/small_multiples_ordering.py": {
      "sha256": "bd90f35e9fbb8eb5f3ef25a2ee743a4acc0ecda48781435e0522b2b382a6b816",
      "size": 2523
    },
    "modules/period-comparison/vendor/modules/charting/stacked_column_pipeline.py": {
      "sha256": "a0bd93e94ec98e8f1a2484e9df813f3154c8117ffb6c6fc3b158922c6b04b66d",
      "size": 27156
    },
    "modules/period-comparison/vendor/modules/charting/static_export.py": {
      "sha256": "dfe6d915a5b171d018d58472764c9e9431eb6d567093eefea2872e04138bd6d6",
      "size": 1131
    },
    "modules/period-comparison/vendor/modules/charting/update_layouts.py": {
      "sha256": "05f81b40ed4298d07c51d9465576ebc1b6b4a53689f99319501fe89390cf64c9",
      "size": 60908
    },
    "modules/period-comparison/vendor/modules/charting/upset_helpers.py": {
      "sha256": "c7ef21bbe353280653a5983f5a972a6f406aecbd5a7c024b0bec2a7088447b3f",
      "size": 362
    },
    "modules/period-comparison/vendor/modules/charting/upset_plot.py": {
      "sha256": "494ae1d6c14de66e730ff7d4685a2e0638b7f715895aa82e89899cd930c64fb0",
      "size": 9905
    },
    "modules/period-comparison/vendor/modules/data/__init__.py": {
      "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
      "size": 1
    },
    "modules/period-comparison/vendor/modules/data/cohort_processing.py": {
      "sha256": "c400326ca69007552cd5a23ef5e483b28d3362b4886e859528d32017456d3b91",
      "size": 16284
    },
    "modules/period-comparison/vendor/modules/data/common_data_utils.py": {
      "sha256": "6d1da1d46c3194f2531a4a016e6983663be68ef681c35c14d6f87c08a4b014da",
      "size": 132890
    },
    "modules/period-comparison/vendor/modules/data/data_cleaning.py": {
      "sha256": "65c0b486a2c44d7bdef6f5893591313a800c86e103ab7b7d564717aadd7a3b01",
      "size": 33497
    },
    "modules/period-comparison/vendor/modules/data/identify_columns.py": {
      "sha256": "99503c3b78f9292a3886c0dce06763f114b4014552f062fd1f244328fe35b6ad",
      "size": 110631
    },
    "modules/period-comparison/vendor/modules/data/merge_data.py": {
      "sha256": "2e6db2448e376169026e2f3771ebe7a09fda2de3b28ed3278faf38a4978693da",
      "size": 7151
    },
    "modules/period-comparison/vendor/modules/data/misc_charts_data_prep.py": {
      "sha256": "e93f9b58864160fcacd11d2bf68ddf2f2363d412a496a9b4583ef962f50ca30d",
      "size": 38571
    },
    "modules/period-comparison/vendor/modules/data/multidimensional_charts_prep.py": {
      "sha256": "59a572198611659b84d3a338e8e0b9f581b9a339202ebd1a6bdea579c07d98e6",
      "size": 76808
    },
    "modules/period-comparison/vendor/modules/data/time_series_data_prep.py": {
      "sha256": "6f9fdbfdfc1efef268f14f443b3fbe516661782fa96adfca73a2d64525af36be",
      "size": 4425
    },
    "modules/period-comparison/vendor/modules/data/waterfall_data_prep.py": {
      "sha256": "f78b45dc9ec4073c7f27d864bf790e1572dce80bce3f6d1b45c96dd94c4abd27",
      "size": 55834
    },
    "modules/period-comparison/vendor/modules/layout/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/period-comparison/vendor/modules/layout/core/ui_adapter.py": {
      "sha256": "76b429c2939fe46aea274d84d3100d74ce491b4efef77f5daed0c88a943d3182",
      "size": 3870
    },
    "modules/period-comparison/vendor/modules/layout/core/widget_state.py": {
      "sha256": "981c40c7692385a2759846de4c95e98e2d9966ac956e33dce4346d62047c1538",
      "size": 3426
    },
    "modules/period-comparison/vendor/modules/layout/layout_data.py": {
      "sha256": "87cf31d1387ad2d7845aa9ecc212feae1bfc6206cc50db9b67b8b72d63574523",
      "size": 2064
    },
    "modules/period-comparison/vendor/modules/layout/layout_helpers.py": {
      "sha256": "62b1dae0b4881d9194d4cd10e339417a161b159b76d78d8bde0b1d3efd13c3a4",
      "size": 31815
    },
    "modules/period-comparison/vendor/modules/layout/memoization.py": {
      "sha256": "ead4a46d07b43ea84aba55fe0555ee41408e2ba142c0557f0f8d1be91e931ba3",
      "size": 13439
    },
    "modules/period-comparison/vendor/modules/layout/performance.py": {
      "sha256": "4996b586dff3692252ec885e66d36a7327070c781c680f41dc5489c171531616",
      "size": 930
    },
    "modules/period-comparison/vendor/modules/layout/session_manager.py": {
      "sha256": "2e2d8bcc45065741009c314209239be57270455203d22176784dd084e49910f4",
      "size": 1105
    },
    "modules/period-comparison/vendor/modules/layout/set_up_widgets.py": {
      "sha256": "d12359ef6f67d0be4908a5e849a89935e6aee580897442609f8f71a29d78a5e5",
      "size": 761
    },
    "modules/period-comparison/vendor/modules/layout/widgets.py": {
      "sha256": "a4c5d79b664bc303080e083850ac0941ce66a0527e9e5858fec66e21aef0f6c0",
      "size": 923
    },
    "modules/period-comparison/vendor/modules/llm/__init__.py": {
      "sha256": "e416198937f477b64f1d2857ae2c442ae0fd5142def500be486a160c2a3d5340",
      "size": 51
    },
    "modules/period-comparison/vendor/modules/llm/confirm_plots.py": {
      "sha256": "8d14b250f446893c6266d689f26a40ed8c275ab96fcd2b474a49cd6b60e6bacb",
      "size": 693
    },
    "modules/period-comparison/vendor/modules/llm/interpret_plots.py": {
      "sha256": "2a594115f304474e9f55308ab91563645bcfe3b14f24cca416c001d5f45bab68",
      "size": 628
    },
    "modules/period-comparison/vendor/modules/llm/prompt_helpers.py": {
      "sha256": "f15b08a346138fc64b662d53905d369a00069ae5c67aa51575371b0915d4006e",
      "size": 498
    },
    "modules/period-comparison/vendor/modules/plan/__init__.py": {
      "sha256": "8ca432b4acd188c61581e22655212589661f36359f6f409ea6b9faca4c018a20",
      "size": 72
    },
    "modules/period-comparison/vendor/modules/plan/plan_dataset.py": {
      "sha256": "e7827dcf76ea64047d30bd1831745e219719c0bfcb76c0d588715322fed69fe3",
      "size": 601
    },
    "modules/period-comparison/vendor/modules/reporting_table.py": {
      "sha256": "99b687b83f4ce62fb2a33c875cf5740edb0854e9a7b094f1c314b1b6198adc1e",
      "size": 17079
    },
    "modules/period-comparison/vendor/modules/utilities/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/period-comparison/vendor/modules/utilities/config.py": {
      "sha256": "b4e7c75e766a2619ab768d2e79e8934b3238083bcfd260fc2a7375b3198aeef1",
      "size": 233980
    },
    "modules/period-comparison/vendor/modules/utilities/date_utils.py": {
      "sha256": "ddb2041be93ed08476f4a6c5fad67d6d59d94076cfc20d14c2d89a28b04aaba3",
      "size": 1930
    },
    "modules/period-comparison/vendor/modules/utilities/error_messages.py": {
      "sha256": "87828173f92a862ef37a88181d813ed39a3c1255ff2a6e5ab4a6d6d63d926315",
      "size": 19248
    },
    "modules/period-comparison/vendor/modules/utilities/helpers.py": {
      "sha256": "43c2c6083ad0635ab84664c7c6c8402780363aa718ea239e694785cf98ce29f7",
      "size": 105016
    },
    "modules/period-comparison/vendor/modules/utilities/logging_utils.py": {
      "sha256": "e78581502d65120f8a76560769a460702817206fbaf6226f95fdac94eb8e3f84",
      "size": 2551
    },
    "modules/period-comparison/vendor/modules/utilities/notifier.py": {
      "sha256": "5bcd244b4d319381b9cf67e8f1d6d7a9764891c32fd589801dd1ae5d98846b08",
      "size": 1020
    },
    "modules/period-comparison/vendor/modules/utilities/session_context.py": {
      "sha256": "93399e3e3c8ae812269304f6c3d5325f524baf3f8ce25835391108d158445b3c",
      "size": 8820
    },
    "modules/period-comparison/vendor/modules/utilities/ui_notifier.py": {
      "sha256": "918c62f85ff5ddd16337c608d8325b68a356573c54492ac0607a5316b09239cf",
      "size": 7212
    },
    "modules/period-comparison/vendor/modules/utilities/utils.py": {
      "sha256": "e8a7d350a40c9eedd864771c0327b6f1ddac4b40d434c96cbc778df849788b58",
      "size": 11296
    },
    "modules/period-comparison/vendor/modules/utils/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/period-comparison/vendor/modules/utils/polars_excel_writer.py": {
      "sha256": "c70e202ca92489ee3411bddfa266a786c6838b6b7a9b512c80212f07c737def4",
      "size": 2688
    },
    "modules/period-comparison/vendor/modules/variance/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/period-comparison/vendor/modules/variance/index_handling.py": {
      "sha256": "d7e578c8dd5cf2a008469d6aee132ca19d0fc416c19761f9f9af4cf9a61ac449",
      "size": 76257
    },
    "modules/period-comparison/vendor/modules/variance/variance_decomposition.py": {
      "sha256": "769cbf8b2096398fa1d9df6ad045f26085b3b0e331cc71f77d2ddde3ded373fe",
      "size": 60557
    },
    "modules/period-comparison/vendor/modules/variance/variance_formulas.py": {
      "sha256": "af95c36e55a861585a1e8e59b2a247f2b1a11cdc747c5a9d561a63b0a7f3e947",
      "size": 92461
    },
    "modules/period-comparison/vendor/modules/variance/variance_orchestrator.py": {
      "sha256": "5a1176d5a5ed9a4e97b1d7bd953de68f57a7fde2170480fbd4dfffa5bd92b5c9",
      "size": 83371
    },
    "modules/period-comparison/vendor/modules/variance/variance_utils.py": {
      "sha256": "60b50dd739ff11f1d1b098fcc3c340974ed0825033df0a204fa54980fc6667cf",
      "size": 51623
    },
    "modules/reporting-engine/README.md": {
      "sha256": "50a10cc2ac0ebec5c3ed628b8102aca800d3015d0ca2154b7aa2b5e91f2986f6",
      "size": 6284
    },
    "modules/reporting-engine/catalog/adapter_registry.json": {
      "sha256": "1ba4308be2f04bc8e66568221f738728765bdbc41b8c402e0462d5cd322b3edc",
      "size": 20880
    },
    "modules/reporting-engine/catalog/family_selector_playbooks/attributes.md": {
      "sha256": "652f3266a6fbff4d4b2ae8099586dd96a232776190808af2ed9c18dad0801b74",
      "size": 8421
    },
    "modules/reporting-engine/catalog/family_selector_playbooks/distribution.md": {
      "sha256": "9e7c0b9c66620d7eccee6d615efc02e2b02289bcbcb181d60d23f2e8cdc3a98b",
      "size": 12382
    },
    "modules/reporting-engine/catalog/family_selector_playbooks/funnel.md": {
      "sha256": "a5c0323e480bbc2b86e9a5e9d595ea3962968b49bafe15a7280684c1cd4c6569",
      "size": 2347
    },
    "modules/reporting-engine/catalog/family_selector_playbooks/index.md": {
      "sha256": "4c6ce54763da9be5e8594c5873c3fb949b2244bda2e47ad33563238fd5bf847c",
      "size": 765
    },
    "modules/reporting-engine/catalog/family_selector_playbooks/mix.md": {
      "sha256": "f75f4a2ca69366e282a94a7ce371c4e891c12202c00819c01d864fff9da9c544",
      "size": 32555
    },
    "modules/reporting-engine/catalog/family_selector_playbooks/period_comparison.md": {
      "sha256": "3936f568ab63894abb0cec3c9d11a63e241c0b65e4b906eb5654c24ab5d5d344",
      "size": 16228
    },
    "modules/reporting-engine/catalog/family_selector_playbooks/scatter_bubble.md": {
      "sha256": "3cbe94e88712738bb0c18b1e3718bce82f9770090d919fce3edef9224172f0e2",
      "size": 4121
    },
    "modules/reporting-engine/catalog/family_selector_playbooks/set_overlap.md": {
      "sha256": "1e737d4beca73eb1b6f1b6a4820c1be39cb0f3c01c407435d3288e7aa5e9321d",
      "size": 5397
    },
    "modules/reporting-engine/catalog/family_selector_playbooks/statement.md": {
      "sha256": "32cc219cd8762f80cd1a7cb2c00da82bfbd0101e478adfc2d6e0a86cdd10037a",
      "size": 2421
    },
    "modules/reporting-engine/catalog/family_selector_playbooks/variance.md": {
      "sha256": "1fb647f1c6aed44780bff17b4bf28537f24e27306da9869637d601ae3778eab5",
      "size": 15249
    },
    "modules/reporting-engine/catalog/manifest_assessment.md": {
      "sha256": "839aba7064793f7919a755a4822c8b66343127b7799693f21bbd4b20797c949e",
      "size": 8865
    },
    "modules/reporting-engine/catalog/manifest_summary.json": {
      "sha256": "859e130df1d2dd194134bbbc1f6884706c477c07d368fa99c44adb0a2a702951",
      "size": 4300
    },
    "modules/reporting-engine/catalog/mechanical_acceptance_summary.json": {
      "sha256": "46f8da4ddeae837e36685ad17d0cc5d0569249595618725fe122e4273f125dae",
      "size": 29991
    },
    "modules/reporting-engine/catalog/png_gallery_manifest.json": {
      "sha256": "28fa77ceadfb33e6b0a0089d0fb1b757142e0a3b92e475cee0bbfed8966c9252",
      "size": 216903
    },
    "modules/reporting-engine/catalog/role_registry.json": {
      "sha256": "02d13fc0c4cda246206e328801cf759023a0311d4fd6b835b28b63b75c84f4b2",
      "size": 51223
    },
    "modules/reporting-engine/catalog/selection_manifest.json": {
      "sha256": "934a06b31811f2aee51863b668070b3b0dcef2f28f4739d3730e9c5b03bfd374",
      "size": 1439212
    },
    "modules/reporting-engine/catalog/semantic_acceptance_summary.json": {
      "sha256": "e1bd8b92932fff0964766765b00cf0f92e916e26dd8b399ff9137bf154f7af6e",
      "size": 17543
    },
    "modules/reporting-engine/catalog/semantic_layer.schema.json": {
      "sha256": "b4d23bd51fcf9298e68926b995976f31125c5e17d35f200dc82bd4920c34dccb",
      "size": 25532
    },
    "modules/reporting-engine/fixtures/mechanical_acceptance/attribute_package/innovation_pairs.csv": {
      "sha256": "7cbcafca62f1637e861b3b8cc95a26041810a68ccdb91b0df8b3d82e7da68726",
      "size": 339
    },
    "modules/reporting-engine/fixtures/mechanical_acceptance/attribute_package/top_seller_pairs.csv": {
      "sha256": "1b2fcc7d44bfcd8a691cf95eace50195b4c1a581ecbd2e31164d2a955884c9df",
      "size": 359
    },
    "modules/reporting-engine/fixtures/mechanical_acceptance/attribute_recipe.json": {
      "sha256": "971394607f98994feb5a6d3f2028410fd06197a3d6bcfb0ba40cde006fd422f6",
      "size": 41
    },
    "modules/reporting-engine/fixtures/mechanical_acceptance/funnel_stage.csv": {
      "sha256": "96eed2b9c134da17083fc73b5b62b4045b8192e974995408d7a51b3897669ff7",
      "size": 120
    },
    "modules/reporting-engine/fixtures/mechanical_acceptance/set_overlap.csv": {
      "sha256": "2f32e7d56be56b176a8c98174461953dabeaa45c3b98a70c803c2f8263854cca",
      "size": 400
    },
    "modules/reporting-engine/fixtures/mechanical_acceptance/statement.csv": {
      "sha256": "fc6ade94610244df7abac89824807d8f5ba115f10a7a842344c1c30a2c6dbd87",
      "size": 234
    },
    "modules/reporting-engine/fixtures/mechanical_acceptance/statement_recipe.json": {
      "sha256": "89263148fb08ad7a3122a86d2d82489f0864f89aa7ceeb12e711c4f4571659e1",
      "size": 1186
    },
    "modules/reporting-engine/fixtures/mechanical_acceptance/universal_complete.csv": {
      "sha256": "bfe18a56603ad5232eba10a45c2cbceec383e40867048ae54e8b27d8fd90b65b",
      "size": 3044
    },
    "modules/reporting-engine/fixtures/mechanical_acceptance/variance_root_cause.csv": {
      "sha256": "5420f77921111b36d03caaf99bca154cf5c6ce622f27e37d23c06b24c0348446",
      "size": 246
    },
    "modules/reporting-engine/fixtures/semantic_layer/retail_monthly.csv": {
      "sha256": "5473abf694a0a40a04be245bcff25b875c6b42cf9f1da85097fd4f8ffbd7d59a",
      "size": 907
    },
    "modules/reporting-engine/fixtures/semantic_layer/retail_monthly.semantic.json": {
      "sha256": "50f4f3082a216e790ca85593023961d4a790195c814927806b4bfdeacbfac1fb",
      "size": 34386
    },
    "modules/reporting-engine/fixtures/semantic_layer/retail_monthly.snapshot_cases.json": {
      "sha256": "c93fea39f49c11c4cc99d5576e8e00f4f551341e34c151eaf2346ba560b06aa1",
      "size": 553
    },
    "modules/reporting-engine/fixtures/semantic_layer/retail_monthly_extension.csv": {
      "sha256": "5765d9edfc127148e0348e0b24dc0b2c266410b5f9c0fa99e9bdf37bac8a0cc4",
      "size": 1028
    },
    "modules/reporting-engine/fixtures/semantic_layer/retail_monthly_incompatible.csv": {
      "sha256": "1b155727834d2f145c415e9e210a14d2a2c84106254200fd68fc97b12bfda55b",
      "size": 319
    },
    "modules/reporting-engine/fixtures/semantic_layer/retail_monthly_refresh.csv": {
      "sha256": "d174c933cf05ed6ea24c6abf2f495b6d37379da0f3459e61360d7943360f8a69",
      "size": 1648
    },
    "modules/reporting-engine/fixtures/semantic_layer/retail_monthly_source_notes.md": {
      "sha256": "4ff2398b70225454aaadbce955ae20150151378385b0925a0b92c55432fac27c",
      "size": 3712
    },
    "modules/reporting-engine/references/semantic_layer.md": {
      "sha256": "00b83c9edc09c8428717ed0047b72726f1e1d077d99061e2dc8c83998fe1d84a",
      "size": 10515
    },
    "modules/reporting-engine/requirements-render.txt": {
      "sha256": "53f547afe67556e4bd36aaceafe97b32b6235e7ccc5c6984f629291113e24b00",
      "size": 156
    },
    "modules/reporting-engine/requirements.txt": {
      "sha256": "aed9fc3e2dacf46152efcf4ec678bfae9701d7bc7702123717b6b34a7fd12ccf",
      "size": 44
    },
    "modules/reporting-engine/scripts/budget_report.py": {
      "sha256": "fe69859b4b64c212b2ee4672dcabb73802e8840bc9f5cc312c13542ad7c837dc",
      "size": 4540
    },
    "modules/reporting-engine/scripts/budget_report_preview.py": {
      "sha256": "fa7668661b094590d62e39678f5dfa4cb39f07e355dcb8fbfd4ed095ef406a6e",
      "size": 3068
    },
    "modules/reporting-engine/scripts/check_compatibility.py": {
      "sha256": "edae39a15858bedfb260ca3b0c6f4cbadb0e9aa1f3bc660cb9a3c066dd0490cf",
      "size": 37885
    },
    "modules/reporting-engine/scripts/check_dependencies.py": {
      "sha256": "e35544e87537ac9afeb033745946471505477ad99c705ca679fa1e924c3c3078",
      "size": 2757
    },
    "modules/reporting-engine/scripts/compile_execution.py": {
      "sha256": "a4917e9b8b6c6cf2b7aa42d2b181b91e3d497b6aac8f9476709cf76a42d62d4b",
      "size": 8694
    },
    "modules/reporting-engine/scripts/dataset_intake.py": {
      "sha256": "b712213f606b9aa7dd4f5e0aeb1551f0a64f62accc84f01c6b53959e9922154c",
      "size": 14649
    },
    "modules/reporting-engine/scripts/dataset_snapshot.py": {
      "sha256": "1befb4b705f976bd19b81a32cf3abb31faf559823f7b9515a92693d214bc0e91",
      "size": 1443
    },
    "modules/reporting-engine/scripts/mechanical_acceptance.py": {
      "sha256": "e64d8153a877b4799ccd26715276d2c5f44bee527980030ebfa2add6d50333a0",
      "size": 41826
    },
    "modules/reporting-engine/scripts/profile_dataset.py": {
      "sha256": "54e58c3a9ddac1c59d7b123ea3065d1d8f3b813cb16b74174828bbe5c292f0c4",
      "size": 46551
    },
    "modules/reporting-engine/scripts/render_capability.py": {
      "sha256": "51caedd3ab4d86906abb267d94952403def39a4500c83c82b8f7ec67b6970fab",
      "size": 57039
    },
    "modules/reporting-engine/scripts/render_contract_registry.py": {
      "sha256": "e20ca3ed1f29e57ce70f0c7014aea0425e147caa8664d9de24bd5d539fde2803",
      "size": 9545
    },
    "modules/reporting-engine/scripts/reporting_adapters.py": {
      "sha256": "d33dfa1f4bd029e2033c8444d4c5c09444d082bd54a9f67e279cf11e49013104",
      "size": 14408
    },
    "modules/reporting-engine/scripts/reporting_contract.py": {
      "sha256": "00aa88c9c4b531deab0db7d4312d6c8657982a468c48d090f3819ec7825a323d",
      "size": 11659
    },
    "modules/reporting-engine/scripts/reporting_delivery.py": {
      "sha256": "15ba136a9582249b5f55618144fee660fdaeefaaf6d8b5973c248629e9c4ff01",
      "size": 5773
    },
    "modules/reporting-engine/scripts/run_capability.py": {
      "sha256": "dce589a03af3b5c568ce86b0c531a4b89354c00abc73067fafc06aac2b77f1a3",
      "size": 12299
    },
    "modules/reporting-engine/scripts/semantic_execution.py": {
      "sha256": "b8e5094012bcd29be708933abf220b3d195a33d19e5526ffa5c210a81cd42453",
      "size": 6403
    },
    "modules/reporting-engine/scripts/semantic_layer.py": {
      "sha256": "e993b1bf66d46054ef7a29406721f8c410ef183352ee7bc4c4bfc94caadfd73e",
      "size": 121962
    },
    "modules/scatter-bubble-analysis/.codex-plugin/plugin.json": {
      "sha256": "a92c7168ee9170e82f82825f2d2334983ccc5963c2ddca5717f43f373d5e7bda",
      "size": 2167
    },
    "modules/scatter-bubble-analysis/README.md": {
      "sha256": "a4ef90b9cee7000afa1a8f0117445aea443737fbfcd710dee13f60a90d67e22f",
      "size": 1715
    },
    "modules/scatter-bubble-analysis/assets/icon.svg": {
      "sha256": "a37ce03358a219ed11724b398ec59597996a8c3761c19cb10f0e41cb616a8c05",
      "size": 647
    },
    "modules/scatter-bubble-analysis/evals/trigger_fixtures.json": {
      "sha256": "16b061ad6cf5a77161ed3ecadfee5f9b76828959fc47b400653bc8bb9805ff9b",
      "size": 903
    },
    "modules/scatter-bubble-analysis/mcp/server.cjs": {
      "sha256": "1ea1a27fb88ea755cd70e9d1fb87fd11a9b43d1203aceb24aa63a01735f5add1",
      "size": 65673
    },
    "modules/scatter-bubble-analysis/references/legacy_inventory.json": {
      "sha256": "0d6015be1c3c65ecea34c76524522209b778de0019bf1270be6a4af2e393c037",
      "size": 808
    },
    "modules/scatter-bubble-analysis/requirements.txt": {
      "sha256": "7112d66937eab052100ce81d1a4e534099b2929ffdd4c4d1f1b3887284ff5ec3",
      "size": 116
    },
    "modules/scatter-bubble-analysis/scripts/check_dependencies.py": {
      "sha256": "72251db311385e5a66aa602f4738b8d55f3325c4f1a3633965dff97fe82f76c8",
      "size": 4459
    },
    "modules/scatter-bubble-analysis/scripts/inspect_inputs.py": {
      "sha256": "fe31ad71b2b7646ddff2e724db6661526293e188c438b03ab10200f2b30436fa",
      "size": 2499
    },
    "modules/scatter-bubble-analysis/scripts/legacy_scatter_bubble_charting.py": {
      "sha256": "2fe9e69039b874dc1c24645fdc3b9c0bd4a49216741c3455f446a15bdcd20f59",
      "size": 67754
    },
    "modules/scatter-bubble-analysis/scripts/review_session.py": {
      "sha256": "1dc2e5ac1aa4dd4bbe86d73da0d0c85cb058d4223e5d96c0c6efaa3e1197543b",
      "size": 26339
    },
    "modules/scatter-bubble-analysis/scripts/run_scatter_bubble.py": {
      "sha256": "f0068c9ff806c172743340b846ea1bae0933f5a26e787c1866271a1bddfab394",
      "size": 1678
    },
    "modules/scatter-bubble-analysis/scripts/scatter_bubble_core.py": {
      "sha256": "1b6436a2e412303a7f9d12a1f30af529914dff505dae426c55c76e93f6de53ed",
      "size": 65398
    },
    "modules/scatter-bubble-analysis/skills/scatter-bubble-analysis/SKILL.md": {
      "sha256": "016ce55ca53b4eceb59be297086ff57a1b9093c3b116701f097df757fcfc738c",
      "size": 9973
    },
    "modules/scatter-bubble-analysis/vendor/modules/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/scatter-bubble-analysis/vendor/modules/auth/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/scatter-bubble-analysis/vendor/modules/auth/config.py": {
      "sha256": "7e95dfe02a16f254346f49ae981890d5641ca11fa6c32e1ba92269c6e04327a9",
      "size": 4441
    },
    "modules/scatter-bubble-analysis/vendor/modules/auth/google_identity.py": {
      "sha256": "bc33a5cacf88ab073c72171640c7067429c6884927ab1628f5fece503262dd9e",
      "size": 5521
    },
    "modules/scatter-bubble-analysis/vendor/modules/auth/session.py": {
      "sha256": "554cb2902d1ad2ee3ce232dd5c06422cd23232d0995489e18c25be61778ae42b",
      "size": 3849
    },
    "modules/scatter-bubble-analysis/vendor/modules/chart_harness/__init__.py": {
      "sha256": "64040e09b08b176a94cee3a65971c649479d7bc2d47a7a48c0fed0bf00c65dc5",
      "size": 4699
    },
    "modules/scatter-bubble-analysis/vendor/modules/chart_harness/analysis_context.py": {
      "sha256": "b1a530fffe1f9ae963950e779dd409920d94a168289f3faafef6cc93c8c2985e",
      "size": 10800
    },
    "modules/scatter-bubble-analysis/vendor/modules/chart_harness/artifacts.py": {
      "sha256": "190476ae688368778b08804e049244e595461edb7206f3525a0a1baec1f5b5e6",
      "size": 22039
    },
    "modules/scatter-bubble-analysis/vendor/modules/chart_harness/date_parsing.py": {
      "sha256": "175f17c295b0029db1bb895876aaa4f66d9a3e19b924cfffbbf22af42879a087",
      "size": 1104
    },
    "modules/scatter-bubble-analysis/vendor/modules/chart_harness/metric_semantics.py": {
      "sha256": "10849cdef532699ff323233f4f699eddee7fba7836075984199657c5c8d41f5a",
      "size": 12757
    },
    "modules/scatter-bubble-analysis/vendor/modules/chart_harness/period_contract.py": {
      "sha256": "1d04dd1a23808ecda086a53f3d76a492a2600c2b58917a63cd272a0b330e1384",
      "size": 11110
    },
    "modules/scatter-bubble-analysis/vendor/modules/chart_harness/period_derivations.py": {
      "sha256": "dfbe2252a94f7a264c1431a82fcf6cedd664756496399ad3090d9ee05c7fe614",
      "size": 30445
    },
    "modules/scatter-bubble-analysis/vendor/modules/chart_harness/period_label_policy.py": {
      "sha256": "e03d299651e00918a803e39c135eaeeeda9d972b77336fc8032daf7a068d946b",
      "size": 10567
    },
    "modules/scatter-bubble-analysis/vendor/modules/chart_harness/recipe_filters.py": {
      "sha256": "7a5bf6afab4cada57bb7093b517351c2ebeeb586c1524ae4b5a0d265fdc26792",
      "size": 13543
    },
    "modules/scatter-bubble-analysis/vendor/modules/chart_harness/reporting_titles.py": {
      "sha256": "b60bd2d5d20ed1f05fb1ce41c2a6807b139fc147789b22dde516de72f5fd830f",
      "size": 15842
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/__init__.py": {
      "sha256": "23163594f883b6262202001df66075390e9e30e23df2a858cff3b9b116d841e6",
      "size": 620
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/adjust_position.py": {
      "sha256": "aa92efb668a3f805b6a00759d6f933886c0d881d63a7a4c38247b90775707bc5",
      "size": 24574
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/area_pipeline.py": {
      "sha256": "47c2b23ba566d76fe253aaa31d32f021827eb56a7005eb7191fa60cff7b5b40b",
      "size": 21316
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/bubble_pipeline.py": {
      "sha256": "f7367dc5809ef5bde6c31b58029c620bd50f582a243cfe90dd38b63df2f5e541",
      "size": 5782
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/chart_helpers.py": {
      "sha256": "3828d367f5ad4299a4b3e71c06c6517127ec4ffde171b82cf260b74b3567f686",
      "size": 48060
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/chart_primitives.py": {
      "sha256": "38a3ccbac651300f21aae8f8025870aae7bebfd04e28db9f7fd27d6c38e99bf4",
      "size": 94051
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/draw_bubble.py": {
      "sha256": "da11bef92f80038c86a80aa009835d6bb27d20323cc9c813b023546078aaab16",
      "size": 39099
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/draw_charts_utils.py": {
      "sha256": "dac0fd1fc0e7c43d997c37213cd62948a38f73bc291e86d0fd22bdf9e90fac0f",
      "size": 156824
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/draw_distribution.py": {
      "sha256": "fdb8b8308913e63563dbd8e629b56f0e17dbe43af4e60bfa2a13d583d8f9f474",
      "size": 16947
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/draw_multitier.py": {
      "sha256": "79bf120e05207e156ad2103e6be6756ca129352cc496acd8db7867542237d319",
      "size": 97915
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/draw_other_charts.py": {
      "sha256": "4a9a5f0cd900619047d1f923859decc99b16a5839b74ad4b896d0cd39b7b4e23",
      "size": 38354
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/draw_pareto.py": {
      "sha256": "318b897545148615807e122073e6247a9f31ad142c87921725ac8a09c1b5fd66",
      "size": 23834
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/draw_scatter.py": {
      "sha256": "b24d0b34245382c710f30a230fd7555c7b13b03a84645d5a9c5aa822f0182292",
      "size": 42871
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/draw_timeline.py": {
      "sha256": "0b812d1fd53ab4ce4baf40e5cd293fd9ee702838e1b8aef528ea39e6289d6dfe",
      "size": 34282
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/draw_venn_upset.py": {
      "sha256": "9f87901443c040780033b340bdc7f581d9e79b3dc3f871ff607ba7f23662ad69",
      "size": 9244
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/draw_waterfall.py": {
      "sha256": "2e4e39337e67efa4f5398b39fda99a096d8453ee7e68fb455f50039b5f2f567e",
      "size": 44354
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/draw_width_and_stacked_plots.py": {
      "sha256": "0ff2a1f0492c01e86176157fa8f2974a434b8dfd3e0de2af5672c091189e211e",
      "size": 115738
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/legacy_draw_waterfall.py": {
      "sha256": "6a14e69341f1b1e37bb65fc0b090bfac72ac1951e05a0611507deb739a98ce14",
      "size": 44022
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/logic.py": {
      "sha256": "e616f6d339939ffe2131f7eb9cdc5d05d97a144a9ea1114aacd36a6e60a84e08",
      "size": 881
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/make_titles.py": {
      "sha256": "338445e55ea08d31a0a153a4737171a175ae6b56306add64ffae82d10558dfde",
      "size": 45352
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/mekko_pipeline.py": {
      "sha256": "d7229676db87f714c77d02df808256e7a835e01c771ac1452c3076722028a62d",
      "size": 41054
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/palettes.py": {
      "sha256": "a6ad512a80dff49c70c7b3c44aa7c8b160f9b1a1bf7b7c6d81e3bd45c88beb89",
      "size": 51874
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/plot_charts.py": {
      "sha256": "5468db22b976f4eeb76b23bc83e9ae994fb2cc861dc19ce584ebaec8f47fedb4",
      "size": 143629
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/plot_horizontal_bar.py": {
      "sha256": "7c407e19d49ff436220e465bdf0e20107ef421a7cc0e8497abe6bfe04eb821c8",
      "size": 1241
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/plotting_utilities.py": {
      "sha256": "62a9e8e68fb02c56949b7e3b67822242fdbca5eb4ad5d05aa39f0b8fe51beb06",
      "size": 45111
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/polars_helpers.py": {
      "sha256": "b0ba28065a01feaa1e0ca5230a1127b847dbd6cac2cacf321825fc4e423a3ab2",
      "size": 7601
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/prepare_charts.py": {
      "sha256": "3421d495f5aabcaffd20572285bc5b8e97bcd3ffe22c15f30ee68a91818984d6",
      "size": 36776
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/run_charting.py": {
      "sha256": "cffeddeed5f075773d58b7947b1365f4acd8f91f8f7f0f5ddc5ce87811ea5ea4",
      "size": 28749
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/scatter_pipeline.py": {
      "sha256": "da9560c49177b5d8954e82fc8340bd45ab6ae8fb19349f830fdb43cab3e0479a",
      "size": 4831
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/setup_fig.py": {
      "sha256": "c4c72ad57df1cc5bda6b71d2cab4aaa9e4128741da4c01c655b5b68b97e99f02",
      "size": 26104
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/small_multiples_ordering.py": {
      "sha256": "bd90f35e9fbb8eb5f3ef25a2ee743a4acc0ecda48781435e0522b2b382a6b816",
      "size": 2523
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/stacked_column_pipeline.py": {
      "sha256": "a0bd93e94ec98e8f1a2484e9df813f3154c8117ffb6c6fc3b158922c6b04b66d",
      "size": 27156
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/static_export.py": {
      "sha256": "dfe6d915a5b171d018d58472764c9e9431eb6d567093eefea2872e04138bd6d6",
      "size": 1131
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/update_layouts.py": {
      "sha256": "05f81b40ed4298d07c51d9465576ebc1b6b4a53689f99319501fe89390cf64c9",
      "size": 60908
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/upset_helpers.py": {
      "sha256": "c7ef21bbe353280653a5983f5a972a6f406aecbd5a7c024b0bec2a7088447b3f",
      "size": 362
    },
    "modules/scatter-bubble-analysis/vendor/modules/charting/upset_plot.py": {
      "sha256": "494ae1d6c14de66e730ff7d4685a2e0638b7f715895aa82e89899cd930c64fb0",
      "size": 9905
    },
    "modules/scatter-bubble-analysis/vendor/modules/data/__init__.py": {
      "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
      "size": 1
    },
    "modules/scatter-bubble-analysis/vendor/modules/data/cohort_processing.py": {
      "sha256": "c400326ca69007552cd5a23ef5e483b28d3362b4886e859528d32017456d3b91",
      "size": 16284
    },
    "modules/scatter-bubble-analysis/vendor/modules/data/common_data_utils.py": {
      "sha256": "6d1da1d46c3194f2531a4a016e6983663be68ef681c35c14d6f87c08a4b014da",
      "size": 132890
    },
    "modules/scatter-bubble-analysis/vendor/modules/data/data_cleaning.py": {
      "sha256": "65c0b486a2c44d7bdef6f5893591313a800c86e103ab7b7d564717aadd7a3b01",
      "size": 33497
    },
    "modules/scatter-bubble-analysis/vendor/modules/data/identify_columns.py": {
      "sha256": "99503c3b78f9292a3886c0dce06763f114b4014552f062fd1f244328fe35b6ad",
      "size": 110631
    },
    "modules/scatter-bubble-analysis/vendor/modules/data/merge_data.py": {
      "sha256": "2e6db2448e376169026e2f3771ebe7a09fda2de3b28ed3278faf38a4978693da",
      "size": 7151
    },
    "modules/scatter-bubble-analysis/vendor/modules/data/misc_charts_data_prep.py": {
      "sha256": "e93f9b58864160fcacd11d2bf68ddf2f2363d412a496a9b4583ef962f50ca30d",
      "size": 38571
    },
    "modules/scatter-bubble-analysis/vendor/modules/data/multidimensional_charts_prep.py": {
      "sha256": "59a572198611659b84d3a338e8e0b9f581b9a339202ebd1a6bdea579c07d98e6",
      "size": 76808
    },
    "modules/scatter-bubble-analysis/vendor/modules/data/time_series_data_prep.py": {
      "sha256": "6f9fdbfdfc1efef268f14f443b3fbe516661782fa96adfca73a2d64525af36be",
      "size": 4425
    },
    "modules/scatter-bubble-analysis/vendor/modules/data/waterfall_data_prep.py": {
      "sha256": "f78b45dc9ec4073c7f27d864bf790e1572dce80bce3f6d1b45c96dd94c4abd27",
      "size": 55834
    },
    "modules/scatter-bubble-analysis/vendor/modules/layout/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/scatter-bubble-analysis/vendor/modules/layout/core/ui_adapter.py": {
      "sha256": "76b429c2939fe46aea274d84d3100d74ce491b4efef77f5daed0c88a943d3182",
      "size": 3870
    },
    "modules/scatter-bubble-analysis/vendor/modules/layout/core/widget_state.py": {
      "sha256": "981c40c7692385a2759846de4c95e98e2d9966ac956e33dce4346d62047c1538",
      "size": 3426
    },
    "modules/scatter-bubble-analysis/vendor/modules/layout/layout_data.py": {
      "sha256": "87cf31d1387ad2d7845aa9ecc212feae1bfc6206cc50db9b67b8b72d63574523",
      "size": 2064
    },
    "modules/scatter-bubble-analysis/vendor/modules/layout/layout_helpers.py": {
      "sha256": "62b1dae0b4881d9194d4cd10e339417a161b159b76d78d8bde0b1d3efd13c3a4",
      "size": 31815
    },
    "modules/scatter-bubble-analysis/vendor/modules/layout/memoization.py": {
      "sha256": "ead4a46d07b43ea84aba55fe0555ee41408e2ba142c0557f0f8d1be91e931ba3",
      "size": 13439
    },
    "modules/scatter-bubble-analysis/vendor/modules/layout/performance.py": {
      "sha256": "4996b586dff3692252ec885e66d36a7327070c781c680f41dc5489c171531616",
      "size": 930
    },
    "modules/scatter-bubble-analysis/vendor/modules/layout/session_manager.py": {
      "sha256": "2e2d8bcc45065741009c314209239be57270455203d22176784dd084e49910f4",
      "size": 1105
    },
    "modules/scatter-bubble-analysis/vendor/modules/layout/set_up_widgets.py": {
      "sha256": "d12359ef6f67d0be4908a5e849a89935e6aee580897442609f8f71a29d78a5e5",
      "size": 761
    },
    "modules/scatter-bubble-analysis/vendor/modules/layout/widgets.py": {
      "sha256": "a4c5d79b664bc303080e083850ac0941ce66a0527e9e5858fec66e21aef0f6c0",
      "size": 923
    },
    "modules/scatter-bubble-analysis/vendor/modules/llm/__init__.py": {
      "sha256": "e416198937f477b64f1d2857ae2c442ae0fd5142def500be486a160c2a3d5340",
      "size": 51
    },
    "modules/scatter-bubble-analysis/vendor/modules/llm/confirm_plots.py": {
      "sha256": "8d14b250f446893c6266d689f26a40ed8c275ab96fcd2b474a49cd6b60e6bacb",
      "size": 693
    },
    "modules/scatter-bubble-analysis/vendor/modules/llm/interpret_plots.py": {
      "sha256": "2a594115f304474e9f55308ab91563645bcfe3b14f24cca416c001d5f45bab68",
      "size": 628
    },
    "modules/scatter-bubble-analysis/vendor/modules/llm/prompt_helpers.py": {
      "sha256": "f15b08a346138fc64b662d53905d369a00069ae5c67aa51575371b0915d4006e",
      "size": 498
    },
    "modules/scatter-bubble-analysis/vendor/modules/plan/__init__.py": {
      "sha256": "8ca432b4acd188c61581e22655212589661f36359f6f409ea6b9faca4c018a20",
      "size": 72
    },
    "modules/scatter-bubble-analysis/vendor/modules/plan/plan_dataset.py": {
      "sha256": "e7827dcf76ea64047d30bd1831745e219719c0bfcb76c0d588715322fed69fe3",
      "size": 601
    },
    "modules/scatter-bubble-analysis/vendor/modules/utilities/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/scatter-bubble-analysis/vendor/modules/utilities/config.py": {
      "sha256": "b4e7c75e766a2619ab768d2e79e8934b3238083bcfd260fc2a7375b3198aeef1",
      "size": 233980
    },
    "modules/scatter-bubble-analysis/vendor/modules/utilities/date_utils.py": {
      "sha256": "ddb2041be93ed08476f4a6c5fad67d6d59d94076cfc20d14c2d89a28b04aaba3",
      "size": 1930
    },
    "modules/scatter-bubble-analysis/vendor/modules/utilities/error_messages.py": {
      "sha256": "87828173f92a862ef37a88181d813ed39a3c1255ff2a6e5ab4a6d6d63d926315",
      "size": 19248
    },
    "modules/scatter-bubble-analysis/vendor/modules/utilities/helpers.py": {
      "sha256": "43c2c6083ad0635ab84664c7c6c8402780363aa718ea239e694785cf98ce29f7",
      "size": 105016
    },
    "modules/scatter-bubble-analysis/vendor/modules/utilities/logging_utils.py": {
      "sha256": "e78581502d65120f8a76560769a460702817206fbaf6226f95fdac94eb8e3f84",
      "size": 2551
    },
    "modules/scatter-bubble-analysis/vendor/modules/utilities/notifier.py": {
      "sha256": "5bcd244b4d319381b9cf67e8f1d6d7a9764891c32fd589801dd1ae5d98846b08",
      "size": 1020
    },
    "modules/scatter-bubble-analysis/vendor/modules/utilities/session_context.py": {
      "sha256": "93399e3e3c8ae812269304f6c3d5325f524baf3f8ce25835391108d158445b3c",
      "size": 8820
    },
    "modules/scatter-bubble-analysis/vendor/modules/utilities/ui_notifier.py": {
      "sha256": "918c62f85ff5ddd16337c608d8325b68a356573c54492ac0607a5316b09239cf",
      "size": 7212
    },
    "modules/scatter-bubble-analysis/vendor/modules/utilities/utils.py": {
      "sha256": "e8a7d350a40c9eedd864771c0327b6f1ddac4b40d434c96cbc778df849788b58",
      "size": 11296
    },
    "modules/scatter-bubble-analysis/vendor/modules/utils/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/scatter-bubble-analysis/vendor/modules/utils/polars_excel_writer.py": {
      "sha256": "c70e202ca92489ee3411bddfa266a786c6838b6b7a9b512c80212f07c737def4",
      "size": 2688
    },
    "modules/scatter-bubble-analysis/vendor/modules/variance/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/scatter-bubble-analysis/vendor/modules/variance/index_handling.py": {
      "sha256": "d7e578c8dd5cf2a008469d6aee132ca19d0fc416c19761f9f9af4cf9a61ac449",
      "size": 76257
    },
    "modules/scatter-bubble-analysis/vendor/modules/variance/variance_decomposition.py": {
      "sha256": "769cbf8b2096398fa1d9df6ad045f26085b3b0e331cc71f77d2ddde3ded373fe",
      "size": 60557
    },
    "modules/scatter-bubble-analysis/vendor/modules/variance/variance_formulas.py": {
      "sha256": "af95c36e55a861585a1e8e59b2a247f2b1a11cdc747c5a9d561a63b0a7f3e947",
      "size": 92461
    },
    "modules/scatter-bubble-analysis/vendor/modules/variance/variance_orchestrator.py": {
      "sha256": "5a1176d5a5ed9a4e97b1d7bd953de68f57a7fde2170480fbd4dfffa5bd92b5c9",
      "size": 83371
    },
    "modules/scatter-bubble-analysis/vendor/modules/variance/variance_utils.py": {
      "sha256": "60b50dd739ff11f1d1b098fcc3c340974ed0825033df0a204fa54980fc6667cf",
      "size": 51623
    },
    "modules/set-overlap-analysis/.codex-plugin/plugin.json": {
      "sha256": "7a34ebc85e41df334f049376f3d5a0ecf8e7b89f4ee4ffced99d6a7df25a1301",
      "size": 1888
    },
    "modules/set-overlap-analysis/README.md": {
      "sha256": "85656c5c084bc3bd8748e81741b2f0780a409542870d21967c6f2f7979f3b0d5",
      "size": 4990
    },
    "modules/set-overlap-analysis/assets/icon.svg": {
      "sha256": "ef6ab5fc33dbba954e1be8024f4390aea2700290f6212e6e08c33fbdffa84c3b",
      "size": 641
    },
    "modules/set-overlap-analysis/evals/trigger_fixtures.json": {
      "sha256": "d0918b820d94161f95f684b00df1b4a9dfdb34541e3209f939c32b87efa314d2",
      "size": 841
    },
    "modules/set-overlap-analysis/mcp/server.cjs": {
      "sha256": "807bed26bfd1ae416fa4e0a2cf0fad720168a3a36bfe2f057ac3de9e5725bb85",
      "size": 64473
    },
    "modules/set-overlap-analysis/references/legacy_inventory.json": {
      "sha256": "d3d41f6bd7b14988cc961f90bb455f9f6dcd695c66d0ee35d24688bd49be87ef",
      "size": 918
    },
    "modules/set-overlap-analysis/references/legacy_mapping.json": {
      "sha256": "a31bf9cf7bda3d5ee2250f03af8f398926d0f237ed7dbd65dfcbde2cff41969f",
      "size": 1274
    },
    "modules/set-overlap-analysis/requirements.txt": {
      "sha256": "434ae2f248f4cc90c02fa57fb6978bf3025670d79cbc14d0075ce319d53aa479",
      "size": 123
    },
    "modules/set-overlap-analysis/scripts/check_dependencies.py": {
      "sha256": "992faed479cd02fa8ebe8a09c914a917f083f082423163a9295f74c2a0e7b045",
      "size": 4416
    },
    "modules/set-overlap-analysis/scripts/inspect_inputs.py": {
      "sha256": "7b459aa64ebddd9eefcaed1806b5379e02ec08769735a926b83f5eeffaa86619",
      "size": 1568
    },
    "modules/set-overlap-analysis/scripts/review_session.py": {
      "sha256": "74571d8511d0d80676a56fa0b665200abe2016855987eec69b5b907c61bdc5a0",
      "size": 27781
    },
    "modules/set-overlap-analysis/scripts/run_set_overlap.py": {
      "sha256": "967ef3256b27f6b618b409a50823519bdc9646defefa3a5cd91f353f46d2919a",
      "size": 1553
    },
    "modules/set-overlap-analysis/scripts/set_overlap_core.py": {
      "sha256": "f759bb0d3394a824bf47c7b5815333c3ee284bad9b85a1875198c0abebfd1929",
      "size": 61531
    },
    "modules/set-overlap-analysis/skills/set-overlap-analysis/SKILL.md": {
      "sha256": "40a9f48db0499ad3f1836f821069f23990bece6d6c70327c4d7155d9d227fdf8",
      "size": 7693
    },
    "modules/set-overlap-analysis/vendor/modules/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/set-overlap-analysis/vendor/modules/auth/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/set-overlap-analysis/vendor/modules/auth/config.py": {
      "sha256": "7e95dfe02a16f254346f49ae981890d5641ca11fa6c32e1ba92269c6e04327a9",
      "size": 4441
    },
    "modules/set-overlap-analysis/vendor/modules/auth/google_identity.py": {
      "sha256": "bc33a5cacf88ab073c72171640c7067429c6884927ab1628f5fece503262dd9e",
      "size": 5521
    },
    "modules/set-overlap-analysis/vendor/modules/auth/session.py": {
      "sha256": "554cb2902d1ad2ee3ce232dd5c06422cd23232d0995489e18c25be61778ae42b",
      "size": 3849
    },
    "modules/set-overlap-analysis/vendor/modules/chart_harness/__init__.py": {
      "sha256": "64040e09b08b176a94cee3a65971c649479d7bc2d47a7a48c0fed0bf00c65dc5",
      "size": 4699
    },
    "modules/set-overlap-analysis/vendor/modules/chart_harness/analysis_context.py": {
      "sha256": "b1a530fffe1f9ae963950e779dd409920d94a168289f3faafef6cc93c8c2985e",
      "size": 10800
    },
    "modules/set-overlap-analysis/vendor/modules/chart_harness/artifacts.py": {
      "sha256": "190476ae688368778b08804e049244e595461edb7206f3525a0a1baec1f5b5e6",
      "size": 22039
    },
    "modules/set-overlap-analysis/vendor/modules/chart_harness/date_parsing.py": {
      "sha256": "175f17c295b0029db1bb895876aaa4f66d9a3e19b924cfffbbf22af42879a087",
      "size": 1104
    },
    "modules/set-overlap-analysis/vendor/modules/chart_harness/metric_semantics.py": {
      "sha256": "10849cdef532699ff323233f4f699eddee7fba7836075984199657c5c8d41f5a",
      "size": 12757
    },
    "modules/set-overlap-analysis/vendor/modules/chart_harness/period_contract.py": {
      "sha256": "1d04dd1a23808ecda086a53f3d76a492a2600c2b58917a63cd272a0b330e1384",
      "size": 11110
    },
    "modules/set-overlap-analysis/vendor/modules/chart_harness/period_derivations.py": {
      "sha256": "dfbe2252a94f7a264c1431a82fcf6cedd664756496399ad3090d9ee05c7fe614",
      "size": 30445
    },
    "modules/set-overlap-analysis/vendor/modules/chart_harness/period_label_policy.py": {
      "sha256": "e03d299651e00918a803e39c135eaeeeda9d972b77336fc8032daf7a068d946b",
      "size": 10567
    },
    "modules/set-overlap-analysis/vendor/modules/chart_harness/recipe_filters.py": {
      "sha256": "7a5bf6afab4cada57bb7093b517351c2ebeeb586c1524ae4b5a0d265fdc26792",
      "size": 13543
    },
    "modules/set-overlap-analysis/vendor/modules/chart_harness/reporting_titles.py": {
      "sha256": "b60bd2d5d20ed1f05fb1ce41c2a6807b139fc147789b22dde516de72f5fd830f",
      "size": 15842
    },
    "modules/set-overlap-analysis/vendor/modules/charting/__init__.py": {
      "sha256": "23163594f883b6262202001df66075390e9e30e23df2a858cff3b9b116d841e6",
      "size": 620
    },
    "modules/set-overlap-analysis/vendor/modules/charting/adjust_position.py": {
      "sha256": "aa92efb668a3f805b6a00759d6f933886c0d881d63a7a4c38247b90775707bc5",
      "size": 24574
    },
    "modules/set-overlap-analysis/vendor/modules/charting/area_pipeline.py": {
      "sha256": "47c2b23ba566d76fe253aaa31d32f021827eb56a7005eb7191fa60cff7b5b40b",
      "size": 21316
    },
    "modules/set-overlap-analysis/vendor/modules/charting/bubble_pipeline.py": {
      "sha256": "f7367dc5809ef5bde6c31b58029c620bd50f582a243cfe90dd38b63df2f5e541",
      "size": 5782
    },
    "modules/set-overlap-analysis/vendor/modules/charting/chart_helpers.py": {
      "sha256": "3828d367f5ad4299a4b3e71c06c6517127ec4ffde171b82cf260b74b3567f686",
      "size": 48060
    },
    "modules/set-overlap-analysis/vendor/modules/charting/chart_primitives.py": {
      "sha256": "38a3ccbac651300f21aae8f8025870aae7bebfd04e28db9f7fd27d6c38e99bf4",
      "size": 94051
    },
    "modules/set-overlap-analysis/vendor/modules/charting/draw_bubble.py": {
      "sha256": "da11bef92f80038c86a80aa009835d6bb27d20323cc9c813b023546078aaab16",
      "size": 39099
    },
    "modules/set-overlap-analysis/vendor/modules/charting/draw_charts_utils.py": {
      "sha256": "dac0fd1fc0e7c43d997c37213cd62948a38f73bc291e86d0fd22bdf9e90fac0f",
      "size": 156824
    },
    "modules/set-overlap-analysis/vendor/modules/charting/draw_distribution.py": {
      "sha256": "fdb8b8308913e63563dbd8e629b56f0e17dbe43af4e60bfa2a13d583d8f9f474",
      "size": 16947
    },
    "modules/set-overlap-analysis/vendor/modules/charting/draw_multitier.py": {
      "sha256": "79bf120e05207e156ad2103e6be6756ca129352cc496acd8db7867542237d319",
      "size": 97915
    },
    "modules/set-overlap-analysis/vendor/modules/charting/draw_other_charts.py": {
      "sha256": "4a9a5f0cd900619047d1f923859decc99b16a5839b74ad4b896d0cd39b7b4e23",
      "size": 38354
    },
    "modules/set-overlap-analysis/vendor/modules/charting/draw_pareto.py": {
      "sha256": "318b897545148615807e122073e6247a9f31ad142c87921725ac8a09c1b5fd66",
      "size": 23834
    },
    "modules/set-overlap-analysis/vendor/modules/charting/draw_scatter.py": {
      "sha256": "b24d0b34245382c710f30a230fd7555c7b13b03a84645d5a9c5aa822f0182292",
      "size": 42871
    },
    "modules/set-overlap-analysis/vendor/modules/charting/draw_timeline.py": {
      "sha256": "0b812d1fd53ab4ce4baf40e5cd293fd9ee702838e1b8aef528ea39e6289d6dfe",
      "size": 34282
    },
    "modules/set-overlap-analysis/vendor/modules/charting/draw_venn_upset.py": {
      "sha256": "9f87901443c040780033b340bdc7f581d9e79b3dc3f871ff607ba7f23662ad69",
      "size": 9244
    },
    "modules/set-overlap-analysis/vendor/modules/charting/draw_waterfall.py": {
      "sha256": "2e4e39337e67efa4f5398b39fda99a096d8453ee7e68fb455f50039b5f2f567e",
      "size": 44354
    },
    "modules/set-overlap-analysis/vendor/modules/charting/draw_width_and_stacked_plots.py": {
      "sha256": "0ff2a1f0492c01e86176157fa8f2974a434b8dfd3e0de2af5672c091189e211e",
      "size": 115738
    },
    "modules/set-overlap-analysis/vendor/modules/charting/legacy_draw_waterfall.py": {
      "sha256": "6a14e69341f1b1e37bb65fc0b090bfac72ac1951e05a0611507deb739a98ce14",
      "size": 44022
    },
    "modules/set-overlap-analysis/vendor/modules/charting/logic.py": {
      "sha256": "e616f6d339939ffe2131f7eb9cdc5d05d97a144a9ea1114aacd36a6e60a84e08",
      "size": 881
    },
    "modules/set-overlap-analysis/vendor/modules/charting/make_titles.py": {
      "sha256": "338445e55ea08d31a0a153a4737171a175ae6b56306add64ffae82d10558dfde",
      "size": 45352
    },
    "modules/set-overlap-analysis/vendor/modules/charting/mekko_pipeline.py": {
      "sha256": "d7229676db87f714c77d02df808256e7a835e01c771ac1452c3076722028a62d",
      "size": 41054
    },
    "modules/set-overlap-analysis/vendor/modules/charting/palettes.py": {
      "sha256": "a6ad512a80dff49c70c7b3c44aa7c8b160f9b1a1bf7b7c6d81e3bd45c88beb89",
      "size": 51874
    },
    "modules/set-overlap-analysis/vendor/modules/charting/plot_charts.py": {
      "sha256": "5468db22b976f4eeb76b23bc83e9ae994fb2cc861dc19ce584ebaec8f47fedb4",
      "size": 143629
    },
    "modules/set-overlap-analysis/vendor/modules/charting/plot_horizontal_bar.py": {
      "sha256": "7c407e19d49ff436220e465bdf0e20107ef421a7cc0e8497abe6bfe04eb821c8",
      "size": 1241
    },
    "modules/set-overlap-analysis/vendor/modules/charting/plotting_utilities.py": {
      "sha256": "62a9e8e68fb02c56949b7e3b67822242fdbca5eb4ad5d05aa39f0b8fe51beb06",
      "size": 45111
    },
    "modules/set-overlap-analysis/vendor/modules/charting/polars_helpers.py": {
      "sha256": "b0ba28065a01feaa1e0ca5230a1127b847dbd6cac2cacf321825fc4e423a3ab2",
      "size": 7601
    },
    "modules/set-overlap-analysis/vendor/modules/charting/prepare_charts.py": {
      "sha256": "3421d495f5aabcaffd20572285bc5b8e97bcd3ffe22c15f30ee68a91818984d6",
      "size": 36776
    },
    "modules/set-overlap-analysis/vendor/modules/charting/run_charting.py": {
      "sha256": "cffeddeed5f075773d58b7947b1365f4acd8f91f8f7f0f5ddc5ce87811ea5ea4",
      "size": 28749
    },
    "modules/set-overlap-analysis/vendor/modules/charting/scatter_pipeline.py": {
      "sha256": "da9560c49177b5d8954e82fc8340bd45ab6ae8fb19349f830fdb43cab3e0479a",
      "size": 4831
    },
    "modules/set-overlap-analysis/vendor/modules/charting/setup_fig.py": {
      "sha256": "c4c72ad57df1cc5bda6b71d2cab4aaa9e4128741da4c01c655b5b68b97e99f02",
      "size": 26104
    },
    "modules/set-overlap-analysis/vendor/modules/charting/small_multiples_ordering.py": {
      "sha256": "bd90f35e9fbb8eb5f3ef25a2ee743a4acc0ecda48781435e0522b2b382a6b816",
      "size": 2523
    },
    "modules/set-overlap-analysis/vendor/modules/charting/stacked_column_pipeline.py": {
      "sha256": "a0bd93e94ec98e8f1a2484e9df813f3154c8117ffb6c6fc3b158922c6b04b66d",
      "size": 27156
    },
    "modules/set-overlap-analysis/vendor/modules/charting/static_export.py": {
      "sha256": "dfe6d915a5b171d018d58472764c9e9431eb6d567093eefea2872e04138bd6d6",
      "size": 1131
    },
    "modules/set-overlap-analysis/vendor/modules/charting/update_layouts.py": {
      "sha256": "05f81b40ed4298d07c51d9465576ebc1b6b4a53689f99319501fe89390cf64c9",
      "size": 60908
    },
    "modules/set-overlap-analysis/vendor/modules/charting/upset_helpers.py": {
      "sha256": "c7ef21bbe353280653a5983f5a972a6f406aecbd5a7c024b0bec2a7088447b3f",
      "size": 362
    },
    "modules/set-overlap-analysis/vendor/modules/charting/upset_plot.py": {
      "sha256": "494ae1d6c14de66e730ff7d4685a2e0638b7f715895aa82e89899cd930c64fb0",
      "size": 9905
    },
    "modules/set-overlap-analysis/vendor/modules/data/__init__.py": {
      "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
      "size": 1
    },
    "modules/set-overlap-analysis/vendor/modules/data/cohort_processing.py": {
      "sha256": "c400326ca69007552cd5a23ef5e483b28d3362b4886e859528d32017456d3b91",
      "size": 16284
    },
    "modules/set-overlap-analysis/vendor/modules/data/common_data_utils.py": {
      "sha256": "6d1da1d46c3194f2531a4a016e6983663be68ef681c35c14d6f87c08a4b014da",
      "size": 132890
    },
    "modules/set-overlap-analysis/vendor/modules/data/data_cleaning.py": {
      "sha256": "65c0b486a2c44d7bdef6f5893591313a800c86e103ab7b7d564717aadd7a3b01",
      "size": 33497
    },
    "modules/set-overlap-analysis/vendor/modules/data/identify_columns.py": {
      "sha256": "99503c3b78f9292a3886c0dce06763f114b4014552f062fd1f244328fe35b6ad",
      "size": 110631
    },
    "modules/set-overlap-analysis/vendor/modules/data/merge_data.py": {
      "sha256": "2e6db2448e376169026e2f3771ebe7a09fda2de3b28ed3278faf38a4978693da",
      "size": 7151
    },
    "modules/set-overlap-analysis/vendor/modules/data/misc_charts_data_prep.py": {
      "sha256": "e93f9b58864160fcacd11d2bf68ddf2f2363d412a496a9b4583ef962f50ca30d",
      "size": 38571
    },
    "modules/set-overlap-analysis/vendor/modules/data/multidimensional_charts_prep.py": {
      "sha256": "59a572198611659b84d3a338e8e0b9f581b9a339202ebd1a6bdea579c07d98e6",
      "size": 76808
    },
    "modules/set-overlap-analysis/vendor/modules/data/time_series_data_prep.py": {
      "sha256": "6f9fdbfdfc1efef268f14f443b3fbe516661782fa96adfca73a2d64525af36be",
      "size": 4425
    },
    "modules/set-overlap-analysis/vendor/modules/data/waterfall_data_prep.py": {
      "sha256": "f78b45dc9ec4073c7f27d864bf790e1572dce80bce3f6d1b45c96dd94c4abd27",
      "size": 55834
    },
    "modules/set-overlap-analysis/vendor/modules/layout/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/set-overlap-analysis/vendor/modules/layout/core/ui_adapter.py": {
      "sha256": "76b429c2939fe46aea274d84d3100d74ce491b4efef77f5daed0c88a943d3182",
      "size": 3870
    },
    "modules/set-overlap-analysis/vendor/modules/layout/core/widget_state.py": {
      "sha256": "981c40c7692385a2759846de4c95e98e2d9966ac956e33dce4346d62047c1538",
      "size": 3426
    },
    "modules/set-overlap-analysis/vendor/modules/layout/layout_data.py": {
      "sha256": "87cf31d1387ad2d7845aa9ecc212feae1bfc6206cc50db9b67b8b72d63574523",
      "size": 2064
    },
    "modules/set-overlap-analysis/vendor/modules/layout/layout_helpers.py": {
      "sha256": "62b1dae0b4881d9194d4cd10e339417a161b159b76d78d8bde0b1d3efd13c3a4",
      "size": 31815
    },
    "modules/set-overlap-analysis/vendor/modules/layout/memoization.py": {
      "sha256": "ead4a46d07b43ea84aba55fe0555ee41408e2ba142c0557f0f8d1be91e931ba3",
      "size": 13439
    },
    "modules/set-overlap-analysis/vendor/modules/layout/performance.py": {
      "sha256": "4996b586dff3692252ec885e66d36a7327070c781c680f41dc5489c171531616",
      "size": 930
    },
    "modules/set-overlap-analysis/vendor/modules/layout/session_manager.py": {
      "sha256": "2e2d8bcc45065741009c314209239be57270455203d22176784dd084e49910f4",
      "size": 1105
    },
    "modules/set-overlap-analysis/vendor/modules/layout/set_up_widgets.py": {
      "sha256": "d12359ef6f67d0be4908a5e849a89935e6aee580897442609f8f71a29d78a5e5",
      "size": 761
    },
    "modules/set-overlap-analysis/vendor/modules/layout/widgets.py": {
      "sha256": "a4c5d79b664bc303080e083850ac0941ce66a0527e9e5858fec66e21aef0f6c0",
      "size": 923
    },
    "modules/set-overlap-analysis/vendor/modules/llm/__init__.py": {
      "sha256": "e416198937f477b64f1d2857ae2c442ae0fd5142def500be486a160c2a3d5340",
      "size": 51
    },
    "modules/set-overlap-analysis/vendor/modules/llm/confirm_plots.py": {
      "sha256": "8d14b250f446893c6266d689f26a40ed8c275ab96fcd2b474a49cd6b60e6bacb",
      "size": 693
    },
    "modules/set-overlap-analysis/vendor/modules/llm/interpret_plots.py": {
      "sha256": "2a594115f304474e9f55308ab91563645bcfe3b14f24cca416c001d5f45bab68",
      "size": 628
    },
    "modules/set-overlap-analysis/vendor/modules/llm/prompt_helpers.py": {
      "sha256": "f15b08a346138fc64b662d53905d369a00069ae5c67aa51575371b0915d4006e",
      "size": 498
    },
    "modules/set-overlap-analysis/vendor/modules/plan/__init__.py": {
      "sha256": "8ca432b4acd188c61581e22655212589661f36359f6f409ea6b9faca4c018a20",
      "size": 72
    },
    "modules/set-overlap-analysis/vendor/modules/plan/plan_dataset.py": {
      "sha256": "e7827dcf76ea64047d30bd1831745e219719c0bfcb76c0d588715322fed69fe3",
      "size": 601
    },
    "modules/set-overlap-analysis/vendor/modules/utilities/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/set-overlap-analysis/vendor/modules/utilities/config.py": {
      "sha256": "b4e7c75e766a2619ab768d2e79e8934b3238083bcfd260fc2a7375b3198aeef1",
      "size": 233980
    },
    "modules/set-overlap-analysis/vendor/modules/utilities/date_utils.py": {
      "sha256": "ddb2041be93ed08476f4a6c5fad67d6d59d94076cfc20d14c2d89a28b04aaba3",
      "size": 1930
    },
    "modules/set-overlap-analysis/vendor/modules/utilities/error_messages.py": {
      "sha256": "87828173f92a862ef37a88181d813ed39a3c1255ff2a6e5ab4a6d6d63d926315",
      "size": 19248
    },
    "modules/set-overlap-analysis/vendor/modules/utilities/helpers.py": {
      "sha256": "43c2c6083ad0635ab84664c7c6c8402780363aa718ea239e694785cf98ce29f7",
      "size": 105016
    },
    "modules/set-overlap-analysis/vendor/modules/utilities/logging_utils.py": {
      "sha256": "e78581502d65120f8a76560769a460702817206fbaf6226f95fdac94eb8e3f84",
      "size": 2551
    },
    "modules/set-overlap-analysis/vendor/modules/utilities/notifier.py": {
      "sha256": "5bcd244b4d319381b9cf67e8f1d6d7a9764891c32fd589801dd1ae5d98846b08",
      "size": 1020
    },
    "modules/set-overlap-analysis/vendor/modules/utilities/session_context.py": {
      "sha256": "93399e3e3c8ae812269304f6c3d5325f524baf3f8ce25835391108d158445b3c",
      "size": 8820
    },
    "modules/set-overlap-analysis/vendor/modules/utilities/ui_notifier.py": {
      "sha256": "918c62f85ff5ddd16337c608d8325b68a356573c54492ac0607a5316b09239cf",
      "size": 7212
    },
    "modules/set-overlap-analysis/vendor/modules/utilities/utils.py": {
      "sha256": "e8a7d350a40c9eedd864771c0327b6f1ddac4b40d434c96cbc778df849788b58",
      "size": 11296
    },
    "modules/set-overlap-analysis/vendor/modules/utils/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/set-overlap-analysis/vendor/modules/utils/polars_excel_writer.py": {
      "sha256": "c70e202ca92489ee3411bddfa266a786c6838b6b7a9b512c80212f07c737def4",
      "size": 2688
    },
    "modules/set-overlap-analysis/vendor/modules/variance/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/set-overlap-analysis/vendor/modules/variance/index_handling.py": {
      "sha256": "d7e578c8dd5cf2a008469d6aee132ca19d0fc416c19761f9f9af4cf9a61ac449",
      "size": 76257
    },
    "modules/set-overlap-analysis/vendor/modules/variance/variance_decomposition.py": {
      "sha256": "769cbf8b2096398fa1d9df6ad045f26085b3b0e331cc71f77d2ddde3ded373fe",
      "size": 60557
    },
    "modules/set-overlap-analysis/vendor/modules/variance/variance_formulas.py": {
      "sha256": "af95c36e55a861585a1e8e59b2a247f2b1a11cdc747c5a9d561a63b0a7f3e947",
      "size": 92461
    },
    "modules/set-overlap-analysis/vendor/modules/variance/variance_orchestrator.py": {
      "sha256": "5a1176d5a5ed9a4e97b1d7bd953de68f57a7fde2170480fbd4dfffa5bd92b5c9",
      "size": 83371
    },
    "modules/set-overlap-analysis/vendor/modules/variance/variance_utils.py": {
      "sha256": "60b50dd739ff11f1d1b098fcc3c340974ed0825033df0a204fa54980fc6667cf",
      "size": 51623
    },
    "modules/statement-analysis/.codex-plugin/plugin.json": {
      "sha256": "a3d67783145a8068c1f9ab1b04ba34193ebae98aa9212d57763541ff14f4fd24",
      "size": 1862
    },
    "modules/statement-analysis/README.md": {
      "sha256": "fa7ab8303d55ad978bb6bfeb106af0ffd25fa0e83d33af3912f534fef7e7630a",
      "size": 540
    },
    "modules/statement-analysis/assets/icon.svg": {
      "sha256": "d3d1f2063dcfab34ac4f142572af0fc26d0becbe226fc58aa7a0b4689d66b57e",
      "size": 651
    },
    "modules/statement-analysis/evals/trigger_fixtures.json": {
      "sha256": "a96969c3449938375ee703e1c089e614ba684488b325755d85ee0c33d9bd9c81",
      "size": 959
    },
    "modules/statement-analysis/requirements.txt": {
      "sha256": "df9f2fabe756b2206d3f6e2b6f99d6cc7381a51c497a4e5a13abcd978fad40c2",
      "size": 40
    },
    "modules/statement-analysis/scripts/check_dependencies.py": {
      "sha256": "b8e5bf73fe98264fa7d48718ffd33137e4997a7da7fbdd915d30e6b71ffe5550",
      "size": 4212
    },
    "modules/statement-analysis/scripts/run_statement_analysis.py": {
      "sha256": "492f010cde65c3204ce05358a98549950c9229e763f8acfa70cfd0f74cc7520b",
      "size": 1417
    },
    "modules/statement-analysis/scripts/statement_core.py": {
      "sha256": "57284712498865e9fbda685e9d6f32cd9500cf3cc8a560736b764735ec7590be",
      "size": 28129
    },
    "modules/statement-analysis/skills/statement-analysis/SKILL.md": {
      "sha256": "ead12bdb520d9313526ec51248d88245980ae6c4c1b500fba28422a42a639742",
      "size": 5606
    },
    "modules/variance-analysis/.codex-plugin/plugin.json": {
      "sha256": "c89280ad441c57c8d1bf52d8571d612bf740c664f8c5b74a5734fe446be9cc10",
      "size": 2433
    },
    "modules/variance-analysis/README.md": {
      "sha256": "0696a1531885687beec637bcd9362701608992de89e78535e937ae992f84a628",
      "size": 5024
    },
    "modules/variance-analysis/assets/icon.svg": {
      "sha256": "b0d8e14b9b0087908ac190c8e626838c43f2f81f84b4dbe542c0ce2a19c0b912",
      "size": 687
    },
    "modules/variance-analysis/evals/trigger_fixtures.json": {
      "sha256": "3ba963431f09efad4819284ac032348d1f229306c0472954a5b62526c512e3c1",
      "size": 1122
    },
    "modules/variance-analysis/mcp/server.cjs": {
      "sha256": "9fd3f83c0507dd1152646c8ea30f7a4cfca48f4131383f780dd0bca46f4094c9",
      "size": 75448
    },
    "modules/variance-analysis/references/legacy_inventory.json": {
      "sha256": "40245a5dabf9448d8221662f3e20710bda51925b263b7f365e0faaa680a8d2f1",
      "size": 2007
    },
    "modules/variance-analysis/requirements.txt": {
      "sha256": "618fe34637ae3b61e4c951ced96c40c294bfcd1ba2f4872b26f82b9fd6fa498f",
      "size": 167
    },
    "modules/variance-analysis/scripts/accounting_controls.py": {
      "sha256": "f7c21784fd9e554fc6aebc1aacf025c9aafde8f57af44d3a7e0b5e9c8538c716",
      "size": 7895
    },
    "modules/variance-analysis/scripts/check_dependencies.py": {
      "sha256": "25f791ee0aef388b8bd33ca01a2733943cd62c2e1d19824b987ef1ea5b81970f",
      "size": 8336
    },
    "modules/variance-analysis/scripts/exploded_variance_bridge_chart.py": {
      "sha256": "4d02401b7e442bc5f158c4ba18e2897ecf7c12689db0d6389296fe632f72dd5b",
      "size": 43769
    },
    "modules/variance-analysis/scripts/ibcs_titles.py": {
      "sha256": "975437bb11fc7b1fe874a06fbf33500c85bb19b8ac3825820235e3cea5a997cd",
      "size": 17283
    },
    "modules/variance-analysis/scripts/inspect_column_values.py": {
      "sha256": "5f90106c17a98384028bab042e9e58e861d8ef970e072aef34267506dde1872c",
      "size": 4443
    },
    "modules/variance-analysis/scripts/inspect_inputs.py": {
      "sha256": "745ccd8fea09237621cf08838141da530d39b9d5e1eedc1c866520b8d813c9f1",
      "size": 3884
    },
    "modules/variance-analysis/scripts/legacy_adapter.py": {
      "sha256": "2a78bbf9e98ee3649e8e2979a248ca58dc993282433b92376a3bc13789d6a1e3",
      "size": 68779
    },
    "modules/variance-analysis/scripts/legacy_plotting.py": {
      "sha256": "3b376668b97a3ff7cb9770bc0cab3113210b4cb096b07c90a02b0ed1c34217b6",
      "size": 22176
    },
    "modules/variance-analysis/scripts/model_use.py": {
      "sha256": "630e8c31dffa23073bbd80394ac8098362afce20ee9dac327af00e9087a710b0",
      "size": 17147
    },
    "modules/variance-analysis/scripts/report_locales.py": {
      "sha256": "d2fe7b6bab9ea0c3dcf35ecf7a28bc4c02bc3b51d862f35be63f95eed37fd071",
      "size": 22354
    },
    "modules/variance-analysis/scripts/review_preflight.py": {
      "sha256": "84ce5aeeb28ec3cdbe865d37a340e43bfbb7bdf59eceeaeee16be031249f0f0c",
      "size": 1751
    },
    "modules/variance-analysis/scripts/review_session.py": {
      "sha256": "e28d2930c245cff073c9a7ee75453a691c2a70653ec969f54aeff4e66c888093",
      "size": 42060
    },
    "modules/variance-analysis/scripts/root_cause_bridge_chart.py": {
      "sha256": "bc9c536a0d95a6fd000d3e00a5d9710c60deb5544a87a1cfae4c082a6250c518",
      "size": 49467
    },
    "modules/variance-analysis/scripts/root_cause_client_report.py": {
      "sha256": "b3247c253b5185d82e4d9650a48fc7d9fea9754b56c69a338df5f57ebb3d89fc",
      "size": 84547
    },
    "modules/variance-analysis/scripts/run_variance.py": {
      "sha256": "e7b67974a4af889ca856778f601ae55fea93613d1eda21b0a59cc287b0d1c079",
      "size": 13201
    },
    "modules/variance-analysis/scripts/total_by_dimension_bridge_chart.py": {
      "sha256": "46f2e755a0ae1e26bfd39fb050afffa9c4d610df994eb4571b98ab7ec950aafe",
      "size": 31165
    },
    "modules/variance-analysis/scripts/variance_core.py": {
      "sha256": "b51f6fdbb81b6833c3146e123cbb5a9a506b01ecec6c8ed82f29005a84540b1f",
      "size": 214820
    },
    "modules/variance-analysis/skills/variance-analysis/SKILL.md": {
      "sha256": "8cf715e0b42d23d5cbe0420cc2a7f6b1790436ed461c53a832ff6c0e497631fe",
      "size": 33306
    },
    "modules/variance-analysis/vendor/modules/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/variance-analysis/vendor/modules/auth/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/variance-analysis/vendor/modules/auth/config.py": {
      "sha256": "7e95dfe02a16f254346f49ae981890d5641ca11fa6c32e1ba92269c6e04327a9",
      "size": 4441
    },
    "modules/variance-analysis/vendor/modules/auth/google_identity.py": {
      "sha256": "bc33a5cacf88ab073c72171640c7067429c6884927ab1628f5fece503262dd9e",
      "size": 5521
    },
    "modules/variance-analysis/vendor/modules/auth/session.py": {
      "sha256": "554cb2902d1ad2ee3ce232dd5c06422cd23232d0995489e18c25be61778ae42b",
      "size": 3849
    },
    "modules/variance-analysis/vendor/modules/chart_harness/__init__.py": {
      "sha256": "64040e09b08b176a94cee3a65971c649479d7bc2d47a7a48c0fed0bf00c65dc5",
      "size": 4699
    },
    "modules/variance-analysis/vendor/modules/chart_harness/analysis_context.py": {
      "sha256": "b1a530fffe1f9ae963950e779dd409920d94a168289f3faafef6cc93c8c2985e",
      "size": 10800
    },
    "modules/variance-analysis/vendor/modules/chart_harness/artifacts.py": {
      "sha256": "190476ae688368778b08804e049244e595461edb7206f3525a0a1baec1f5b5e6",
      "size": 22039
    },
    "modules/variance-analysis/vendor/modules/chart_harness/date_parsing.py": {
      "sha256": "175f17c295b0029db1bb895876aaa4f66d9a3e19b924cfffbbf22af42879a087",
      "size": 1104
    },
    "modules/variance-analysis/vendor/modules/chart_harness/metric_semantics.py": {
      "sha256": "10849cdef532699ff323233f4f699eddee7fba7836075984199657c5c8d41f5a",
      "size": 12757
    },
    "modules/variance-analysis/vendor/modules/chart_harness/period_contract.py": {
      "sha256": "1d04dd1a23808ecda086a53f3d76a492a2600c2b58917a63cd272a0b330e1384",
      "size": 11110
    },
    "modules/variance-analysis/vendor/modules/chart_harness/period_derivations.py": {
      "sha256": "dfbe2252a94f7a264c1431a82fcf6cedd664756496399ad3090d9ee05c7fe614",
      "size": 30445
    },
    "modules/variance-analysis/vendor/modules/chart_harness/period_label_policy.py": {
      "sha256": "e03d299651e00918a803e39c135eaeeeda9d972b77336fc8032daf7a068d946b",
      "size": 10567
    },
    "modules/variance-analysis/vendor/modules/chart_harness/recipe_filters.py": {
      "sha256": "7a5bf6afab4cada57bb7093b517351c2ebeeb586c1524ae4b5a0d265fdc26792",
      "size": 13543
    },
    "modules/variance-analysis/vendor/modules/chart_harness/reporting_titles.py": {
      "sha256": "b60bd2d5d20ed1f05fb1ce41c2a6807b139fc147789b22dde516de72f5fd830f",
      "size": 15842
    },
    "modules/variance-analysis/vendor/modules/charting/__init__.py": {
      "sha256": "69b6ac2411dd762e4bcf7e0a4040dc61a0deadebfd03515245824eaf8c877688",
      "size": 75
    },
    "modules/variance-analysis/vendor/modules/charting/adjust_position.py": {
      "sha256": "751380954c931e84368ac95bce9398f7f15638bb98f80d6a9a78366c17541d83",
      "size": 24403
    },
    "modules/variance-analysis/vendor/modules/charting/chart_helpers.py": {
      "sha256": "c9b4a573bbc69a3797e42e53824415eecaa7bbb8f57347d8ead8f40e65936cf5",
      "size": 46648
    },
    "modules/variance-analysis/vendor/modules/charting/chart_primitives.py": {
      "sha256": "b7d556e52c4d251f6cf5ffce438d2ae77d53fc8442f734134d7581c17e0502d6",
      "size": 91244
    },
    "modules/variance-analysis/vendor/modules/charting/draw_charts_utils.py": {
      "sha256": "739fc6ae318b25ef6834a4f25a0c15510fd52cc280c02bd8e8e832c13156c4f8",
      "size": 140272
    },
    "modules/variance-analysis/vendor/modules/charting/draw_multitier.py": {
      "sha256": "c76b8f9d8baced6008b723540ffa680ef188002a759c3f2e6c459d83b8087373",
      "size": 86234
    },
    "modules/variance-analysis/vendor/modules/charting/draw_waterfall.py": {
      "sha256": "7e41511d19bec2fb18cbac66038e223b7c4c8ab2f31723c680efe8c73f0223ff",
      "size": 71224
    },
    "modules/variance-analysis/vendor/modules/charting/legacy_draw_waterfall.py": {
      "sha256": "6a14e69341f1b1e37bb65fc0b090bfac72ac1951e05a0611507deb739a98ce14",
      "size": 44022
    },
    "modules/variance-analysis/vendor/modules/charting/make_titles.py": {
      "sha256": "68f8e95febbe5f9b59ac77d58c943410d97d5f2010d53651ffed1277046710dc",
      "size": 44550
    },
    "modules/variance-analysis/vendor/modules/charting/plot_charts.py": {
      "sha256": "90c05ad9535fd2fd9747d108bdaf93f21c78262b865bbb68f0bc4dad38d54fd8",
      "size": 19222
    },
    "modules/variance-analysis/vendor/modules/charting/polars_helpers.py": {
      "sha256": "2e1fc52cbc2a85c9516ae1c090a832c91e7aa4817dfe6222736c4d6e4d42fd0d",
      "size": 7535
    },
    "modules/variance-analysis/vendor/modules/charting/prepare_charts.py": {
      "sha256": "ed24ed55fd080dfd7cf0f78e89bde614eda97052928b4f8004a813d0047db729",
      "size": 36762
    },
    "modules/variance-analysis/vendor/modules/charting/setup_fig.py": {
      "sha256": "b9c0664e65ca9eb8ca5855eb26863bd57e8905124fadbc93b8f73905f2ceb2bc",
      "size": 26218
    },
    "modules/variance-analysis/vendor/modules/charting/update_layouts.py": {
      "sha256": "92a28c57fe5544c1a6ad64115d6da94056e36372ecb48eb9fc986d4cacfa6d12",
      "size": 59443
    },
    "modules/variance-analysis/vendor/modules/charting/upset_helpers.py": {
      "sha256": "c7ef21bbe353280653a5983f5a972a6f406aecbd5a7c024b0bec2a7088447b3f",
      "size": 362
    },
    "modules/variance-analysis/vendor/modules/data/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/variance-analysis/vendor/modules/data/common_data_utils.py": {
      "sha256": "da96c6e826750bc3515d8582a64bb5690f6603725dc5b1f579e5a939c8ad85fc",
      "size": 131279
    },
    "modules/variance-analysis/vendor/modules/data/misc_charts_data_prep.py": {
      "sha256": "b7d10cf0b3836c50a99e256ae8a8630ecb6ca786cf6cf6be06e189f04ffbf463",
      "size": 37898
    },
    "modules/variance-analysis/vendor/modules/data/multidimensional_charts_prep.py": {
      "sha256": "6935e57d40d71a8ee4723955bded6c5153188140f3d031ee7c08b307435aa784",
      "size": 74793
    },
    "modules/variance-analysis/vendor/modules/data/waterfall_data_prep.py": {
      "sha256": "ec2b6bf7b4193eeb6ba25a6ee6789aa25cb163a730322e787d53bc190421a7a6",
      "size": 55829
    },
    "modules/variance-analysis/vendor/modules/layout/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/variance-analysis/vendor/modules/layout/core/ui_adapter.py": {
      "sha256": "76b429c2939fe46aea274d84d3100d74ce491b4efef77f5daed0c88a943d3182",
      "size": 3870
    },
    "modules/variance-analysis/vendor/modules/layout/core/widget_state.py": {
      "sha256": "981c40c7692385a2759846de4c95e98e2d9966ac956e33dce4346d62047c1538",
      "size": 3426
    },
    "modules/variance-analysis/vendor/modules/layout/layout_data.py": {
      "sha256": "87cf31d1387ad2d7845aa9ecc212feae1bfc6206cc50db9b67b8b72d63574523",
      "size": 2064
    },
    "modules/variance-analysis/vendor/modules/layout/layout_helpers.py": {
      "sha256": "62b1dae0b4881d9194d4cd10e339417a161b159b76d78d8bde0b1d3efd13c3a4",
      "size": 31815
    },
    "modules/variance-analysis/vendor/modules/layout/memoization.py": {
      "sha256": "ead4a46d07b43ea84aba55fe0555ee41408e2ba142c0557f0f8d1be91e931ba3",
      "size": 13439
    },
    "modules/variance-analysis/vendor/modules/layout/session_manager.py": {
      "sha256": "2e2d8bcc45065741009c314209239be57270455203d22176784dd084e49910f4",
      "size": 1105
    },
    "modules/variance-analysis/vendor/modules/layout/set_up_widgets.py": {
      "sha256": "d12359ef6f67d0be4908a5e849a89935e6aee580897442609f8f71a29d78a5e5",
      "size": 761
    },
    "modules/variance-analysis/vendor/modules/layout/widgets.py": {
      "sha256": "a4c5d79b664bc303080e083850ac0941ce66a0527e9e5858fec66e21aef0f6c0",
      "size": 923
    },
    "modules/variance-analysis/vendor/modules/llm/__init__.py": {
      "sha256": "e416198937f477b64f1d2857ae2c442ae0fd5142def500be486a160c2a3d5340",
      "size": 51
    },
    "modules/variance-analysis/vendor/modules/llm/confirm_plots.py": {
      "sha256": "8d14b250f446893c6266d689f26a40ed8c275ab96fcd2b474a49cd6b60e6bacb",
      "size": 693
    },
    "modules/variance-analysis/vendor/modules/llm/interpret_plots.py": {
      "sha256": "e31c4f09ee2b1881fe9b5bbb2105da7a903714e70b469e34e4f61752e0ea90d3",
      "size": 568
    },
    "modules/variance-analysis/vendor/modules/plan/__init__.py": {
      "sha256": "8ca432b4acd188c61581e22655212589661f36359f6f409ea6b9faca4c018a20",
      "size": 72
    },
    "modules/variance-analysis/vendor/modules/plan/plan_dataset.py": {
      "sha256": "b45b85a3af41ac3496cdd4ca165ebe529e7bd31c312abaaaf3bc96af4cbc752f",
      "size": 316
    },
    "modules/variance-analysis/vendor/modules/utilities/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/variance-analysis/vendor/modules/utilities/config.py": {
      "sha256": "d139c54ec4880ef91db4674dd0d093cb795c62072a5e89a1a8a0246af3f1fc33",
      "size": 233948
    },
    "modules/variance-analysis/vendor/modules/utilities/error_messages.py": {
      "sha256": "87828173f92a862ef37a88181d813ed39a3c1255ff2a6e5ab4a6d6d63d926315",
      "size": 19248
    },
    "modules/variance-analysis/vendor/modules/utilities/helpers.py": {
      "sha256": "43c2c6083ad0635ab84664c7c6c8402780363aa718ea239e694785cf98ce29f7",
      "size": 105016
    },
    "modules/variance-analysis/vendor/modules/utilities/logging_utils.py": {
      "sha256": "e78581502d65120f8a76560769a460702817206fbaf6226f95fdac94eb8e3f84",
      "size": 2551
    },
    "modules/variance-analysis/vendor/modules/utilities/notifier.py": {
      "sha256": "5bcd244b4d319381b9cf67e8f1d6d7a9764891c32fd589801dd1ae5d98846b08",
      "size": 1020
    },
    "modules/variance-analysis/vendor/modules/utilities/session_context.py": {
      "sha256": "93399e3e3c8ae812269304f6c3d5325f524baf3f8ce25835391108d158445b3c",
      "size": 8820
    },
    "modules/variance-analysis/vendor/modules/utilities/ui_notifier.py": {
      "sha256": "918c62f85ff5ddd16337c608d8325b68a356573c54492ac0607a5316b09239cf",
      "size": 7212
    },
    "modules/variance-analysis/vendor/modules/utilities/utils.py": {
      "sha256": "568d9bbc77d8c01afcb868f3816d3839d346f60121be148acca1bd5b8c5a4900",
      "size": 7512
    },
    "modules/variance-analysis/vendor/modules/utils/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/variance-analysis/vendor/modules/utils/polars_excel_writer.py": {
      "sha256": "c70e202ca92489ee3411bddfa266a786c6838b6b7a9b512c80212f07c737def4",
      "size": 2688
    },
    "modules/variance-analysis/vendor/modules/variance/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "modules/variance-analysis/vendor/modules/variance/index_handling.py": {
      "sha256": "d7e578c8dd5cf2a008469d6aee132ca19d0fc416c19761f9f9af4cf9a61ac449",
      "size": 76257
    },
    "modules/variance-analysis/vendor/modules/variance/variance_decomposition.py": {
      "sha256": "6791a44d9f8ef9574701a4309f5b7a55d1bcc0a1330fc26d51d5bcc192d22c4a",
      "size": 60860
    },
    "modules/variance-analysis/vendor/modules/variance/variance_formulas.py": {
      "sha256": "af95c36e55a861585a1e8e59b2a247f2b1a11cdc747c5a9d561a63b0a7f3e947",
      "size": 92461
    },
    "modules/variance-analysis/vendor/modules/variance/variance_orchestrator.py": {
      "sha256": "5a1176d5a5ed9a4e97b1d7bd953de68f57a7fde2170480fbd4dfffa5bd92b5c9",
      "size": 83371
    },
    "modules/variance-analysis/vendor/modules/variance/variance_utils.py": {
      "sha256": "60b50dd739ff11f1d1b098fcc3c340974ed0825033df0a204fa54980fc6667cf",
      "size": 51623
    },
    "modules/variance-analysis/vendor/modules/vera_assurance/__init__.py": {
      "sha256": "e7c525a93ec80ec01a6134527f33a17d07f61cccafd90b33d26bdb96d8e1281f",
      "size": 2710
    },
    "modules/variance-analysis/vendor/modules/vera_assurance/contracts.py": {
      "sha256": "8203378c30262e1dfc568099a34a444cb33130343abf17d4a2eea8da107d7cb0",
      "size": 93104
    },
    "modules/variance-analysis/vendor/modules/vera_assurance/decisions.py": {
      "sha256": "28b62f4932997aa50d4d5b099383823096c203a035f1fdbb94ec97b0ce7fe63b",
      "size": 6397
    },
    "modules/variance-analysis/vendor/modules/vera_assurance/envelope.py": {
      "sha256": "80f9b005b190a2607ab3a12ad9c508174c8de100d7b9752f87644c62db070358",
      "size": 18987
    },
    "modules/variance-analysis/vendor/modules/vera_assurance/jurisdiction.py": {
      "sha256": "9bbf63c917cad41f2d2f516c7400b092d1a5a020e8e6e83831fbacc31968ebf1",
      "size": 7887
    },
    "modules/variance-analysis/vendor/modules/vera_assurance/money.py": {
      "sha256": "a2064acd368ae921fc37156e88711ed9afef4c7b8de7a374be552fa644a52431",
      "size": 10967
    },
    "modules/variance-analysis/vendor/modules/vera_assurance/recovery.py": {
      "sha256": "fbc5402144b405057deb92005580923f7b2ab67cfd439fe2af977a49f96f1715",
      "size": 21592
    },
    "modules/variance-analysis/vendor/modules/vera_assurance/relationships.py": {
      "sha256": "bfadd997d33e764f414e55d967933a7745ba0a9032df21addf8fed076400a085",
      "size": 15349
    },
    "modules/variance-analysis/vendor/modules/vera_assurance/review_output_transaction.cjs": {
      "sha256": "63075c6c3b0eff1d3a6706aa59d0dd1e00c558f9a4b51dcf952e881caccfa348",
      "size": 41618
    },
    "modules/variance-analysis/vendor/modules/vera_assurance/serialization.py": {
      "sha256": "8fdbb590830d8a41b6bb3271ceb0abf9874237d0151028b994b9e5521077141f",
      "size": 11043
    },
    "playbook/clara_kickoff_playbook.json": {
      "sha256": "987e6dceb6f12bd54e2594047b20e5044be424eb0c9a488584bb928b0c221e35",
      "size": 2762
    },
    "plugin.json": {
      "sha256": "13eca6d1811f0cab1d497ecced113e1fa802e0dea5f45fab1d71b20092ef98b7",
      "size": 4119
    },
    "privacy/contracts/advisory-brief-planner.json": {
      "sha256": "5906939c39543e1a1646fe169ab2dcac0e0461fa55b66bc7f22a2f3f5a4408b4",
      "size": 137735
    },
    "privacy/contracts/advisory-case-director.json": {
      "sha256": "439c7ef3ab57a27c680d5cf881cab7970dfb9444c771b2f41b4aba96fce4f0f2",
      "size": 131325
    },
    "privacy/contracts/advisory-deliverable-validator.json": {
      "sha256": "f665b67af25db71ed5a1cdfcaf37309ea8583159ff92c7d2ed5c295798c7f3e0",
      "size": 145614
    },
    "privacy/contracts/attribute-reporting.json": {
      "sha256": "259c2e4cea1d8593e8dfc6c0f801557eeb6583c1766912a6c65e815d78306d4c",
      "size": 142374
    },
    "privacy/contracts/brand-fit.json": {
      "sha256": "a320c5266e0a8aa397c94a2b77611374af2118c1493497dbdd9948166c4fabec",
      "size": 142335
    },
    "privacy/contracts/business-planning.json": {
      "sha256": "08b1fdd999763f0415df7e357a11c3118d1231a51ae6bcf9031828e6b22944a5",
      "size": 147957
    },
    "privacy/contracts/claim-basis-map.json": {
      "sha256": "cc4227b7afaba8feb8f78c870360256a908421bd847551056b28e569c3670491",
      "size": 126519
    },
    "privacy/contracts/clara.json": {
      "sha256": "9afdd0928b125e9e38142dbfb36f475cb50393e9e68e138dfc62eff9bafed19a",
      "size": 241014
    },
    "privacy/contracts/deck-correction.json": {
      "sha256": "21503c7db8b62f19009ff7462e6986fb8d8237a21afdf1810e5f12db4626519d",
      "size": 149306
    },
    "privacy/contracts/distribution-analysis.json": {
      "sha256": "75629455d771915a733ca9c6cdb265886bdae62c014e5f695e14f052f7a7be39",
      "size": 121850
    },
    "privacy/contracts/funnel-analysis.json": {
      "sha256": "5f2af8ab5d904bb9836df51c8a8b3f61af0a2bd11bd1f9890a6f00d90d9ec32e",
      "size": 121780
    },
    "privacy/contracts/hosted-interview.json": {
      "sha256": "bd98ffed75943ddcf8c7ec49c41592d3c44eba9b62c8df697e3de03571dee737",
      "size": 155419
    },
    "privacy/contracts/html-deck.json": {
      "sha256": "8a12624e01a24f88bf30479fae9d7d62702145c5b3d935985af77740baee8c3d",
      "size": 130566
    },
    "privacy/contracts/index.json": {
      "sha256": "ee4dc7570c4df97dadcf9b7cfb04e2486b2c5bb61446af0d8072303f18bfe13f",
      "size": 4265
    },
    "privacy/contracts/learn-with-clara.json": {
      "sha256": "0b18b317dc2b136cea1ef9493ed2782db2b76004337000ede4e1d2f30dc4fd79",
      "size": 52029
    },
    "privacy/contracts/management-control-pack.json": {
      "sha256": "4e1a34849e4e50b88147dbbbd5531ef792655d47d370cd13cfec6c907193e315",
      "size": 124134
    },
    "privacy/contracts/mix-contribution-analysis.json": {
      "sha256": "10b9446b5f34a5f32e9a7b8a7c277b6c89fca762a51f0fa9357f5cd34dd9d7f9",
      "size": 121908
    },
    "privacy/contracts/period-comparison.json": {
      "sha256": "09a26375d2928f7440f670569ba34c0375eefcfc4bd3408f355c64c5088d5063",
      "size": 121849
    },
    "privacy/contracts/reporting-engine.json": {
      "sha256": "8e41a09c8147055365c46203e5f9dbe81c42f1233d6578f163867239dc622478",
      "size": 141755
    },
    "privacy/contracts/research-video.json": {
      "sha256": "3bfc6191d857dbde50b1ec8641a4edb62e3c77edd50704de4f757581379bb9af",
      "size": 147356
    },
    "privacy/contracts/scatter-bubble-analysis.json": {
      "sha256": "22858dacc84321f99948f9758d8cb37fbfb8a9c615eaedae8461c25e6966a2b7",
      "size": 121843
    },
    "privacy/contracts/set-overlap-analysis.json": {
      "sha256": "d11fedbf164e2b8172eb1164412d4ca12c8ce050f9516408094f3f053412d4b5",
      "size": 121825
    },
    "privacy/contracts/statement-analysis.json": {
      "sha256": "c053ecce309b652cabc65ac133a5a2c47aed0df7fc868f7a038e902764bfcfab",
      "size": 121838
    },
    "privacy/contracts/transcribe.json": {
      "sha256": "c8ccea4f8ccfc19d925a8143ec52dfcbdda2805d6ee99ef3de0aea199980d46c",
      "size": 150382
    },
    "privacy/contracts/variance-analysis.json": {
      "sha256": "351cada0777e08d81b05a7197c57ff05d4ac55b80e657557fb242799798bd8c8",
      "size": 122373
    },
    "privacy/package-projection.json": {
      "sha256": "cec62a5bbced3ba3b56e2c1b391d246c144a55d1bfc14d97db1e21c747235f33",
      "size": 603
    },
    "privacy/privacy-surface.schema.json": {
      "sha256": "ac16d248e6df00cc08af1b430f507d246c074869d2fc826df1bb9a5bd6cff420",
      "size": 8407
    },
    "privacy/registry.json": {
      "sha256": "55f4f1c3c617b460f3eceb71830fd39636eb8e6f940a28354b111318c51fb026",
      "size": 10387
    },
    "privacy/registry.schema.json": {
      "sha256": "a0d4340647fee6b711089dbcad0c03592902aff38ee58b125c0ee3e876749dd0",
      "size": 6034
    },
    "privacy/repository-source-reviews/hosted-interviews.json": {
      "sha256": "d6440df779a23d7df7ca038619ff5ed0fb1522a162e94c76a4c1b9607bbf0402",
      "size": 29824
    },
    "privacy/repository-source-reviews/hosted-voice.json": {
      "sha256": "1cb2576cdefc9ebc3119c870215d7f07d7849866abbcf3685b45da0452788aa0",
      "size": 19087
    },
    "privacy/repository-source-reviews/managed-python-runtime.json": {
      "sha256": "9c947c39c952abcd924c6f7b3ff2e15abca75eefe148aa940b2e49a6c89b05a9",
      "size": 23266
    },
    "privacy/repository-source-reviews/on-demand-mcp.json": {
      "sha256": "542c3ee622512a06cfeb47121c854e02816b1e11d74f0800067e4efc82452a1e",
      "size": 5385
    },
    "privacy/repository-source-reviews/operational-incidents.json": {
      "sha256": "dc42e4cc12fb6a6022d75ee9b93263531a408586c922898a340d4192a65ce623",
      "size": 51318
    },
    "privacy/repository-source-reviews/plugin-feedback.json": {
      "sha256": "744e6d9cec3944dc6b0677f30f6c6bb845371e33b0b08ab62d154f75c32b7a26",
      "size": 23556
    },
    "privacy/repository-source-reviews/plugin-update-check.json": {
      "sha256": "9c51c5c22458ab29124bfd58d5f272308ae3ffa908298798104d4c2be170354c",
      "size": 5466
    },
    "privacy/repository-source-reviews/prepared-course-files.json": {
      "sha256": "ccb43f5786936a5f5e30aa001120576d0f3af84c9395e376e0392d18fa7d6f3e",
      "size": 9419
    },
    "privacy/repository-source-reviews/research-video-voice.json": {
      "sha256": "179ab6b1e342d661641e156224f8984a1689002c382315aede9a9edb0288b0ba",
      "size": 13438
    },
    "privacy/repository-source-reviews/retail-data.json": {
      "sha256": "7393d0b3e272be5482fd7799c72b0986878fc252b1cc8d18ad891e4aa8951eea",
      "size": 13965
    },
    "privacy/repository-source-reviews/run-receipt-stamping.json": {
      "sha256": "05cf3fd1b1712f14f9c3adda265390697801de1657ec984f08165421e68aafcd",
      "size": 31512
    },
    "privacy/repository-source-reviews/workflow-usage.json": {
      "sha256": "d48b2dd318114ddddf2611b23029448a131c1fb5b24b9e99c6ee43b9be38bf32",
      "size": 36322
    },
    "privacy/repository-source-reviews/workstream-business-planning.json": {
      "sha256": "074fcb1413eb4398f16a33ca8615a370dfc59944a8f433177c714fbd7ba5fb8b",
      "size": 32697
    },
    "privacy/repository-source-reviews/workstream-learn-with-clara.json": {
      "sha256": "a10e25f0b86e60592a5358d71b083ccb8f313b67727fb554dd06e75989547a28",
      "size": 793295
    },
    "privacy/repository-source-reviews/workstream-management-control-pack.json": {
      "sha256": "b5bc703a7d93c3760f301e7954a7a640f15ebbcea28f095eb98968b9d0a54394",
      "size": 5933
    },
    "privacy/repository-source-reviews/workstream-reporting-engine.json": {
      "sha256": "dcc77aec98eef8b64f1667310890d9889a62a250b6566407cc06fca194c83276",
      "size": 26182
    },
    "privacy/repository-source-reviews/workstream-variance-analysis.json": {
      "sha256": "b0f653c06e0714a9136a077be215cd3e5d2e991c35b4b1aa9132cbf6bb874e1b",
      "size": 4190
    },
    "privacy/runtime-profiles.json": {
      "sha256": "f96c2d96d94af8bc902a8892c51e98b1f962498ba9a24f2f2739d3ad71da70a1",
      "size": 4099
    },
    "privacy/runtime-profiles.schema.json": {
      "sha256": "3bcf55bdcb2bb610e85f5588edcc406e2dfcd8c105578ea8b58d873ee34c02ea",
      "size": 4534
    },
    "privacy/service-boundary.schema.json": {
      "sha256": "38e24396140af208dde7d44bc406f69fb89d9939e472543a6b7449bff2644136",
      "size": 9004
    },
    "privacy/services/hosted-interviews.json": {
      "sha256": "f8f726a2c75bc699ce94da6a41428d39355f32d40e255170aaaec47b7b553939",
      "size": 27831
    },
    "privacy/services/hosted-voice.json": {
      "sha256": "b33da5505e007eb592e5a8817b4d73abf8f1a8fc520d695b0a74de4f7de1c497",
      "size": 17736
    },
    "privacy/services/managed-python-runtime.json": {
      "sha256": "1dd9fd25e9635750cf331cc9bbf86e1e111e5f8b93513926b2625104be0e326b",
      "size": 23011
    },
    "privacy/services/on-demand-mcp.json": {
      "sha256": "47cdfc47cc4d50114e4011acbf35b372adc6e7ff71a9535a0b667b6727cbade1",
      "size": 4025
    },
    "privacy/services/operational-incidents.json": {
      "sha256": "2811af819a0f9568ad77acf89dac2fbf6e8446bdcd20f03aa91ba5ece06cba90",
      "size": 42565
    },
    "privacy/services/plugin-feedback.json": {
      "sha256": "3b9e7de864a86331a1ab5298b9a97252cd63b0e01e44adacc127040094a145bf",
      "size": 22380
    },
    "privacy/services/plugin-update-check.json": {
      "sha256": "ee557d7d6144ae6402802ea51b49a49fc4ce35b9f3f08e78927c735de08cbbcc",
      "size": 5084
    },
    "privacy/services/prepared-course-files.json": {
      "sha256": "fb201c4fa8d6c1b3cd3f270edd251ba5a1df3296e157826a022ddafac7da1ed2",
      "size": 4221
    },
    "privacy/services/research-video-voice.json": {
      "sha256": "859cc924fc925f0d9c5f22f1b024bf7995ee6add822ce1fa6135036d726600fa",
      "size": 12274
    },
    "privacy/services/retail-data.json": {
      "sha256": "27658f7ce7a3ae1c2b7186fb521fa94d69f8533ce9d5c0ef5c49f9c424603f7c",
      "size": 13249
    },
    "privacy/services/run-receipt-stamping.json": {
      "sha256": "ff49140bf33e630689173e448218839bdc24dcce08d7541bdf033aa296cbe88c",
      "size": 21290
    },
    "privacy/services/workflow-usage.json": {
      "sha256": "17c5c397811ad2079d293d2045b496e2a51516656954f46868103c9fc9e3cb2d",
      "size": 27671
    },
    "privacy/workstreams/advisory-brief-planner.json": {
      "sha256": "e94cfd9bbc51e533a4fc6e4ee50e7c6829070729b3f2ec7e8d376a38a352eaf8",
      "size": 17338
    },
    "privacy/workstreams/advisory-case-director.json": {
      "sha256": "6503cf005b7a29bc1dd614820846950eed46ed8c355257e384ccf2700e66a370",
      "size": 10918
    },
    "privacy/workstreams/advisory-deliverable-validator.json": {
      "sha256": "eab4553985d39bdb923f93e99af087dbcd1452ac8bac72436200bf3b76f873f1",
      "size": 25167
    },
    "privacy/workstreams/attribute-reporting.json": {
      "sha256": "f32a21609d337a07404fd3125bc87fb3e3d843985f163791a24c1f06561562ff",
      "size": 9084
    },
    "privacy/workstreams/brand-fit.json": {
      "sha256": "57b8cb4a03f6f45401223222671a4aa6ae3ba191e5ca1431deb13bc5bbcac877",
      "size": 9110
    },
    "privacy/workstreams/business-planning.json": {
      "sha256": "57aa13877b30b0ef5e9763ed2c57dd45ee39facb86896e92528a157fb61df87a",
      "size": 27840
    },
    "privacy/workstreams/claim-basis-map.json": {
      "sha256": "665282273c248358fc4e584ea6866aa27c4c89fa4dd78f92d58520f8008bf82a",
      "size": 6147
    },
    "privacy/workstreams/clara.json": {
      "sha256": "e0aadad8aa8daa9aa1da4b6431a766132c190d69e70611083d5d7a743a1a8a0b",
      "size": 16781
    },
    "privacy/workstreams/deck-correction.json": {
      "sha256": "a4b33b648dea20ae8e6e731481765923a426985ad61b7b05709e4c53d1e11b92",
      "size": 11565
    },
    "privacy/workstreams/distribution-analysis.json": {
      "sha256": "1fc80b9bcbfc73429c553574f64224915366722e0952c7a4631794993ff84b06",
      "size": 1569
    },
    "privacy/workstreams/funnel-analysis.json": {
      "sha256": "3baaab07aa60db95f921acc8d8d8c0a782e0956b8269eaacee395155cb02ee9d",
      "size": 1523
    },
    "privacy/workstreams/hosted-interview.json": {
      "sha256": "5c70b2f9dd6477d75420ab01f70c11f6ee56d87b9bffff03dbf782b057f002c9",
      "size": 7597
    },
    "privacy/workstreams/html-deck.json": {
      "sha256": "93e6c5b7f1db749331486469cdb1c5cb38771678e6ba7e5ef44cf7bc9bf91e98",
      "size": 10216
    },
    "privacy/workstreams/learn-with-clara.json": {
      "sha256": "820e10e0a25567e44c8397fcef533d14f0923f600d8fee36a3934d94db51b6e5",
      "size": 13790
    },
    "privacy/workstreams/management-control-pack.json": {
      "sha256": "a035c32b8983c7fdbfcb417f03d124b7443008e305e02a2ea788ee13e245f8d9",
      "size": 5600
    },
    "privacy/workstreams/mix-contribution-analysis.json": {
      "sha256": "54f32d676f053f2895a62ba0bb68e2eb764d7fea39949d75fe50bcdb2321bb12",
      "size": 1611
    },
    "privacy/workstreams/period-comparison.json": {
      "sha256": "8facae9f53032ced8053e9b4833c80ea8866a8330037eef18d6f36c7655272ee",
      "size": 1584
    },
    "privacy/workstreams/reporting-engine.json": {
      "sha256": "df3bc2a9e9481af04fa0748a48661bc91ce1fd7abd1957aa30c08881005263ff",
      "size": 21599
    },
    "privacy/workstreams/research-video.json": {
      "sha256": "8112c779a3c15a6617b4f7b65c4e82205aa458f3b1c6d63f36952333691f4240",
      "size": 15090
    },
    "privacy/workstreams/scatter-bubble-analysis.json": {
      "sha256": "d0ae24f3ba15cdeecb65dd3c318e51505189170134dedaed048b1d0cd55d73fc",
      "size": 1554
    },
    "privacy/workstreams/set-overlap-analysis.json": {
      "sha256": "7adc0f7077f168ad757bda925391b1738aa51a01179573addfdb14d9d9aeb313",
      "size": 1548
    },
    "privacy/workstreams/statement-analysis.json": {
      "sha256": "46b644794f14b35e8a57cdaed0a701271a616ded6e851703f521a4955831855c",
      "size": 1569
    },
    "privacy/workstreams/transcribe.json": {
      "sha256": "e9b497493a6c1cce998a3710626a009afce3a3587df29e030b4b517162124385",
      "size": 12661
    },
    "privacy/workstreams/variance-analysis.json": {
      "sha256": "91f3f7bc28f2cb79262ff6e70b0a4ae2fd4e8d5bbc294c4d6009f004dc07f03b",
      "size": 3887
    },
    "requirements-ocr.txt": {
      "sha256": "adbb5688c3b26acd30543ba3690caa731a25fbfb6365c18579845e117d9657bf",
      "size": 248
    },
    "requirements-shared-core.lock": {
      "sha256": "23421a8fb8dd2babda00115d9e753469165f3915af150f2638fabcf0b47247f5",
      "size": 50632
    },
    "requirements-shared-core.txt": {
      "sha256": "ff9e629a753fb17ec1b2e69559b2ed895ad7268da17336be94180b1a163d0971",
      "size": 1224
    },
    "requirements-shared-ocr.lock": {
      "sha256": "3445544b6e9728dd13b8ea955085bc75b434b72ed220bca888c480a6fa49989b",
      "size": 85275
    },
    "requirements-shared-ocr.txt": {
      "sha256": "f7ed4cf366005441e31cbd0dd81af078f770d8cf5e222e3e8a428c69d3289f8f",
      "size": 404
    },
    "requirements.txt": {
      "sha256": "b149c32297d506492d255ad4b2548bd7f75891b9f56514a52cfa15e7f33d6aea",
      "size": 189
    },
    "scripts/_desktop_teaching.py": {
      "sha256": "b4972f05a13c05552dcac0b549e3ac574e5e886ae5cac8a93860e0a23f6d1d46",
      "size": 519
    },
    "scripts/_locked_dependencies.py": {
      "sha256": "17f163c6da67a85213fde5537c9989cd027fd248fe402bda3f8d6668c03dafd9",
      "size": 2376
    },
    "scripts/_managed_python_runtime.py": {
      "sha256": "944934937a005693a026a1509054e21fd8c3cbb7883b55d767c879dae61ecb7d",
      "size": 34262
    },
    "scripts/_python_bootstrap.py": {
      "sha256": "ee0f842aea60acf7b5a6f530900591f72eecd50e134f70d410c8b57f0123b5a4",
      "size": 8032
    },
    "scripts/_shared_python_runtime.py": {
      "sha256": "b7d49042dfdfb06a9d0e5e16b8f2a4ec8c1d1b478aeec4720660b250ffaf43da",
      "size": 22598
    },
    "scripts/add_case_file.py": {
      "sha256": "5e72eabba1643e5a2b463ede06a9fbf0c7ac77f8ac37938ab8d5a4686154fed4",
      "size": 3694
    },
    "scripts/add_judgement.py": {
      "sha256": "719f0d765b4566bbaf24caad3c54cfcdbdbd9d446d3b2d00bbb08e129c6ca554",
      "size": 3077
    },
    "scripts/add_open_questions.py": {
      "sha256": "8234d7bed80a83ba696b10dc62efce126913f421ce8d811969443d6a09ee8283",
      "size": 3708
    },
    "scripts/advisor_case_core.py": {
      "sha256": "1102874a9103ce3aa8efb16679b363fe5b25b2df53c92f0091d1815a4e942108",
      "size": 310029
    },
    "scripts/advisory_delivery.py": {
      "sha256": "877d87df4bc1d5b2322e3b96bfc86fd86d6fdb1a7a288ca84f439e104d2c71e8",
      "size": 17052
    },
    "scripts/advisory_evidence_lineage.py": {
      "sha256": "958a516f4341bafecd8fabafa4e848fed2e7b52d3bbf8f3f07292048261e3009",
      "size": 44839
    },
    "scripts/advisory_lineage_labels.py": {
      "sha256": "2ad7c96dee1bd61d76f578bfef1dac2f90d3b7ab8d72e0a355dce4ebed44d934",
      "size": 13067
    },
    "scripts/analyze_deck_revision_materials.py": {
      "sha256": "d619d0235be9ffe41e0aa70b583fd7fc071b281b0ccac28c63ccff7a4db9ad75",
      "size": 18716
    },
    "scripts/apply_deck_revision_plan.py": {
      "sha256": "68f48e221fbaecb76851755160c224aea7bc529e75251cb3775a8c079c79fb3d",
      "size": 35671
    },
    "scripts/apply_inclusion_bundles.py": {
      "sha256": "743454d3bd3a6114c7b008bff58ff0e2cfdb0c08df7139e982253340a891efc2",
      "size": 2532
    },
    "scripts/approve_deck_revision_plan.py": {
      "sha256": "066673b928fbbf8a276be2e1d4656d6b783c1ea1df2ce9f647c95b9eafee778e",
      "size": 10548
    },
    "scripts/approve_judgement.py": {
      "sha256": "33bda5ae173803eefc0b12abee0ebe3b916e15b142b467794ed263cf99de39d9",
      "size": 1275
    },
    "scripts/approve_judgements.py": {
      "sha256": "31c259c97fdf447b213a95d34cf2899dc349347e2f96f3af895c7165a4d628ea",
      "size": 10935
    },
    "scripts/archive_cli.py": {
      "sha256": "e96d672fd62106622063a78f47c416ec35fa74bf16f6cdaa3ac7d4c49c4664f7",
      "size": 8876
    },
    "scripts/archive_emit.py": {
      "sha256": "e6af4a0b8ac814638f85541cd18d9841760ca7f0410e8039256b92521c72416a",
      "size": 9154
    },
    "scripts/archive_projection.py": {
      "sha256": "96dfa605cce28df808400ab76dab98cd3c27d7ae7fd71c343ea56dd8f7b3027c",
      "size": 19380
    },
    "scripts/archive_report_legacy.py": {
      "sha256": "6dadb7f05b50afb13f7d23cde1e0e6a0748ad850a7df7dadace66f66cf96098e",
      "size": 11744
    },
    "scripts/archive_report_measurements.py": {
      "sha256": "dc6776113459131fbf756dbd8882e622c9441e80200ece7f64f24b259eb94118",
      "size": 11772
    },
    "scripts/archive_report_receipt.py": {
      "sha256": "04758e412e1dabdbd63f0b8de8f6018077a00c642a235ac869351df24039796d",
      "size": 12713
    },
    "scripts/archive_report_seal.py": {
      "sha256": "a74fc59815602ed9a3ee3ff7d31d2cdc2989a7f106a29185767750990f88649b",
      "size": 5245
    },
    "scripts/archive_report_store.py": {
      "sha256": "916017ea711652bf12d885725b50a8cc168a2624e7f5ad4cee12297f73822186",
      "size": 19776
    },
    "scripts/archive_reporting.py": {
      "sha256": "67013369177f82f56645f5529fb604cc6ee044def8bceef12a36db94e3607b6a",
      "size": 36271
    },
    "scripts/archive_reporting_failure.py": {
      "sha256": "3a618de9edb0678412ba6d5d47ddef5ccfdcb9f022cf81055647e242d94fff24",
      "size": 3429
    },
    "scripts/artifact_publication.py": {
      "sha256": "1e5b1b09bf101c9be781f82123790954ad06db62326bc1be1c7619625c899ced",
      "size": 3557
    },
    "scripts/auto_attribute_hosted_transcript.py": {
      "sha256": "1bd1a85dd8f64e7be9f698bcf3f9df290e4c9135482c090a936a105276fa3566",
      "size": 20618
    },
    "scripts/bootstrap_python_dependencies.py": {
      "sha256": "3e7536db5e75ea6796673e545dd567dc6c30ea604d0f49770034dddd7c1c5533",
      "size": 4044
    },
    "scripts/bounded_process.py": {
      "sha256": "e409460e7df27d1fc89df5d2908c6ff3b438420d1c0bd1a1b4c9e4ce7de0ea3b",
      "size": 3494
    },
    "scripts/build_case_brief.py": {
      "sha256": "517da956e087df1121002971c31dd3acc2c6f3be986be5fceeb96398d7e9a1fa",
      "size": 1757
    },
    "scripts/build_clara_kickoff_deck.py": {
      "sha256": "f7bdf18c0f2c8cd1a2db9f7d873398dde26ad5241e93729b2902824f4c04c972",
      "size": 1803
    },
    "scripts/build_clara_partner_brief.py": {
      "sha256": "b1d88d99947187f8e29089666d0978be2b8b1e409ff7b834e9f46fed6cea877c",
      "size": 1806
    },
    "scripts/build_decision_pack.py": {
      "sha256": "290816d360f8d17654f6ba93e91c6020fb29d537fbdcab2cc04317feed733786",
      "size": 1893
    },
    "scripts/build_deck_revision_execution_packets.py": {
      "sha256": "aa888eb6776800297fc90a9f617a306732fc281413823f0ca7a24f295dca3067",
      "size": 21940
    },
    "scripts/build_deck_revision_execution_plan.py": {
      "sha256": "fcc3707a7d7eeab55ef4e754f657c2f2120c1497657907b4f5dc7bfc7a9f4033",
      "size": 14021
    },
    "scripts/build_deck_revision_interpretation_packets.py": {
      "sha256": "61fed12e4f43e821eb69cc3b2a1354d5752ac5ed133ded11a9d55209124bd3ed",
      "size": 17822
    },
    "scripts/build_deck_revision_quote_candidate_matrix.py": {
      "sha256": "e8855ad6f298f414c4c0d59aaf4f16860dbf704745a08fc09ee80f658243f6cf",
      "size": 17389
    },
    "scripts/build_deck_revision_workbench.py": {
      "sha256": "9ae9564d4f913d67af7deb27ca289e127ea7fd8858300948930b37df1c2c1c0e",
      "size": 36308
    },
    "scripts/build_inclusion_review.py": {
      "sha256": "6bcc76433ce9602746bf1b50de202668335c55cda87db6b6c8d82f8e0864501a",
      "size": 2099
    },
    "scripts/build_public_truth_audit_envelope.py": {
      "sha256": "cb497451e6d5502c7027760a720d224fe872008efe38e8e51eb0513c344565f4",
      "size": 21431
    },
    "scripts/build_real_data_pilot_error_summary.py": {
      "sha256": "2e09c688910f46a82db9881e2789a5c33eea25d2101d64917721aa010cebf750",
      "size": 33534
    },
    "scripts/build_real_general_ledger_audit_envelope.py": {
      "sha256": "8822298cb91005b58c88e71eeeb929baef379491f93c0a12ccc9da327a831d1e",
      "size": 46338
    },
    "scripts/build_voice_feedback_timeline.py": {
      "sha256": "9421c1e2cefe599a25a15490e1b792005220d69019b9cab327cf2c66e9a0619b",
      "size": 27183
    },
    "scripts/capture_advisory_web_evidence.py": {
      "sha256": "4fa2abd98b581cc0fac46b77b158baa43dc1fdae03ad51fb24823e246a6eec08",
      "size": 10713
    },
    "scripts/case_exchange_safety.py": {
      "sha256": "8aaa910146d7accdcdb99ab793fb2c3e59585697d5d9284aab8946a2de7c35e3",
      "size": 5591
    },
    "scripts/case_store.py": {
      "sha256": "46f7c0295caadc811e36a341404ff6f1d7bee5b803dc0c18281a9be24bb64dc1",
      "size": 8672
    },
    "scripts/change_requests.py": {
      "sha256": "0e39b7acd69e0c374e50a34d3eb58acf5abe8a243de571e46485dc9d1beed63c",
      "size": 55963
    },
    "scripts/check_change_requests.py": {
      "sha256": "7c402fd323145342c40678fbfcc78c1cc0021717a6149dc55a69ecb0a613acd4",
      "size": 848
    },
    "scripts/check_dependencies.py": {
      "sha256": "d104fdd6c54e52f09e42f63fdbb6254a901cea1a79ef5f4ae65c467c990e514d",
      "size": 14033
    },
    "scripts/check_for_update.py": {
      "sha256": "76ba154b77b43e280f550bd26c9ff194dedd29320978ce4f71306ec812f1590f",
      "size": 9285
    },
    "scripts/commit_advisory_workpaper.py": {
      "sha256": "1a3f0ea7271385efc38cd7d4ae7ceeb814766b73045c3ba851194c6ea2cf24c4",
      "size": 2107
    },
    "scripts/commit_decision_narrative.py": {
      "sha256": "12a4e046d0f9af44d6d3ca21bb1088e3c8f1868f509898a836877ca0d3a60470",
      "size": 1860
    },
    "scripts/complete_deck_revision_output_review.py": {
      "sha256": "55efcc9bacf86e432aaa136c257355430c6a61424022f2ad70d7d32324a3fc3f",
      "size": 15731
    },
    "scripts/course_chat_bridge.py": {
      "sha256": "dc16232b7f072a81de4c2aa1659706da90166e548e43a48ff5d1962001601ada",
      "size": 1237
    },
    "scripts/course_chat_mcp.cjs": {
      "sha256": "47f287062575db4e69e7cb40f876ada88937d84ec91ebb5d6dcff5bc34cc2d8a",
      "size": 348
    },
    "scripts/decision_narrative.py": {
      "sha256": "d596dcb192db69e8ca32e511f99aba371328260ddd916e77c7b7d250b781daf2",
      "size": 3330
    },
    "scripts/deck_revision_execution_contract.py": {
      "sha256": "5088e508561027979ed3fce8c758cdbcf1277a0d1ffdd4fb45c6c4eb3035fe3a",
      "size": 2158
    },
    "scripts/deck_revision_text_match.py": {
      "sha256": "ca3c2f11197f17727f5bb98d37482fa5bf204ae3b44fb08cacbbb9facc15263a",
      "size": 1107
    },
    "scripts/delete_material.py": {
      "sha256": "40cca4a2c067ee7e928131771e74ddc411c694677445547c7526288bea3d0c80",
      "size": 3350
    },
    "scripts/diagnostic_context.py": {
      "sha256": "60583a020186eb9baef9000f9974694d1ee9207d035742200a682f57591ad153",
      "size": 1451
    },
    "scripts/export_case_update.py": {
      "sha256": "34497af0cfbca51d8b561c209594fcb951117a226b77e10368ab12fb33368f11",
      "size": 2182
    },
    "scripts/export_case_workspace.py": {
      "sha256": "9bee0920b913bcd150529130604319af5bb145c4457b51fb0a6ca848281ce46b",
      "size": 2208
    },
    "scripts/finalize_deck_revision_plan.py": {
      "sha256": "d20c0aa909a3423ab635fd2a75ecdf5ec68fcecc559c730a1ef5b5a3b8fb27e8",
      "size": 41003
    },
    "scripts/finalize_hosted_transcript.py": {
      "sha256": "3aa94262c8139745e394c2bf8234292028a085f20220df76dd61558f3eeca0fe",
      "size": 21522
    },
    "scripts/html_deck_runtime.py": {
      "sha256": "a4585f10b456bbc44513873c430c58bc3f40351a69646b2e255e14861ace6d21",
      "size": 14806
    },
    "scripts/import_case_update.py": {
      "sha256": "ecaf008f915081e8932487194f7c3774f5ccb8461627fadac91a9b9bc7f8397d",
      "size": 2245
    },
    "scripts/import_hosted_voice_bundle.py": {
      "sha256": "ed283224bad95bfb500205b7d8590df8a91eee1a4f06195bddd58d66d789af42",
      "size": 57594
    },
    "scripts/import_hosted_voice_bundle_to_folder.py": {
      "sha256": "48b11f2718f0c9aab778710dbc71d4c723d81fd3c5bcde0fae75810da4e07279",
      "size": 45506
    },
    "scripts/import_latest_hosted_voice_bundle.py": {
      "sha256": "8e2522669da7c108e28853bc724ae69d523523e6c8b3112c42036cfa0fd3c5d2",
      "size": 5825
    },
    "scripts/incident_host_mcp.cjs": {
      "sha256": "f4e3913af0c1a7d4f3a5fd2b25ffcc43e7b39e33529e72f8264d7b0b89f86128",
      "size": 14125
    },
    "scripts/incident_tool_schemas.json": {
      "sha256": "b03e28ab99d71867fa61d1fb2f68f9ec64ea908e0703ba6744fda2147b4b093b",
      "size": 26789
    },
    "scripts/index_materials.py": {
      "sha256": "b9b9d4fb259500abeb26afe0c48ad48f4abc65857736a2fb01c4559b31dcee9e",
      "size": 3140
    },
    "scripts/ingest_notes.py": {
      "sha256": "3cc11da20071c12cc7e9595386d874b1f103f735ac336d50618df2d083f70bf9",
      "size": 2066
    },
    "scripts/init_case.py": {
      "sha256": "cf7ca3c6e63e240a15f6c11aa87b3354a4efdc0eca724269990233b89e924edf",
      "size": 2133
    },
    "scripts/integrate_transcript_review.py": {
      "sha256": "d6873e69bcaa63db45217236dba6b45ebb260459c4bcd644e237ae0581c5a993",
      "size": 20617
    },
    "scripts/launch_hosted_voice.py": {
      "sha256": "bf73a10f86a388df87737528b9debce56b453a5d1cfa9d70665b85ed688b74b6",
      "size": 13554
    },
    "scripts/local_courses.py": {
      "sha256": "b49e56924b9206a393ec4b9a1294ef84183f3e117971a6375e174ed45f6a11d8",
      "size": 920
    },
    "scripts/local_helper_environment.json": {
      "sha256": "211b9d29c8085fdcebd89ee6f6ef4ea92e368adf07b35058a8aa67b503c70a01",
      "size": 318
    },
    "scripts/local_helper_environment.py": {
      "sha256": "c6352dad75af89133af337159dd5aafcab89c1b21bf55c0c77133321e9d1d0fc",
      "size": 1055
    },
    "scripts/local_onboarding.py": {
      "sha256": "c818e87fd7ad5370b125dbd9858137eb58abaebcd195904f8812bb8ad8c3eedd",
      "size": 595
    },
    "scripts/local_onboarding_case.py": {
      "sha256": "829faa6e911e9ccbdc475e018af48420c65143a86917f037c483725afb6469bf",
      "size": 360
    },
    "scripts/local_teaching.py": {
      "sha256": "fb8966e64495411a3b5204513752d443456f1b99aef500edcc1ad53f6a67befe",
      "size": 637
    },
    "scripts/manage_hosted_interview.py": {
      "sha256": "704bc2c8ede2ec5fd78e35967f72acce18eac2ddf27bd52bcb3df8b6930c9f5b",
      "size": 22914
    },
    "scripts/managed_ocr_runtime.py": {
      "sha256": "52b9b0a70ba50f4145407c6c8dc075f19ae94239e77c5521e96c48fc5982b91a",
      "size": 7646
    },
    "scripts/managed_python_runtime.py": {
      "sha256": "0f6bb7331551e626b498fce93f43951a325c10541a5b458e0c4144e8158ee3bf",
      "size": 19949
    },
    "scripts/match_feedback_frames_to_deck_slides.py": {
      "sha256": "05bcb9f30b23e97b0b54907296943c72120040c2d95de422b5ac3b0440b96fda",
      "size": 33671
    },
    "scripts/mcp_service_client.cjs": {
      "sha256": "d26d891c0448ece8f2eba6a4cd18c9b14c7fac81b550fd33734bd9b1a7e311a8",
      "size": 4196
    },
    "scripts/media_publication.py": {
      "sha256": "4a3870720448f8f9e0974c3ad986e0d6e077ad52186b8ecd42ab9c44421f162a",
      "size": 1227
    },
    "scripts/model_data_report.py": {
      "sha256": "7a0fae4f7981674d31e34bb5cb94a8aa86830f495f554393b5fd151c13a81f14",
      "size": 51452
    },
    "scripts/normalize_legacy_pptx.py": {
      "sha256": "e18103f3fce1a90279eb778aca0e59714575b692c533a730962577ab4c618041",
      "size": 3050
    },
    "scripts/notarized_run_receipt.py": {
      "sha256": "6b8cbc5b08a4c23271de61074f5fe435107c8afe3e648f117baba9f0cdfdab5f",
      "size": 46596
    },
    "scripts/on_demand_mcp.cjs": {
      "sha256": "b175109752e7611776e5d424aad29ff4d1678a9e077a8993f892dc50431f6b54",
      "size": 6881
    },
    "scripts/onboarding_session_start.py": {
      "sha256": "cb6fe047a7029c4d77b60872555507bc23e07f1279038d7ad772fa577b5364a4",
      "size": 2133
    },
    "scripts/operational_incidents.py": {
      "sha256": "686ed0140b970aff8b4314a3e53a13e202b1c80af91a95f949613f33f36342d1",
      "size": 95994
    },
    "scripts/parse_commercial_general_journal.py": {
      "sha256": "9ee7b702f494bca21193216afdc889f181a87cff6becd6124d29e2b5c3427b49",
      "size": 105083
    },
    "scripts/preparation_contract_kernel.py": {
      "sha256": "6219f334d6cb97369816bfb3cb11a073f057419d4e238adb6f02f22f5cb6cd91",
      "size": 77774
    },
    "scripts/prepare_clara_kickoff.py": {
      "sha256": "58836f4f6b5dca49be99f27ea887bfdec4db262bec54999832bc42225b05a4b8",
      "size": 2645
    },
    "scripts/prepare_editable_pptx_merge_input.py": {
      "sha256": "b31c7a8b2134bd91bb1a0c2d747566ad640db6a5d8007045a7b4ab2957b7e3ee",
      "size": 2630
    },
    "scripts/prepare_support_package.py": {
      "sha256": "8639a077b0c6fe12b49f676dd7dc785c4c450911184b62d42af743244ce1c960",
      "size": 2569
    },
    "scripts/prepare_voice_deck_revision.py": {
      "sha256": "8d9a22820537a5e2b6aec0f8fd5c74af2f36a15a24b8905c221ef3909dcd68cc",
      "size": 37808
    },
    "scripts/privacy_contract.py": {
      "sha256": "08116da007761d983c5eaead355025e9ba299d20dc31821044f402da1bcab594",
      "size": 8491
    },
    "scripts/public_http.py": {
      "sha256": "0320cf3b5407c0805c453f2f81918c29b1eb33c32d7384855d5b39d2ae09c073",
      "size": 9222
    },
    "scripts/real_data_pilot_output_boundary.py": {
      "sha256": "341495c7abdec121607d1ad48a0b5c61cd0297c0c2f76aae4d8c46e17d49df6d",
      "size": 17423
    },
    "scripts/record_analysis_contribution.py": {
      "sha256": "9134df6c408a78eb8404f13ff3758bda26c2ca98e25d1822700f6f7e8a125db4",
      "size": 2996
    },
    "scripts/record_case_direction_return.py": {
      "sha256": "9bc960fe45ba6f8ba0e6a5dc19b35f40342d3bc318873d1a257c4257193c4f42",
      "size": 2067
    },
    "scripts/record_reporting_contribution.py": {
      "sha256": "05f0d8e338742e9b04ba98f9e4af4ca336354aea7c40fc16579f177d2b10d4e2",
      "size": 11949
    },
    "scripts/render_attempt.py": {
      "sha256": "285cc895314be9d76f145c2a86d0c493a9b958dfbd3126be433aafd002517eac",
      "size": 3261
    },
    "scripts/repair_audio_pointer_links.py": {
      "sha256": "bea98821df1d30cd78b4f14587846890f22884e2aee500f7eb0c882efa0a3a74",
      "size": 9904
    },
    "scripts/report_mcp.cjs": {
      "sha256": "d279a1d47130b5bd8cff393aa9772ff7b2958fdd419c423845a590e347aafd75",
      "size": 1128
    },
    "scripts/report_mcp.py": {
      "sha256": "2f602685fdc76252f309a5e2da3b89d5b57a5480619d88963b3cc63b275a021a",
      "size": 7734
    },
    "scripts/reporting_product.py": {
      "sha256": "452fb73fbc25ee5918e68fcc969dbb6fe02f05557ceafcaa42f49d00f5b1d74d",
      "size": 1727
    },
    "scripts/run_clara_deck_benchmark.py": {
      "sha256": "109eee8d30426eb97aab0c6d0228292e3e499b5015b73ecdbf760275044b8e00",
      "size": 89480
    },
    "scripts/run_deck_revision.py": {
      "sha256": "44ffa92de9dd6005677595b00f44915aa001bb8fcbe4590abc950de9a9a6e098",
      "size": 14349
    },
    "scripts/run_deck_revision_fixture.py": {
      "sha256": "c11a2bfc7b6fd346cda7ecba756ba04d4ef89482fbf7eb18dd5ed8d9fb5339d0",
      "size": 14213
    },
    "scripts/run_real_general_ledger_pilot.py": {
      "sha256": "8ceb25e32a39bdd0d7ff915178924ad37bd4a93038f10d90d9dc356b07b2afba",
      "size": 56631
    },
    "scripts/selective_reporting.py": {
      "sha256": "3c99afa7d416625bd94d1dc0aab41ea354df662f0362098f3b431a57fecba8ba",
      "size": 1194
    },
    "scripts/self_relaunch.py": {
      "sha256": "f21a4772861f7626003343b9dd1b1e7062f00ad643f707de657b1c4fb4cf5751",
      "size": 2404
    },
    "scripts/start_deck_feedback.py": {
      "sha256": "608f63e705eedcb0e3b43af6ff624ab8f05587fd3d4f41ff21168564f61618a8",
      "size": 12596
    },
    "scripts/summarize_html_deck_benchmark.py": {
      "sha256": "1e792dabdf0398d79f2b40ebb085e56525d4e5e492eff75020f076db2c434a25",
      "size": 50747
    },
    "scripts/technical_runner.py": {
      "sha256": "6a3aecebda21501a690664702ea733dac0ca38c2893ae90d7bb9b20f91625971",
      "size": 10379
    },
    "scripts/upload_hosted_audio.py": {
      "sha256": "439c6d0c453b51285cdc014fe7e17aec109c27fec345173930e866e4386c25c6",
      "size": 37058
    },
    "scripts/upsert_case_issues.py": {
      "sha256": "7101a636234498038f84ede9385ef9d62f9868105758b1c5efad85d598dd83a0",
      "size": 4549
    },
    "scripts/validate_advisory_contract.py": {
      "sha256": "e4d5b2f7cb0bccba36454510bd6cf554e04b3b003eedb6755a25047152f10ac0",
      "size": 22828
    },
    "scripts/validate_public_truth_benchmark.py": {
      "sha256": "d67083f3335fe459aa9eff6d59b064ef921c2717eeaa8188596e3b3ee5f3ccbe",
      "size": 28036
    },
    "scripts/validate_real_data_pilot_intake.py": {
      "sha256": "74f9277e63917895f673868bd5ee596660375b7df6105915f7922a4278490089",
      "size": 58867
    },
    "scripts/validate_real_data_pilot_mechanical_errors.py": {
      "sha256": "5269a54c73d491d4129f83a91f8fdb4f79ddda8dae763248da52182786cd54f9",
      "size": 27318
    },
    "scripts/validate_real_data_pilot_semantic_review.py": {
      "sha256": "5f1e55790b7e25ba5f35fd20ee3d2c4c0924889634c15c485568a6b85c6b8edb",
      "size": 36098
    },
    "scripts/validate_workspace.py": {
      "sha256": "aa123af4008591dc1640521974574d7d18052a6606d7f5ecfad861a0b330c1d6",
      "size": 1673
    },
    "scripts/verified_execution.py": {
      "sha256": "3f66afd2e1c7004111bb3137cdf4367b759a7f4534de0c38957be67faec8ef01",
      "size": 46712
    },
    "scripts/verify_advisory_delivery.py": {
      "sha256": "1db20ac24cadf936821244631b51bf6187258efb269c745d61fc6c6261fe950a",
      "size": 1147
    },
    "scripts/verify_advisory_html_delivery.py": {
      "sha256": "771dec6416bb5bd0eb2453caed09fbd9644c1386dab1c187c1d2b859e377d8ef",
      "size": 2406
    },
    "scripts/verify_decision_pack.py": {
      "sha256": "9c32fa783af5d65223d284c7b6c23e551d2c92265a0f4f6efc8c0f31eaa4cf83",
      "size": 1890
    },
    "scripts/verify_deck_revision_output.py": {
      "sha256": "4cbe678ce65a5d3f5a65c23b74450184e1740b9e0b967b5b9b91e6c778f3e436",
      "size": 23897
    },
    "scripts/verify_mcp_package.cjs": {
      "sha256": "aaec0746f25fad9cf9994a7be54924a8c5e89003220195294faa8318ae58de5d",
      "size": 6233
    },
    "scripts/workflow_usage.py": {
      "sha256": "05e255a7b363e142f0cab187afc9f4cd39b633019abbc508f0f5d6edbcb00ad0",
      "size": 27263
    },
    "skills/advisory-brief-planner/SKILL.md": {
      "sha256": "226d3feb079e9b0cfd8886f607fd64d21a202d8e13fe5545f81ddf67ae44f4ad",
      "size": 16551
    },
    "skills/advisory-brief-planner/agents/openai.yaml": {
      "sha256": "72835e093527184b4ab5df8ddd396f54dee7bacd3b7e18ab2e80555d4ccecd1c",
      "size": 285
    },
    "skills/advisory-brief-planner/references/advisory-contract.md": {
      "sha256": "7e87617d089443530c384c7713a09e78ef1f64d5c6b04e5d890d89e4e47391a6",
      "size": 7017
    },
    "skills/advisory-case-director/SKILL.md": {
      "sha256": "f68aea95d06ef3818bb46449edccfdb5dd0ffe4b369a2c3faae373b98820444a",
      "size": 23251
    },
    "skills/advisory-case-director/agents/openai.yaml": {
      "sha256": "ba19c16d32453c8f79e260117c964dba9cc77dae9e148308da37fbd047bddf9d",
      "size": 265
    },
    "skills/advisory-case-director/evals/case_direction_cases.json": {
      "sha256": "fde4735ac17d4d8be5a62057ddcb1d325cb56ba048d3107c43161b95901a63a8",
      "size": 6764
    },
    "skills/advisory-case-director/references/case-direction-return.md": {
      "sha256": "b7a68ee800a7825298dbe645d49a21f3e41b764ae6feb310968989e70ecad5b3",
      "size": 4486
    },
    "skills/advisory-case-director/references/operating-model.md": {
      "sha256": "db2f2f43c3bffbf0f53323bae5b64000a1b04971b519402f62e0c4115a3db395",
      "size": 8984
    },
    "skills/advisory-deliverable-validator/SKILL.md": {
      "sha256": "a958c0d3d6b4f978f73dc2ef7163b3019f28549e1278e00c30845fa187a5f7ca",
      "size": 31467
    },
    "skills/advisory-deliverable-validator/agents/openai.yaml": {
      "sha256": "fe37dbe19ea450dd59f0a529cbc552f368bf74b39619debe8556ff0e64bed944",
      "size": 474
    },
    "skills/advisory-deliverable-validator/evals/semantic_validation_cases.json": {
      "sha256": "d769d19538f5aee9817fd9586e75a99ac24991a28d73920aa40dcdc437acec01",
      "size": 12196
    },
    "skills/advisory-deliverable-validator/references/advisory-contract.md": {
      "sha256": "c34fc34c7a642dc2e08f02c9fd4bc1038f559ccb14114f8a2127fa4d1e71dd79",
      "size": 5117
    },
    "skills/advisory-deliverable-validator/references/advisory_validation_review.schema.json": {
      "sha256": "cd2ec050ebbb26ce41e8af0e7498befb381ddd6939d41edc3738a3b2a11399f5",
      "size": 15156
    },
    "skills/advisory-deliverable-validator/scripts/advisory_review_render.py": {
      "sha256": "0aed18e4209aa68d5caedf2cf1b3136a4d6a7caf86dd4fc5bf8a844a2c0e6783",
      "size": 21314
    },
    "skills/advisory-deliverable-validator/scripts/advisory_validation.py": {
      "sha256": "d32fc7f1c14710aa0346f549b1814ae6b6b18ce3340dbbe3e5eab20ff34ed1e4",
      "size": 110423
    },
    "skills/attribute-reporting/SKILL.md": {
      "sha256": "0f6552a7f3022ff0ba491e16cc0a503100682062e70c12ff9057170f142567ab",
      "size": 5642
    },
    "skills/attribute-reporting/agents/openai.yaml": {
      "sha256": "0f9237f5c3b5771fc3ef509ba770ccffa375a1733cfd6dd042c0f644209832dc",
      "size": 355
    },
    "skills/brand-fit/SKILL.md": {
      "sha256": "bcc076cf716a808bfd0a056fae6f37413c6065d5689f1183ee628e3e7d7e9b1b",
      "size": 5514
    },
    "skills/brand-fit/agents/openai.yaml": {
      "sha256": "af9bd10b208edc4e81b8592cb939ac5065ed937264730fab90fbccd740f3c4a0",
      "size": 359
    },
    "skills/business-planning/SKILL.md": {
      "sha256": "7d573d9ec382e0b24db35c35d81a64aaaffb71fd4ea53b7eed4daedc27bcab0a",
      "size": 5234
    },
    "skills/claim-basis-map/SKILL.md": {
      "sha256": "a31d3f3c32856f1c4e5fa49f44284c04ddc5b563554574c7c054b1a8948d9c88",
      "size": 15355
    },
    "skills/claim-basis-map/agents/openai.yaml": {
      "sha256": "7a2d2f7f48c9a8a94a386dc2b87dbf3241fccb192b4dba4043057ccffe96db0e",
      "size": 316
    },
    "skills/claim-basis-map/scripts/render_claim_basis_map.py": {
      "sha256": "5575e9917bb4ebf52278b83de7e3c24cefe6c80e7f0bb0da3cd4405f404d97aa",
      "size": 37658
    },
    "skills/clara/SKILL.md": {
      "sha256": "40f850e57f5b05164f3972bbf94991136db3f9af27481aac8cc91d97238a5063",
      "size": 35798
    },
    "skills/clara/references/case-operations.md": {
      "sha256": "4f5d1c225b895a88d62e2cd36cdaee2070e7ad72f7177c473f9f3788aab75bc2",
      "size": 44195
    },
    "skills/clara/references/cowork-runtime.md": {
      "sha256": "b4e0d0dca102830bd71bed9a28b6145ae70d2099246daf0db171e22556ed5b97",
      "size": 10085
    },
    "skills/clara/references/incident-recovery.md": {
      "sha256": "273127ae2c142ad1e0d0abb78e9fa78696bdbd5425b82d8578373963cad88f77",
      "size": 22051
    },
    "skills/clara/references/local-onboarding.md": {
      "sha256": "7a4d0c6de74151f5e4256c174945ea16b9d6056f620b24007a5152e4d4a02574",
      "size": 12873
    },
    "skills/clara/references/model-data-report-contract.md": {
      "sha256": "24a6f34082e24ac4affb0d5c585e9805620802097fae6005d99c8061b1cfe56a",
      "size": 19725
    },
    "skills/clara/references/public-process-page-contract.md": {
      "sha256": "64f8f2b729b4b1c8470539ea7405d2ae51dc1035cf02fd82ab9bc55ce7ac3b43",
      "size": 3876
    },
    "skills/clara/references/tutorial-cases.md": {
      "sha256": "289949dff2927469fc96866142732f277b3ddae9d95bfaf020df9fe57c7aa8bb",
      "size": 3211
    },
    "skills/clara/references/workflow-catalog.md": {
      "sha256": "07de6bda987ccaa6367f567f5d52156f685795aef2fad745b41dfc8bc7ef203d",
      "size": 5128
    },
    "skills/clara/references/workflow-usage.md": {
      "sha256": "87d748ba6c81c2d88aa5e913a993e3e5681805703cd98450c1082ac42b9f4afa",
      "size": 16640
    },
    "skills/deck-correction/SKILL.md": {
      "sha256": "5b682315f229ffc5e138060010f8ba93e97128bef5f9863b30891fc2a90de3f4",
      "size": 19895
    },
    "skills/deck-correction/agents/openai.yaml": {
      "sha256": "90581f521d68cda21d50472d88701c1842a2c619b53caad2e7c3140031265af4",
      "size": 384
    },
    "skills/hosted-interview/SKILL.md": {
      "sha256": "81b959e3947a3e8cf18fb408b31a2329b295c877fbbd0b8b22fbce958c065390",
      "size": 13603
    },
    "skills/hosted-interview/agents/openai.yaml": {
      "sha256": "3f0c5924cc0f51d0e958d6f8c655bda553edc7438248a7a781848ac063e4a9b5",
      "size": 321
    },
    "skills/html-deck/SKILL.md": {
      "sha256": "6a9a8233ba428b218117cbe929ce934644ea6486915a1561e8c855997eb5ea28",
      "size": 18300
    },
    "skills/html-deck/agents/openai.yaml": {
      "sha256": "ad54daac86f93a5c334a0b6e69ddba3a81f74e28ff7cc7bd5300667bbb750012",
      "size": 344
    },
    "skills/html-deck/assets/deck-engine/deck.css": {
      "sha256": "2e381434ad20806b55ebc9e103be0adc74461fca07a547d1fbbacb7871454104",
      "size": 27588
    },
    "skills/html-deck/assets/deck-engine/deck.js": {
      "sha256": "5f2307d9e5f7f04f1bc77c37c17b22df4f298f1f7b6769f3645d1de4f06fdc6b",
      "size": 13996
    },
    "skills/html-deck/assets/deck-engine/shell.html": {
      "sha256": "b1472c38def80937deefebd3546cafa71b6ec1d233022b284eb0d2ea1cd65916",
      "size": 3086
    },
    "skills/html-deck/assets/deck-engine/starter-slides.html": {
      "sha256": "852525590db8d2bf6f5a497802b75dcfd9169d99a44f9713bbe910691c4c9286",
      "size": 10828
    },
    "skills/html-deck/assets/layout-library/layouts.css": {
      "sha256": "78ba619c4f8bf23be92b7c17c8064625cea6e891aaab6b027be7e5f4b8556568",
      "size": 10613
    },
    "skills/html-deck/assets/layout-library/registry.json": {
      "sha256": "23ac1b3e5acd0793ddf7baa6628558ee29fc0f6253eb69f5afefc45fdf1cde58",
      "size": 20736
    },
    "skills/html-deck/assets/layout-library/starter-deck-plan.json": {
      "sha256": "b602565d9709f00c2ee508d43b0415db9ed733e11e5fa5f3c060c653dcbe20f9",
      "size": 3094
    },
    "skills/html-deck/assets/layout-library/templates/assertion.html": {
      "sha256": "0c64d4ba1c65912ca729de4f665534bc0b18409c1857858523dd04997690c5c8",
      "size": 622
    },
    "skills/html-deck/assets/layout-library/templates/chapter-transition.html": {
      "sha256": "234b1dacecf13755bfce112a5ada596d497e5ccb36a635b925e8ff8445504c04",
      "size": 505
    },
    "skills/html-deck/assets/layout-library/templates/closing-decision.html": {
      "sha256": "fca053937eebe00099e07bc2e9d9054ac35f6e31d734ef6a915f4177e6eb2425",
      "size": 535
    },
    "skills/html-deck/assets/layout-library/templates/decision-gates.html": {
      "sha256": "9bdac2376b0793ab2a1585bfe4b454b711d30ffd80caaf9524a172e4f5e9816a",
      "size": 417
    },
    "skills/html-deck/assets/layout-library/templates/editorial-cover.html": {
      "sha256": "00fd821bfbd639b22bc00751aeb67eb571f02071e5f02f6526c3feab7d179bb2",
      "size": 591
    },
    "skills/html-deck/assets/layout-library/templates/evidence-register.html": {
      "sha256": "1d9504cbe07bcb4199e1b03bb8b9628285b320fcaee50e99188c6814c58657c3",
      "size": 434
    },
    "skills/html-deck/assets/layout-library/templates/evidence-split.html": {
      "sha256": "caa1736637d1bf48426a08dc820f9668273e76a92a5de89d9e079045fd94d090",
      "size": 1002
    },
    "skills/html-deck/assets/layout-library/templates/image-led.html": {
      "sha256": "d565f5dfcba9fa3559c4d8b407ac68ed54006a59e03ae9da5b2e10a977fc024e",
      "size": 690
    },
    "skills/html-deck/assets/layout-library/templates/items/closing-action.html": {
      "sha256": "1c45a8a47cc2704bc885293a2e401c53e842c0f2503c9ac5bc0617db445b3c8b",
      "size": 216
    },
    "skills/html-deck/assets/layout-library/templates/items/comparison-point.html": {
      "sha256": "8729b5dbbe2ca0be688507d8d62205985155cac8ead95cc784692faa1e632238",
      "size": 199
    },
    "skills/html-deck/assets/layout-library/templates/items/decision-gate.html": {
      "sha256": "eaf6cfb5ca5d1ef70f4664099f0b5b993ef5acf06e45561b57ded0b334df41eb",
      "size": 238
    },
    "skills/html-deck/assets/layout-library/templates/items/evidence-entry.html": {
      "sha256": "bf233e1321207efc5e1cecf1ae11dfe806fddb1c56f30df03d9ba9fbe979e708",
      "size": 296
    },
    "skills/html-deck/assets/layout-library/templates/items/evidence-point.html": {
      "sha256": "f09663cf03155352dd28c3200f61e4f7fca879061546929389656dc985506c86",
      "size": 195
    },
    "skills/html-deck/assets/layout-library/templates/items/metric.html": {
      "sha256": "9861bd2d582fedcdc18417fb064751abcc4a7df239bc98d0a114d689d41954e1",
      "size": 261
    },
    "skills/html-deck/assets/layout-library/templates/items/process-step.html": {
      "sha256": "4602ed4cfa0e3c4130e948574e0b22ab890835560e9ced71ac002fa8e28f9aa1",
      "size": 253
    },
    "skills/html-deck/assets/layout-library/templates/items/roadmap-phase.html": {
      "sha256": "9aa1e450be80f40f0c1603648db1a9725a0721dd9f947caedb525f4cc55216cd",
      "size": 298
    },
    "skills/html-deck/assets/layout-library/templates/items/scenario-row.html": {
      "sha256": "26656375649fe2eb15efb085ad6fb596f195f62768a9f01dc98625a772fc1f2d",
      "size": 290
    },
    "skills/html-deck/assets/layout-library/templates/items/timeline-step.html": {
      "sha256": "472163ec1fc90644c16dba3272155f698c16e58b176b2b1d3ec3fa025ffb1605",
      "size": 362
    },
    "skills/html-deck/assets/layout-library/templates/metric-contrast.html": {
      "sha256": "dd825fb367e51b6f32d1cb7aac7047e837778130d925b8b6368b0edeece49c3d",
      "size": 427
    },
    "skills/html-deck/assets/layout-library/templates/paired-comparison.html": {
      "sha256": "99a2be223005c3895968e63fbde28833f70e4c7874b75a00cde132446363e48d",
      "size": 1047
    },
    "skills/html-deck/assets/layout-library/templates/process-flow.html": {
      "sha256": "c7e2b8665c03ed562b23aee24c38fac496ea20c592046bd951e5b1ddea4c5797",
      "size": 426
    },
    "skills/html-deck/assets/layout-library/templates/roadmap.html": {
      "sha256": "9ca4f79542a3b7b961883773a590afa1b78256ccf03a19efa26a6e227d9c3635",
      "size": 422
    },
    "skills/html-deck/assets/layout-library/templates/scenario-matrix.html": {
      "sha256": "1d4de27ad18785a7cd629137d3e83e06cbfbb35c7ff3134b856f522a05c1ba8f",
      "size": 434
    },
    "skills/html-deck/assets/layout-library/templates/timeline.html": {
      "sha256": "716b22025772df48a27eb388ac7a34991989109beb29ce34b8b53761d8757d9f",
      "size": 423
    },
    "skills/html-deck/assets/layout-library/templates/visual-takeaway.html": {
      "sha256": "429c05f21ecbaf63bb7a8642ec06847376e9a24c2ddfdc269bf8215987f00f3b",
      "size": 697
    },
    "skills/html-deck/references/evidence-bindings.md": {
      "sha256": "d8f83b25430898ff126ee98d67fff63c49b19b965d775e8d8e86d09345c86827",
      "size": 8408
    },
    "skills/html-deck/references/quality-bar.md": {
      "sha256": "77424a8af1eb619d3b50f2ee31673c340822dc57b0bccfdcf68abc5f5b281604",
      "size": 5095
    },
    "skills/html-deck/references/revision-workflow.md": {
      "sha256": "f7bef902a6d909b4991f4c536e5a740d08770a9bdd9f16d0aa6c32b3cc2ee6e3",
      "size": 2792
    },
    "skills/html-deck/references/static-compatibility.md": {
      "sha256": "678e5e7ba40b572c72b80c1a37cea8b0e3ef9d9c9f231e01372c39fdf1ecb3c2",
      "size": 1796
    },
    "skills/html-deck/references/structured-authoring.md": {
      "sha256": "536273cfba96d4b11639208eec5843eb61ee5673d10beb2b354c27b873b570a7",
      "size": 6704
    },
    "skills/html-deck/scripts/browser_qa_html_deck.py": {
      "sha256": "91be95f050c8b245c4dedc4c045cee5a69d706808cb31a377acc540f0cf1d5ce",
      "size": 73385
    },
    "skills/html-deck/scripts/build_html_deck.py": {
      "sha256": "705edb3c88cc94d67350045250807f23d5af661549afaf1fbcc9dc5373159bf8",
      "size": 26050
    },
    "skills/html-deck/scripts/build_layout_gallery.py": {
      "sha256": "30f99ae7546d5d5ffbdadbd31094210224d4f032b9c0ff03d569eb9594aa79e5",
      "size": 39162
    },
    "skills/html-deck/scripts/compare_html_deck_revision.py": {
      "sha256": "190549f12c819fc860b0e96eb5408ec59855e15a80c57d714054670ca109db9c",
      "size": 1322
    },
    "skills/html-deck/scripts/compose_html_deck.py": {
      "sha256": "7d2d6ea4926e8ec6532236bc35c757936cf11b983332e0488839b911daff28fe",
      "size": 40763
    },
    "skills/html-deck/scripts/content_ledger.py": {
      "sha256": "b5037e72556596b3a201cc310fa724aa80552d663ade1da258d7415c9d8a3b38",
      "size": 10987
    },
    "skills/html-deck/scripts/data_visuals.py": {
      "sha256": "56cec765974273d9e7cdd460976de46b0441eea486dcf591dbe8af9062bccb54",
      "size": 24808
    },
    "skills/html-deck/scripts/evidence_bindings.py": {
      "sha256": "c4c08750d2dd79cbf6b4961a8647664491299f336e91480fb8fbba15685d7266",
      "size": 62967
    },
    "skills/html-deck/scripts/html_deck_revision.py": {
      "sha256": "ace7f2144b416258d4ca00d14ebb333133674529ca7f0e1f0305595435f9e7bf",
      "size": 63986
    },
    "skills/html-deck/scripts/init_html_deck.py": {
      "sha256": "5c47bd53b7aac2f64844f377aac475179109392b672a4c934707c7a74865e94c",
      "size": 4840
    },
    "skills/html-deck/scripts/inspect_html_deck.py": {
      "sha256": "52759a5789f5b063620610970461992521353c2fda61de53908b31c3d5a732cd",
      "size": 1002
    },
    "skills/html-deck/scripts/validate_html_deck.py": {
      "sha256": "225c3bb0f0f1ba5a4c59ecf73222f9a78c9bc5cac371e633f655c0c9bdced335",
      "size": 47352
    },
    "skills/html-deck/scripts/validate_revision_map.py": {
      "sha256": "321e8228f54bb51902d6f20c3cfc085c2974bc38e0abddb99d9b84dcb4ec097c",
      "size": 1227
    },
    "skills/learn-with-clara/SKILL.md": {
      "sha256": "19c1d7c1182387d4d10e6583049e9056aa428173f24e79147b1a9ae7d48a2350",
      "size": 23717
    },
    "skills/learn-with-clara/references/chat-button.md": {
      "sha256": "81c4078be473b2547fd156b59abfc3ef4734d6bfce9929910e4a34590db62289",
      "size": 3208
    },
    "skills/learn-with-clara/references/execution-evidence.md": {
      "sha256": "551ed9f3c464b305295b82192f0c2177ea5fa25c1d30e91ea4fcde03de7f853e",
      "size": 3839
    },
    "skills/learn-with-clara/references/file-access.md": {
      "sha256": "4dcd66a6a7ad1f96ab4b74455f9a6427796dfc321056231369a75579e54626f4",
      "size": 9223
    },
    "skills/learn-with-clara/references/local-sessions.md": {
      "sha256": "bd084dcb25577abc8a3bf35ebccc5e9a1e2f80cd58b440cbc50fbc7f31ca89ad",
      "size": 6896
    },
    "skills/learn-with-clara/references/prepared-courses.md": {
      "sha256": "fe8f6ef9e83e89124307e6f2ce7009c140c8a01f106ae56573c688773a2ec1e5",
      "size": 12357
    },
    "skills/privacy-surface-review/SKILL.md": {
      "sha256": "705fce66d6605af8c4d0b5316dce5b6645e3fd3b0205b4d5e70113545f5706ee",
      "size": 6323
    },
    "skills/privacy-surface-review/agents/openai.yaml": {
      "sha256": "34aa27296dcf9552f12324266a3b18b8989fd42f609d59b691b10d08a5484791",
      "size": 278
    },
    "skills/privacy-surface-review/references/manifest-contract.md": {
      "sha256": "476cb69a14d0854b474e73e0c015c4548733a401234380de445de094125855f4",
      "size": 9174
    },
    "skills/privacy-surface-review/references/model-data-report-contract.md": {
      "sha256": "24a6f34082e24ac4affb0d5c585e9805620802097fae6005d99c8061b1cfe56a",
      "size": 19725
    },
    "skills/privacy-surface-review/references/public-process-page-contract.md": {
      "sha256": "64f8f2b729b4b1c8470539ea7405d2ae51dc1035cf02fd82ab9bc55ce7ac3b43",
      "size": 3876
    },
    "skills/privacy-surface-review/scripts/local_helper_environment.json": {
      "sha256": "211b9d29c8085fdcebd89ee6f6ef4ea92e368adf07b35058a8aa67b503c70a01",
      "size": 318
    },
    "skills/privacy-surface-review/scripts/local_helper_environment.py": {
      "sha256": "c6352dad75af89133af337159dd5aafcab89c1b21bf55c0c77133321e9d1d0fc",
      "size": 1055
    },
    "skills/privacy-surface-review/scripts/validate_privacy_surfaces.py": {
      "sha256": "8780e82205af756d0e71c81311dca110021e6f7f0abc54ebf4840143f9e6afd6",
      "size": 57562
    },
    "skills/reporting-engine/SKILL.md": {
      "sha256": "3aba7af89899eaea8d91857b58869d62dcf1c3c403cdabe491cbec6c766a9a43",
      "size": 32051
    },
    "skills/reporting-engine/agents/openai.yaml": {
      "sha256": "e40b4aca8379751d29dd466f2600aff115b71f4568790594f192433122bed3de",
      "size": 307
    },
    "skills/research-video/SKILL.md": {
      "sha256": "b946772405fca113ebde3e05c1f54762487d27578e93560c35d0139e361b85fc",
      "size": 20691
    },
    "skills/research-video/agents/openai.yaml": {
      "sha256": "51002144f019c307a584c7bf07058768f3106cc6040dcd76293e6343c01f00a0",
      "size": 600
    },
    "skills/research-video/references/hosted-voice-bundle.schema.json": {
      "sha256": "18a766c224063c1e375d9e95bf06b3fd20029a85248e8c1200850b0ce1062a63",
      "size": 2297
    },
    "skills/research-video/references/scene-plan.schema.json": {
      "sha256": "ced323cf4a01b58b455d6f105ef0581cd5afffbb2911e33ed42158b7f38a1f09",
      "size": 3481
    },
    "skills/research-video/scripts/research_video.py": {
      "sha256": "63a94251ab35c88e71fb5808fff62001c33552ff8c28550515d7b4e46e78e718",
      "size": 82049
    },
    "skills/transcribe/SKILL.md": {
      "sha256": "862d8beacec3777011d1e0d9d1fb4da243521a5f770d4ce750376e19fba4133c",
      "size": 14558
    },
    "skills/transcribe/agents/openai.yaml": {
      "sha256": "72b77e25eb8511a596816e3a617bd4a82b7034c4a2e773a5d9828c80b671650a",
      "size": 325
    },
    "ui/report.html": {
      "sha256": "34e5a81f3a95bbd5c7107cd1325bce54ebbb548d4ad3c3a9151222371a3dd2ee",
      "size": 77715
    },
    "ui/retired-browser-interfaces.json": {
      "sha256": "c6934edc13b5a8acb01b29c504f2387e175d0aed847ff7f898bfb8216d5978a6",
      "size": 727
    },
    "ui/theme.css": {
      "sha256": "f22f840af7171e77a49b4ece7d3ceee20016bb20c38536cb7a774fd4d2a02e31",
      "size": 5509
    },
    "usage/pipelines.json": {
      "sha256": "4d8e4ca107591e4724e1c24c6f5e55b73159883bf789f9d730ed44dd98e8a177",
      "size": 828
    },
    "vendor/modules/__init__.py": {
      "sha256": "b9c828953825fd2b27182d6fe360dfd49ebc9b5e846d4b0d969af3e2829465ae",
      "size": 72
    },
    "vendor/modules/courseware/__init__.py": {
      "sha256": "79c785f896af8b4cdcedf1210131c62b95fc2914dec135f6d3fe93d392648ec6",
      "size": 204
    },
    "vendor/modules/courseware/access.py": {
      "sha256": "bc9bdd5f713e5da54fa5cb803e88f1b481f16b6c945d9cc749d9227aa51e9ace",
      "size": 4599
    },
    "vendor/modules/courseware/assets/InstrumentSans-Regular.ttf": {
      "sha256": "69fd3f7c467c70c1f73b232812407f688f3d87dd7a801ea7281aa97d29cf53d5",
      "size": 86232
    },
    "vendor/modules/courseware/assets/InstrumentSans-SemiBold.ttf": {
      "sha256": "7151cf505f897e17b4e9b956293b5a60046ec39da3923a8feba29ce86fd14e12",
      "size": 87004
    },
    "vendor/modules/courseware/assets/OFL.txt": {
      "sha256": "bc29b497c4e8316b2d248322a9cea670c2f0afc24ae0eb7bbaa54e02e00eebab",
      "size": 4402
    },
    "vendor/modules/courseware/assets/chat.html": {
      "sha256": "a613b3880bf1aa22a89fbcf2a8748633fa39e6d22fe6c6073ece19ca059c1858",
      "size": 6926
    },
    "vendor/modules/courseware/assets/chat.js": {
      "sha256": "b76aa6e2ec27eb98ab12e1f85da933a2de432e915f1cbf96c28c5feab4490098",
      "size": 9747
    },
    "vendor/modules/courseware/assets/course.css": {
      "sha256": "5b28ac597f0a3deaf4cfc907b8a33bb40aae21719206ad0c976b605950f89dc7",
      "size": 6910
    },
    "vendor/modules/courseware/assets/languages.json": {
      "sha256": "507967ae7dcf07ae4e138fff4333adb5fd709484731dcef45d531152c54ede45",
      "size": 68031
    },
    "vendor/modules/courseware/assets/legacy-course.css": {
      "sha256": "1d3097a5f8b2011b1cae5f1916cfc698260bc1ebc1c7e59b3ec91271aa2ee7aa",
      "size": 4819
    },
    "vendor/modules/courseware/assets/legacy-languages.json": {
      "sha256": "bd4a3481deeedf806b1eb1bfe91099a6d7796726bc19eb50eef8dc71692b67e5",
      "size": 16146
    },
    "vendor/modules/courseware/chat.py": {
      "sha256": "d9c3f73fc3cd91b9eafc6a058e1a9f09388c166d9268a60082ec3201b4d94b2b",
      "size": 9109
    },
    "vendor/modules/courseware/deck_view.py": {
      "sha256": "96f75ea3078c9e0c6e509cdefb0beeb876677e2e7884777d213d9b03c6c27b80",
      "size": 4840
    },
    "vendor/modules/courseware/document_view.py": {
      "sha256": "9982c9d6ce83e7feb26165308fa9a136a744891a7e623ce23ff9bb778e6b7403",
      "size": 9465
    },
    "vendor/modules/courseware/execution.py": {
      "sha256": "6aa0933970b41ea790d3ef2f92d2e1aa942a490e3cf76225dfe15aaa055dfd29",
      "size": 7793
    },
    "vendor/modules/courseware/html_view.py": {
      "sha256": "57280e82460bd8c7982294c4be6e0cff7da969800d4282e6da15059571cce0b1",
      "size": 7122
    },
    "vendor/modules/courseware/legacy.py": {
      "sha256": "ba650a5da883f2ea5ea741a1fd5118011c8c9215ff2a06e17f3a41785d004c8f",
      "size": 16358
    },
    "vendor/modules/courseware/library.py": {
      "sha256": "e8bacc16c16fbb8a060ec14979c665973f083a38d4cfe3f5edcdb3c8d4947917",
      "size": 68596
    },
    "vendor/modules/courseware/native.cjs": {
      "sha256": "b33eb8ee25d94871d220eb22664ab746f8ee30a187212fd7072761cfd15bfe73",
      "size": 7412
    },
    "vendor/modules/courseware/policy.py": {
      "sha256": "f0c15e7bac029b913d2c80167e6d23591040bf03958923a1a4c68eb0ae8fd8e7",
      "size": 1360
    },
    "vendor/modules/courseware/preview.py": {
      "sha256": "1a6e56141cdd554a6510100f47745f7b31472c9d22f45407f4f86ac7981aee10",
      "size": 4056
    },
    "vendor/modules/courseware/recovery.py": {
      "sha256": "91edce4ba8fbdda238c506a57d03a839c26390b1a1418fdc225e46d557020dbc",
      "size": 7930
    },
    "vendor/modules/courseware/sales_plan_view.py": {
      "sha256": "115977d03c034ed5f363d6fd5c8c82648ed1349067ac61e48d0701b10caa7e7b",
      "size": 3848
    },
    "vendor/modules/courseware/theme.py": {
      "sha256": "26501b56d6e6f99573a40343de95221671758db13d23a14a7012590a89ae2631",
      "size": 784
    },
    "vendor/modules/courseware/website_view.py": {
      "sha256": "f230f86272201bae7bc34f1868d8cb6013b47ce9ccc8b876acdfb0bc257637d5",
      "size": 3040
    },
    "vendor/modules/desktop_teaching/__init__.py": {
      "sha256": "361dab625f1122781bef9bc5fa04c7d62cf31e6fc55a10433e818a96f4bc4309",
      "size": 78
    },
    "vendor/modules/desktop_teaching/cases.py": {
      "sha256": "17c5796df886818346bae0873da3dfd324c55a4e43d37ec5bb2457b9ef2fc2a2",
      "size": 6878
    },
    "vendor/modules/desktop_teaching/onboarding.py": {
      "sha256": "065c7b3f8d3376d433fd74d4d0db8d316adb1e20720c1d88e7af7ecb85eecf61",
      "size": 32859
    },
    "vendor/modules/desktop_teaching/teaching.py": {
      "sha256": "acd268d54bb7c034f06bd11cd15ccbd17d9a6bafd3e57a0d4897dc08ce06d8ab",
      "size": 25592
    },
    "website-support/LICENSE": {
      "sha256": "0d96a4ff68ad6d4b6f1f30f713b18d5184912ba8dd389f86aa7710db079abcb0",
      "size": 34523
    }
  }
}

SHA-256 of public snapshot: 126d378207eff6dec82748d58641b66fcf67c52047668b2d13a3e8d90217ac47

Update to Clara

Package or technical metadata updated

Package file

Package file

Package file

Package file

Compare saved observations

Changed files

modules/variance-analysis/scripts/variance_core.py

added /files/.agents~1skills~1advisory-output-shaper~1SKILL.md

changed /files/.codex-plugin~1plugin.json/sha256

changed /files/.codex-plugin~1plugin.json/size

added /files/LEGGIMI_INSTALLAZIONE.txt

removed /files/LICENSE

added /files/README.md

added /files/assets~1courses~1advisory-brief-planner~1course.json

added /files/assets~1courses~1advisory-case-director~1course.json

added /files/assets~1courses~1advisory-deliverable-validator~1course.json

added /files/assets~1courses~1attribute-reporting~1course.json

added /files/assets~1courses~1brand-fit~1course.json

added /files/assets~1courses~1business-planning~1course.json

added /files/assets~1courses~1deck-correction~1course.json

added /files/assets~1courses~1hosted-interview~1course.json

added /files/assets~1courses~1html-deck~1course.json

added /files/assets~1courses~1index.json

added /files/assets~1courses~1remote.json

added /files/assets~1courses~1reporting-engine~1course.json

added /files/assets~1courses~1research-video~1course.json

added /files/assets~1courses~1transcribe~1course.json

added /files/assets~1onboarding~1actual-budget.xlsx

added /files/assets~1onboarding~1advisory-brief.md

changed /files/components.json/sha256

changed /files/components.json/size

removed /files/distribution.json

added /files/docs~1specs~1pptx_templates~1ag-style-spec.md

added /files/docs~1specs~1pptx_templates~1bain-style-spec.md

added /files/evals~1html_deck_benchmark_protocol.md

added /files/evals~1html_deck_benchmark_runs.schema.json

added /files/evals~1html_deck_capability_benchmarks.json

added /files/evals~1preparation~1udc_fy2025_customer_concentration~1case.json

added /files/evals~1preparation~1udc_fy2025_customer_concentration~1exact_control_facts.csv

added /files/evals~1preparation~1udc_fy2025_customer_concentration~1exact_extracted_facts.csv

added /files/evals~1preparation~1udc_fy2025_customer_concentration~1expected~1customer_concentration_summary.csv

added /files/evals~1preparation~1udc_fy2025_customer_concentration~1expected~1exceptions.csv

added /files/evals~1preparation~1udc_fy2025_customer_concentration~1expected~1prepared_evidence_manifest.json

added /files/evals~1preparation~1udc_fy2025_customer_concentration~1expected~1reconciliation.json

added /files/evals~1preparation~1wd40_fy2025~1SOURCE_NOTES.md

added /files/evals~1preparation~1wd40_fy2025~1case.json

added /files/evals~1preparation~1wd40_fy2025~1expected~1monthly_pnl.csv

added /files/evals~1preparation~1wd40_fy2025~1expected~1prepared_evidence_manifest.json

added /files/evals~1preparation~1wd40_fy2025~1expected~1reconciliation.json

added /files/evals~1preparation~1wd40_fy2025~1expected~1unmapped_accounts.csv

added /files/evals~1preparation~1wd40_fy2025~1monthly_pnl.semantic.json

added /files/evals~1preparation~1wd40_fy2025~1public_statement_facts.csv

added /files/evals~1preparation~1wd40_fy2025~1reporting_handoff_request.json

added /files/evals~1preparation~1wd40_fy2025~1reviewed_coa_mapping.csv

added /files/evals~1preparation~1wd40_fy2025~1statement_render_recipe.json

added /files/evals~1preparation~1wd40_fy2025~1synthetic_monthly_trial_balance.csv

added /files/evals~1preparation~1wd40_fy2025_working_capital~1case.json

added /files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1discrete_cash_flow_schedule.csv

added /files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1exceptions.csv

added /files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1prepared_evidence_manifest.json

added /files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1raw_fact_preservation.csv

added /files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1reconciliation.json

added /files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1stock_flow_bridge.csv

added /files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1working_capital_schedule.csv

added /files/evals~1preparation~1wd40_fy2025_working_capital~1public_working_capital_facts.csv

added /files/evals~1preparation~1wd40_fy2025_working_capital~1reviewed_working_capital_policy.json

added /files/evals~1public_truth~1fastenal_q1_2025~1SOURCE_NOTES.md

added /files/evals~1public_truth~1fastenal_q1_2025~1benchmark.json

added /files/evals~1public_truth~1fastenal_q1_2025~1expected_prepared_observations.csv

added /files/evals~1public_truth~1fastenal_q1_2025~1expected_validation_report.json

added /files/evals~1public_truth~1fastenal_q1_2025~1truth_observations.csv

added /files/evals~1trigger_fixtures.json

changed /files/execution-files.json/sha256

changed /files/execution-files.json/size

added /files/marketplace_skill_instructions.json

added /files/mcp-catalog.json

added /files/mcp-services.json

removed /files/modules~1README.md

added `/files/.agents~1skills~1advisory-output-shaper~1SKILL.md`

changed `/files/.codex-plugin~1plugin.json/sha256`

changed `/files/.codex-plugin~1plugin.json/size`

added `/files/LEGGIMI_INSTALLAZIONE.txt`

removed `/files/LICENSE`

added `/files/README.md`

added `/files/assets~1courses~1advisory-brief-planner~1course.json`

added `/files/assets~1courses~1advisory-case-director~1course.json`

added `/files/assets~1courses~1advisory-deliverable-validator~1course.json`

added `/files/assets~1courses~1attribute-reporting~1course.json`

added `/files/assets~1courses~1brand-fit~1course.json`

added `/files/assets~1courses~1business-planning~1course.json`

added `/files/assets~1courses~1deck-correction~1course.json`

added `/files/assets~1courses~1hosted-interview~1course.json`

added `/files/assets~1courses~1html-deck~1course.json`

added `/files/assets~1courses~1index.json`

added `/files/assets~1courses~1remote.json`

added `/files/assets~1courses~1reporting-engine~1course.json`

added `/files/assets~1courses~1research-video~1course.json`

added `/files/assets~1courses~1transcribe~1course.json`

added `/files/assets~1onboarding~1actual-budget.xlsx`

added `/files/assets~1onboarding~1advisory-brief.md`

changed `/files/components.json/sha256`

changed `/files/components.json/size`

removed `/files/distribution.json`

added `/files/docs~1specs~1pptx_templates~1ag-style-spec.md`

added `/files/docs~1specs~1pptx_templates~1bain-style-spec.md`

added `/files/evals~1html_deck_benchmark_protocol.md`

added `/files/evals~1html_deck_benchmark_runs.schema.json`

added `/files/evals~1html_deck_capability_benchmarks.json`

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1case.json`

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1exact_control_facts.csv`

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1exact_extracted_facts.csv`

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1expected~1customer_concentration_summary.csv`

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1expected~1exceptions.csv`

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1expected~1prepared_evidence_manifest.json`

added `/files/evals~1preparation~1udc_fy2025_customer_concentration~1expected~1reconciliation.json`

added `/files/evals~1preparation~1wd40_fy2025~1SOURCE_NOTES.md`

added `/files/evals~1preparation~1wd40_fy2025~1case.json`

added `/files/evals~1preparation~1wd40_fy2025~1expected~1monthly_pnl.csv`

added `/files/evals~1preparation~1wd40_fy2025~1expected~1prepared_evidence_manifest.json`

added `/files/evals~1preparation~1wd40_fy2025~1expected~1reconciliation.json`

added `/files/evals~1preparation~1wd40_fy2025~1expected~1unmapped_accounts.csv`

added `/files/evals~1preparation~1wd40_fy2025~1monthly_pnl.semantic.json`

added `/files/evals~1preparation~1wd40_fy2025~1public_statement_facts.csv`

added `/files/evals~1preparation~1wd40_fy2025~1reporting_handoff_request.json`

added `/files/evals~1preparation~1wd40_fy2025~1reviewed_coa_mapping.csv`

added `/files/evals~1preparation~1wd40_fy2025~1statement_render_recipe.json`

added `/files/evals~1preparation~1wd40_fy2025~1synthetic_monthly_trial_balance.csv`

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1case.json`

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1discrete_cash_flow_schedule.csv`

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1exceptions.csv`

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1prepared_evidence_manifest.json`

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1raw_fact_preservation.csv`

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1reconciliation.json`

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1stock_flow_bridge.csv`

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1expected~1working_capital_schedule.csv`

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1public_working_capital_facts.csv`

added `/files/evals~1preparation~1wd40_fy2025_working_capital~1reviewed_working_capital_policy.json`

added `/files/evals~1public_truth~1fastenal_q1_2025~1SOURCE_NOTES.md`

added `/files/evals~1public_truth~1fastenal_q1_2025~1benchmark.json`

added `/files/evals~1public_truth~1fastenal_q1_2025~1expected_prepared_observations.csv`

added `/files/evals~1public_truth~1fastenal_q1_2025~1expected_validation_report.json`

added `/files/evals~1public_truth~1fastenal_q1_2025~1truth_observations.csv`

added `/files/evals~1trigger_fixtures.json`

changed `/files/execution-files.json/sha256`

changed `/files/execution-files.json/size`

added `/files/marketplace_skill_instructions.json`

added `/files/mcp-catalog.json`

added `/files/mcp-services.json`

removed `/files/modules~1README.md`

added `/files/modules~1attribute-reporting~1.codex-plugin~1plugin.json`

added `/files/modules~1attribute-reporting~1README.md`

added `/files/modules~1attribute-reporting~1assets~1icon.svg`

added `/files/modules~1attribute-reporting~1evals~1trigger_fixtures.json`

added `/files/modules~1attribute-reporting~1requirements.txt`

added `/files/modules~1attribute-reporting~1scripts~1apply_validated_mappings.py`

added `/files/modules~1attribute-reporting~1scripts~1attribute_reporting.py`

added `/files/modules~1attribute-reporting~1scripts~1bind_mapping_images.py`

added `/files/modules~1attribute-reporting~1scripts~1brand_fit.py`