--- before
+++ after
@@ -0,0 +1,6080 @@
+"""Deterministic contracts for local product-attribute HTML reports."""
+
+from __future__ import annotations
+
+import csv
+import hashlib
+import html
+import importlib.util
+import json
+import logging
+import math
+import os
+import re
+import shutil
+import sys
+import tempfile
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlsplit
+
+__all__ = [
+    "ContractError",
+    "create_mapping_review_template",
+    "create_mapping_tasks",
+    "finalize_report",
+    "prepare_run",
+    "render_report",
+    "select_codex_effective_correction_tasks",
+    "validate_mapping_decisions",
+    "validate_mapping_payloads",
+    "validate_mapping_review",
+    "validate_mapping_review_payloads",
+    "verify_mapping_tasks_against_source",
+]
+
+LOGGER = logging.getLogger(__name__)
+
+RUN_SCHEMA = "attribute_reporting.run_intake.v1"
+CATALOG_SCHEMA = "attribute_reporting.evidence_catalog.v1"
+MODEL_SCHEMA = "attribute_reporting.report_model.v1"
+RENDER_SCHEMA = "attribute_reporting.render_manifest.v1"
+REVIEW_SCHEMA = "attribute_reporting.semantic_review.v1"
+VERDICT_SCHEMA = "attribute_reporting.correctness_verdict.v1"
+MAPPING_TASK_SCHEMA = "attribute_reporting.mapping_tasks.v1"
+MAPPING_DECISION_SCHEMA = "attribute_reporting.mapping_decisions.v1"
+VALIDATED_MAPPING_SCHEMA = "attribute_reporting.validated_mapping_decisions.v1"
+MAPPING_REVIEW_SCHEMA = "attribute_reporting.mapping_review.v1"
+MAPPING_REVIEW_VALIDATION_SCHEMA = "attribute_reporting.mapping_review_validation.v1"
+CORRECTION_TASK_SELECTION_SCHEMA = "attribute_reporting.correction_task_selection.v1"
+LOCAL_IMAGE_MANIFEST_SCHEMA = "attribute_reporting.local_image_manifest.v1"
+LOCAL_DOWNLOAD_RECEIPT_SCHEMA = "attribute_reporting.local_download_receipt.v1"
+LOCAL_EXTRACTION_RECEIPT_SCHEMA = "attribute_reporting.local_extraction_receipt.v1"
+TRANSPORT_LINEAGE_SCHEMA = "attribute_reporting.transport_lineage.v1"
+LOCAL_TRANSPORT_RECEIPT_FILES = (
+    "local_download_receipt.json",
+    "local_extraction_receipt.json",
+)
+NO_WORK_WORKSET_FILE = "mapping_no_work_workset.json"
+NO_WORK_MAPPING_BASIS_SCHEMA = "attribute_reporting.mapping_review_basis.v1"
+MAX_LOCAL_TRANSPORT_RECEIPT_BYTES = 2 * 1024 * 1024
+MAX_NO_WORK_WORKSET_BYTES = 2 * 1024 * 1024
+MAPPING_PROVENANCE_FILES = (
+    "mapping_tasks.json",
+    "mapping_decisions.json",
+    "validated_mappings.json",
+    "mapping_review.json",
+)
+SERVER_MAPPING_PROVENANCE_FILES = (
+    "mapping_submission_receipt.json",
+    "mapping_review_validation.json",
+    "server_sanitization_receipt.json",
+)
+SERVER_BRIDGE_SCHEMA_PREFIX = "attribute_reporting.server_bridge"
+
+VERDICT_LABELS = {
+    "correct": "Correct",
+    "correct_with_caveats": "Correct with caveats",
+    "incorrect": "Incorrect",
+    "unable_to_determine": "Unable to determine",
+}
+VERDICT_PLACEHOLDER_HTML = (
+    "<!-- ATTRIBUTE_REPORTING_VERDICT -->"
+    '<aside class="verdict unable_to_determine provisional" '
+    'data-correctness-verdict="pending">'
+    '<span class="mark">?</span><div><strong>Correctness review pending</strong>'
+    "<span>The final evidence-backed verdict will replace this banner after "
+    "independent semantic review and browser QA.</span></div></aside>"
+)
+REQUIRED_SECTION_IDS = (
+    "executive_summary",
+    "winning_now",
+    "brand_context",
+    "emerging_signal",
+    "winner_emerging_bridge",
+    "product_evidence",
+    "method_and_caveats",
+)
+REQUIRED_REVIEW_DIMENSIONS = (
+    "claim_coverage",
+    "story_coherence",
+    "importance_calibration",
+    "caveat_handling",
+    "brand_and_example_interpretation",
+    "html_readability",
+)
+ALLOWED_TABLE_KEYS = {
+    "attribute_bundle_comparison_table",
+    "attribute_bridge_table",
+    "rank_weighted_visibility_table",
+    "product_signal_evidence_table",
+}
+ALLOWED_EVIDENCE_FILES = {
+    "summary.json",
+    "pack_manifest.json",
+    "package_integrity.json",
+    "mapped_attribute_comparison.csv",
+    "top_seller_mapped_attribute_comparison.csv",
+    "innovation_pairs.csv",
+    "innovation_triples.csv",
+    "top_seller_pairs.csv",
+    "top_seller_triples.csv",
+    "top_seller_brand_comparison.csv",
+    "price_band_comparison.csv",
+    "price_comparison.json",
+    "resolved_core_comparison.csv",
+    "filter_comparison.csv",
+    "recent_products.csv",
+    "top_seller_products.csv",
+    "top_seller_review_validation.csv",
+    "bundle_review_validation.csv",
+    "sale_pressure_attribute_comparison.csv",
+    "sale_pressure_pairs.csv",
+    "sale_pressure_triples.csv",
+    "sale_pressure_overlap.csv",
+    "sort_rank_delta_attributes.csv",
+}
+SUPPORTED_FORMATS = {
+    "text",
+    "integer",
+    "decimal_1",
+    "decimal_2",
+    "percent_1",
+    "percentage_point_1",
+    "ratio_2",
+    "currency_0",
+}
+TOKEN_RE = re.compile(r"\{\{([a-z][a-z0-9_-]{0,63})\}\}")
+NUMERIC_LITERAL_RE = re.compile(r"(?<![A-Za-z])\d+(?:[.,]\d+)?")
+SAFE_ID_RE = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,127}$")
+MAPPING_PLACEHOLDERS = {
+    "",
+    "n/a",
+    "na",
+    "none",
+    "unknown",
+    "n/a (not stated)",
+    "not stated",
+    "not in taxonomy",
+}
+
+
+class ContractError(ValueError):
+    """Raised when a report or mapping artifact violates its contract."""
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedEvidence:
+    """One evidence binding resolved from a package source."""
+
+    ref_id: str
+    source: str
+    raw_value: Any
+    formatted_value: str
+    source_sha256: str
+    selector: dict[str, Any]
+    source_row_sha256: str | None = None
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _load_json(path: Path) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError as exc:
+        raise ContractError(f"Required JSON file is missing: {path}") from exc
+    except json.JSONDecodeError as exc:
+        raise ContractError(f"Invalid JSON in {path}: {exc}") from exc
+    if not isinstance(payload, dict):
+        raise ContractError(f"Expected a JSON object in {path}")
+    return payload
+
+
+def _write_json(path: Path, payload: Mapping[str, Any]) -> None:
+    destination = path.expanduser().resolve()
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    temporary = tempfile.NamedTemporaryFile(
+        mode="w",
+        encoding="utf-8",
+        dir=destination.parent,
+        prefix=f".{destination.name}.",
+        suffix=".tmp",
+        delete=False,
+    )
+    temporary_path = Path(temporary.name)
+    try:
+        with temporary:
+            json.dump(payload, temporary, ensure_ascii=False, indent=2)
+            temporary.write("\n")
+        temporary_path.chmod(0o600)
+        temporary_path.replace(destination)
+    finally:
+        temporary_path.unlink(missing_ok=True)
+
+
+def _sha256_bytes(payload: bytes) -> str:
+    return hashlib.sha256(payload).hexdigest()
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _canonical_json_sha256(payload: Mapping[str, Any]) -> str:
+    encoded = json.dumps(
+        payload,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    ).encode("utf-8")
+    return _sha256_bytes(encoded)
+
+
+def _safe_relative_path(value: str, *, label: str) -> Path:
+    path = Path(value)
+    if path.is_absolute() or ".." in path.parts or not path.parts:
+        raise ContractError(f"{label} must be a safe relative path: {value!r}")
+    return path
+
+
+def _contained_package_path(
+    package_dir: Path,
+    relative: Path | str,
+    *,
+    label: str,
+) -> Path:
+    """Resolve one package path and reject traversal or symlink escapes."""
+
+    root = package_dir.expanduser().resolve()
+    safe_relative = _safe_relative_path(str(relative), label=label)
+    candidate = (root / safe_relative).resolve()
+    if not candidate.is_relative_to(root):
+        raise ContractError(f"{label} escapes the evidence package: {relative!s}")
+    return candidate
+
+
+def _assert_safe_output_dir(output_dir: Path) -> Path:
+    resolved = output_dir.expanduser().resolve()
+    for parent in (resolved, *resolved.parents):
+        if (parent / ".git").exists():
+            raise ContractError(
+                "Run outputs cannot be written inside a Git workspace; choose a "
+                "private local output folder outside the repository."
+            )
+    return resolved
+
+
+def _read_csv(path: Path) -> tuple[list[str], list[dict[str, str]]]:
+    try:
+        with path.open("r", encoding="utf-8-sig", newline="") as handle:
+            reader = csv.DictReader(handle)
+            columns = list(reader.fieldnames or [])
+            rows = [dict(row) for row in reader]
+    except FileNotFoundError as exc:
+        raise ContractError(f"Required CSV file is missing: {path}") from exc
+    except csv.Error as exc:
+        raise ContractError(f"Invalid CSV in {path}: {exc}") from exc
+    if not columns:
+        raise ContractError(f"CSV file has no header: {path}")
+    return columns, rows
+
+
+def _source_row_sha256(row: Mapping[str, Any]) -> str:
+    return _canonical_json_sha256(dict(row))
+
+
+def _normalise_mapping_token(value: Any) -> str:
+    return re.sub(r"[^a-z0-9]+", "_", str(value or "").casefold()).strip("_")
+
+
+def _taxonomy_leaf_values(nodes: Any) -> list[dict[str, str]]:
+    if not isinstance(nodes, list):
+        return []
+    values: list[dict[str, str]] = []
+    for node in nodes:
+        if not isinstance(node, dict):
+            continue
+        children = node.get("children")
+        if isinstance(children, list) and children:
+            values.extend(_taxonomy_leaf_values(children))
+            continue
+        value_id = str(node.get("id") or "").strip()
+        label = str(node.get("label") or "").strip()
+        if not value_id or not label:
+            continue
+        if str(node.get("status") or "active").strip().casefold() != "active":
+            continue
+        if _normalise_mapping_token(value_id) in {"unknown", "other"}:
+            continue
+        if label.casefold() in {"n/a (not stated)", "not in taxonomy"}:
+            continue
+        values.append({"id": value_id, "label": label})
+    return values
+
+
+def _mapping_value_parts(value: Any) -> list[str]:
+    text = str(value or "").strip()
+    if text.casefold() in MAPPING_PLACEHOLDERS:
+        return []
+    return [part.strip() for part in re.split(r"\s*[|;]\s*", text) if part.strip()]
+
+
+def _row_attribute_evidence(
+    row: Mapping[str, str],
+    *,
+    attribute_id: str,
+    attribute_label: str,
+    selection: str,
+    allowed_values: Sequence[Mapping[str, str]],
+) -> tuple[bool, dict[str, str], str]:
+    columns_by_token: dict[str, list[str]] = {}
+    for column in row:
+        columns_by_token.setdefault(_normalise_mapping_token(column), []).append(column)
+    candidate_tokens = [
+        _normalise_mapping_token(attribute_id),
+        _normalise_mapping_token(attribute_label),
+    ]
+    candidate_columns: list[str] = []
+    for token in candidate_tokens:
+        for candidate in (token, f"{token}_mapped"):
+            for column in columns_by_token.get(candidate, []):
+                if column not in candidate_columns:
+                    candidate_columns.append(column)
+    evidence = {
+        column: str(row.get(column) or "").strip()
+        for column in candidate_columns
+        if str(row.get(column) or "").strip()
+    }
+    allowed_tokens = {
+        token
+        for item in allowed_values
+        for token in (
+            _normalise_mapping_token(item.get("id")),
+            _normalise_mapping_token(item.get("label")),
+        )
+        if token
+    }
+    for evidence_column, value in evidence.items():
+        parts = _mapping_value_parts(value)
+        if parts and all(
+            _normalise_mapping_token(part) in allowed_tokens for part in parts
+        ):
+            evidence_token = _normalise_mapping_token(evidence_column)
+            if evidence_token.endswith("_mapped"):
+                evidence_token = evidence_token[: -len("_mapped")]
+            source_tokens = [
+                f"{evidence_token}_effective_source",
+                f"{_normalise_mapping_token(attribute_id)}_effective_source",
+                f"{_normalise_mapping_token(attribute_label)}_effective_source",
+            ]
+            source = next(
+                (
+                    str(row.get(source_column) or "").strip().casefold()
+                    for token in source_tokens
+                    for source_column in columns_by_token.get(token, [])
+                    if str(row.get(source_column) or "").strip()
+                ),
+                "unattributed",
+            )
+            return True, evidence, source
+
+    if selection == "multi":
+        selected = False
+        selected_sources: list[str] = []
+        for item in allowed_values:
+            leaf_column = f"{attribute_id}__{item['id']}"
+            raw_value = str(row.get(leaf_column) or "").strip().casefold()
+            if raw_value in {"1", "true", "yes"}:
+                evidence[leaf_column] = str(row.get(leaf_column) or "").strip()
+                selected = True
+                leaf_source_token = (
+                    f"{_normalise_mapping_token(leaf_column)}_effective_source"
+                )
+                selected_sources.append(
+                    next(
+                        (
+                            str(row.get(source_column) or "").strip().casefold()
+                            for source_column in columns_by_token.get(
+                                leaf_source_token, []
+                            )
+                            if str(row.get(source_column) or "").strip()
+                        ),
+                        "unattributed",
+                    )
+                )
+        if selected:
+            unique_sources = set(selected_sources)
+            source = next(iter(unique_sources)) if len(unique_sources) == 1 else "mixed"
+            return True, evidence, source
+        for suffix in ("unknown", "other", "not_in_taxonomy"):
+            flag_column = f"{attribute_id}__{suffix}"
+            raw_value = str(row.get(flag_column) or "").strip()
+            if raw_value:
+                evidence[flag_column] = raw_value
+    return False, evidence, "unresolved"
+
+
+def _is_supported_local_image(path: Path) -> bool:
+    suffix = path.suffix.casefold()
+    if suffix not in {".avif", ".gif", ".jpeg", ".jpg", ".png", ".webp"}:
+        return False
+    try:
+        with path.open("rb") as handle:
+            header = handle.read(64)
+    except OSError:
+        return False
+    if suffix in {".jpeg", ".jpg"}:
+        return header.startswith(b"\xff\xd8\xff")
+    if suffix == ".png":
+        return header.startswith(b"\x89PNG\r\n\x1a\n")
+    if suffix == ".gif":
+        return header.startswith((b"GIF87a", b"GIF89a"))
+    if suffix == ".webp":
+        return (
+            len(header) >= 12 and header.startswith(b"RIFF") and header[8:12] == b"WEBP"
+        )
+    return (
+        len(header) >= 12
+        and header[4:8] == b"ftyp"
+        and (header[8:12] in {b"avif", b"avis"} or b"avif" in header[8:32])
+    )
+
+
+@lru_cache(maxsize=8)
+def _cached_local_image_manifest(
+    path_text: str,
+    modified_ns: int,
+    size_bytes: int,
+) -> dict[str, Any]:
+    """Load one sidecar manifest keyed by file identity for repeated task rows."""
+
+    del modified_ns, size_bytes
+    return _load_json(Path(path_text))
+
+
+def _local_sidecar_image(
+    package_dir: Path,
+    row: Mapping[str, str],
+) -> tuple[Path, str] | None:
+    manifest_path = package_dir / "local_image_manifest.json"
+    if not manifest_path.is_file():
+        return None
+    stat = manifest_path.stat()
+    manifest = _cached_local_image_manifest(
+        str(manifest_path.resolve()), stat.st_mtime_ns, stat.st_size
+    )
+    if manifest.get("schema_version") != LOCAL_IMAGE_MANIFEST_SCHEMA:
+        raise ContractError("Unsupported local image manifest schema")
+    if Path(str(manifest.get("package_dir") or "")).expanduser().resolve() != (
+        package_dir.resolve()
+    ):
+        raise ContractError("Local image manifest belongs to another package")
+    product_id = str(
+        row.get("parent_product_id") or row.get("listing_identity") or ""
+    ).strip()
+    entry = next(
+        (
+            item
+            for item in manifest.get("products") or []
+            if isinstance(item, dict)
+            and str(item.get("product_id") or "") == product_id
+        ),
+        None,
+    )
+    if entry is None or entry.get("status") not in {
+        "downloaded",
+        "existing",
+        "reused",
+    }:
+        return None
+    current_row_sha = _source_row_sha256(row)
+    source_rows = entry.get("source_rows")
+    pinned_row_hashes = (
+        {str(value) for value in source_rows.values()}
+        if isinstance(source_rows, dict)
+        else {str(entry.get("source_row_sha256") or "")}
+    )
+    if current_row_sha not in pinned_row_hashes:
+        raise ContractError(f"Local image manifest is stale for product {product_id}")
+    relative = _safe_relative_path(
+        str(entry.get("image_path") or ""), label="local image sidecar"
+    )
+    candidate = (package_dir / relative).resolve()
+    image_root = (package_dir / "images").resolve()
+    if not candidate.is_file() or not candidate.is_relative_to(image_root):
+        raise ContractError(f"Local image sidecar is unavailable: {relative}")
+    if not _is_supported_local_image(candidate):
+        raise ContractError(
+            f"Local image sidecar is not a supported raster: {relative}"
+        )
+    expected_sha = str(entry.get("sha256") or "")
+    if not expected_sha or _sha256_file(candidate) != expected_sha:
+        raise ContractError(f"Local image sidecar hash changed: {relative}")
+    return candidate, relative.as_posix()
+
+
+def _local_mapping_images(
+    package_dir: Path,
+    row: Mapping[str, str],
+) -> list[dict[str, str]]:
+    images: list[dict[str, str]] = []
+    seen_paths: set[str] = set()
+    package_root = package_dir.resolve()
+    image_root = (package_root / "images").resolve()
+    if not image_root.is_relative_to(package_root):
+        raise ContractError("Evidence-package image directory escapes the package")
+    for field in ("pack_image_file", "pack_image_path"):
+        raw_value = str(row.get(field) or "").strip()
+        if not raw_value:
+            continue
+        raw_path = Path(raw_value).expanduser()
+        candidate = raw_path if raw_path.is_absolute() else package_dir / raw_path
+        if candidate.is_file():
+            resolved_path = candidate.resolve()
+            if not resolved_path.is_relative_to(image_root):
+                raise ContractError(
+                    f"Mapping image escapes the package image directory: {resolved_path}"
+                )
+            if not _is_supported_local_image(resolved_path):
+                raise ContractError(
+                    f"Mapping image is not a supported raster image: {resolved_path}"
+                )
+            resolved = str(resolved_path)
+            if resolved not in seen_paths:
+                images.append(
+                    {
+                        "path": resolved_path.relative_to(package_root).as_posix(),
+                        "sha256": _sha256_file(resolved_path),
+                    }
+                )
+                seen_paths.add(resolved)
+    sidecar = _local_sidecar_image(package_dir, row)
+    if sidecar is not None:
+        resolved_path, relative_path = sidecar
+        resolved = str(resolved_path)
+        if resolved not in seen_paths:
+            images.append(
+                {"path": relative_path, "sha256": _sha256_file(resolved_path)}
+            )
+    return images
+
+
+def _mapping_task_id(
+    retailer: str,
+    category_key: str,
+    row_type: str,
+    parent_product_id: str,
+    variant_id: str,
+    attribute_id: str,
+) -> str:
+    stable_key = "|".join(
+        [
+            retailer,
+            category_key,
+            row_type,
+            parent_product_id,
+            variant_id,
+            attribute_id,
+        ]
+    )
+    return "map-" + hashlib.sha256(stable_key.encode("utf-8")).hexdigest()[:24]
+
+
+_MAPPING_IDENTITY_FIELDS = (
+    "retailer",
+    "row_type",
+    "parent_product_id",
+    "variant_id",
+    "category_key",
+    "attribute_id",
+)
+
+
+def _mapping_task_identity(task: Mapping[str, Any]) -> tuple[str, ...]:
+    product = task.get("product")
+    attribute = task.get("attribute")
+    if not isinstance(product, Mapping) or not isinstance(attribute, Mapping):
+        raise ContractError("Correction selection requires complete task identities")
+    identity = (
+        str(product.get("retailer") or "").strip(),
+        str(product.get("row_type") or "").strip(),
+        str(product.get("parent_product_id") or "").strip(),
+        str(product.get("variant_id") or "").strip(),
+        str(product.get("category_key") or "").strip(),
+        str(attribute.get("id") or "").strip(),
+    )
+    if any(not value for index, value in enumerate(identity) if index != 3):
+        raise ContractError("Correction selection encountered an incomplete identity")
+    return identity
+
+
+def select_codex_effective_correction_tasks(
+    tasks: Sequence[Mapping[str, Any]],
+    codex_mapping_identities: Iterable[Sequence[str] | Mapping[str, Any]],
+) -> dict[str, Any]:
+    """Select resolved tasks whose accepted Codex value is report-effective.
+
+    This gate is deterministic because it checks exact source provenance and
+    database identity membership; it does not make or override the semantic
+    mapping decision itself.
+    """
+
+    pinned_identities: set[tuple[str, ...]] = set()
+    for raw_identity in codex_mapping_identities:
+        if isinstance(raw_identity, Mapping):
+            raw_source = str(raw_identity.get("source") or "codex").strip().casefold()
+            if raw_source != "codex":
+                raise ContractError("Correction state identity must use source=codex")
+            identity = (
+                str(raw_identity.get("retailer") or "").strip(),
+                str(raw_identity.get("row_type") or "").strip(),
+                str(raw_identity.get("parent_product_id") or "").strip(),
+                str(raw_identity.get("variant_id") or "").strip(),
+                str(raw_identity.get("category_key") or "").strip(),
+                str(
+                    raw_identity.get("attribute_id")
+                    or raw_identity.get("base_attribute_id")
+                    or ""
+                ).strip(),
+            )
+        else:
+            identity_values = tuple(str(value or "").strip() for value in raw_identity)
+            if len(identity_values) == len(_MAPPING_IDENTITY_FIELDS) + 1:
+                source, *identity_parts = identity_values
+                if source.casefold() != "codex":
+                    raise ContractError(
+                        "Correction state identity must use source=codex"
+                    )
+                identity = tuple(identity_parts)
+            else:
+                identity = identity_values
+        if len(identity) != len(_MAPPING_IDENTITY_FIELDS) or any(
+            not value for index, value in enumerate(identity) if index != 3
+        ):
+            raise ContractError("Pinned Codex mapping identity is incomplete")
+        pinned_identities.add(identity)
+
+    selected: list[dict[str, Any]] = []
+    excluded_unresolved = 0
+    excluded_non_codex_effective = 0
+    excluded_not_pinned = 0
+    for raw_task in tasks:
+        task = dict(raw_task)
+        if str(task.get("mapping_reason") or "") != "migration_recheck":
+            excluded_unresolved += 1
+            continue
+        if str(task.get("existing_evidence_source") or "").casefold() != "codex":
+            excluded_non_codex_effective += 1
+            continue
+        if _mapping_task_identity(task) not in pinned_identities:
+            excluded_not_pinned += 1
+            continue
+        selected.append(task)
+
+    return {
+        "schema_version": CORRECTION_TASK_SELECTION_SCHEMA,
+        "criteria": {
+            "mapping_reason": "migration_recheck",
+            "existing_evidence_source": "codex",
+            "requires_pinned_codex_identity": True,
+        },
+        "task_count_before_selection": len(tasks),
+        "task_count": len(selected),
+        "excluded_unresolved_count": excluded_unresolved,
+        "excluded_non_codex_effective_count": excluded_non_codex_effective,
+        "excluded_not_pinned_count": excluded_not_pinned,
+        "tasks": selected,
+    }
+
+
+def _build_mapping_workset(
+    package: Path,
+    *,
+    retailer: str,
+    category_key: str,
+    rows: Sequence[Mapping[str, str]],
+    attributes: Sequence[Any],
+    include_resolved: bool,
+) -> tuple[list[dict[str, Any]], dict[str, int]]:
+    """Build source-bound product tasks and deterministic coverage counts."""
+
+    tasks: list[dict[str, Any]] = []
+    skipped_variant_attributes = 0
+    resolved_attribute_cells = 0
+    unresolved_attribute_cells = 0
+    migration_recheck_tasks = 0
+    sorted_rows = sorted(
+        rows,
+        key=lambda row: str(
+            row.get("parent_product_id") or row.get("listing_identity") or ""
+        ),
+    )
+    for row in sorted_rows:
+        parent_product_id = str(
+            row.get("parent_product_id") or row.get("listing_identity") or ""
+        ).strip()
+        if not parent_product_id:
+            continue
+        for attribute in attributes:
+            if not isinstance(attribute, dict):
+                continue
+            if str(attribute.get("scope") or "product").casefold() != "product":
+                skipped_variant_attributes += 1
+                continue
+            attribute_id = str(attribute.get("id") or "").strip()
+            attribute_label = str(attribute.get("label") or attribute_id).strip()
+            selection = str(attribute.get("selection") or "single").casefold()
+            if selection not in {"single", "multi"} or not attribute_id:
+                raise ContractError(
+                    f"Unsupported taxonomy selection for attribute {attribute_id!r}"
+                )
+            allowed_values = _taxonomy_leaf_values(attribute.get("nodes"))
+            if not allowed_values:
+                continue
+            resolved, existing_evidence, existing_evidence_source = (
+                _row_attribute_evidence(
+                    row,
+                    attribute_id=attribute_id,
+                    attribute_label=attribute_label,
+                    selection=selection,
+                    allowed_values=allowed_values,
+                )
+            )
+            if resolved:
+                resolved_attribute_cells += 1
+                if not include_resolved:
+                    continue
+                migration_recheck_tasks += 1
+            else:
+                unresolved_attribute_cells += 1
+            row_type = "parent"
+            variant_id = ""
+            task_id = _mapping_task_id(
+                retailer,
+                category_key,
+                row_type,
+                parent_product_id,
+                variant_id,
+                attribute_id,
+            )
+            description = str(
+                row.get("description_excerpt")
+                or row.get("summary")
+                or row.get("description")
+                or ""
+            ).strip()
+            tasks.append(
+                {
+                    "task_id": task_id,
+                    "product": {
+                        "retailer": retailer,
+                        "row_type": row_type,
+                        "parent_product_id": parent_product_id,
+                        "variant_id": variant_id,
+                        "category_key": category_key,
+                        "source_row_sha256": _source_row_sha256(row),
+                        "brand": str(row.get("brand") or "").strip(),
+                        "title": str(row.get("product_name") or "").strip(),
+                        "description": description[:4000],
+                        "pdp_url": _safe_http_url(row.get("pdp_url")),
+                        "local_images": _local_mapping_images(package, row),
+                    },
+                    "attribute": {
+                        "id": attribute_id,
+                        "label": attribute_label,
+                        "selection": selection,
+                        "allowed_values": allowed_values,
+                    },
+                    "existing_evidence": existing_evidence,
+                    "existing_evidence_source": existing_evidence_source,
+                    "mapping_reason": (
+                        "migration_recheck" if resolved else "unresolved"
+                    ),
+                }
+            )
+    coverage = {
+        "product_rows": len(sorted_rows),
+        "resolved_attribute_cells": resolved_attribute_cells,
+        "unresolved_attribute_cells": unresolved_attribute_cells,
+        "migration_recheck_tasks": migration_recheck_tasks,
+        "variant_attribute_cells_skipped": skipped_variant_attributes,
+    }
+    return tasks, coverage
+
+
+def create_mapping_tasks(
+    package_dir: Path,
+    taxonomy: Mapping[str, Any],
+    output_path: Path,
+    *,
+    max_tasks: int = 0,
+    include_resolved: bool = False,
+) -> dict[str, Any]:
+    """Create bounded Codex tasks for unresolved product attributes."""
+
+    package = package_dir.expanduser().resolve()
+    integrity_path = _contained_package_path(
+        package, "package_integrity.json", label="package integrity"
+    )
+    summary_path = _contained_package_path(
+        package, "summary.json", label="package summary"
+    )
+    manifest_path = _contained_package_path(
+        package, "pack_manifest.json", label="pack manifest"
+    )
+    integrity = _load_json(integrity_path)
+    if str(integrity.get("status") or "").casefold() != "pass":
+        raise ContractError("Evidence package integrity is not pass")
+    summary = _load_json(summary_path)
+    manifest = _load_json(manifest_path)
+    category_key = str(summary.get("category_key") or "").strip()
+    retailer = str(summary.get("retailer") or "").strip()
+    if not category_key or not retailer:
+        raise ContractError("Package summary requires retailer and category_key")
+    if max_tasks < 0:
+        raise ContractError("max_tasks cannot be negative")
+    matrix_path = _contained_package_path(
+        package, "product_filter_matrix.csv", label="product filter matrix"
+    )
+    _columns, rows = _read_csv(matrix_path)
+
+    categories = taxonomy.get("categories")
+    if not isinstance(categories, list):
+        raise ContractError("Central taxonomy has no categories list")
+    category = next(
+        (
+            item
+            for item in categories
+            if isinstance(item, dict)
+            and _normalise_mapping_token(item.get("id"))
+            == _normalise_mapping_token(category_key)
+        ),
+        None,
+    )
+    if category is None:
+        raise ContractError(
+            f"Category {category_key!r} is absent from the central taxonomy"
+        )
+    attributes = category.get("attributes")
+    if not isinstance(attributes, list):
+        raise ContractError(f"Taxonomy category {category_key!r} has no attributes")
+
+    tasks, coverage_counts = _build_mapping_workset(
+        package,
+        retailer=retailer,
+        category_key=category_key,
+        rows=rows,
+        attributes=attributes,
+        include_resolved=include_resolved,
+    )
+
+    total_tasks = len(tasks)
+    truncated = bool(max_tasks and total_tasks > max_tasks)
+    if truncated:
+        tasks = tasks[:max_tasks]
+    taxonomy_version = str(taxonomy.get("version") or "").strip()
+    if not taxonomy_version:
+        raise ContractError("Central taxonomy requires a version")
+    payload = {
+        "schema_version": MAPPING_TASK_SCHEMA,
+        "generated_at": _utc_now(),
+        "taxonomy_snapshot": {
+            "version": taxonomy_version,
+            "sha256": _canonical_json_sha256(taxonomy),
+            "category_key": category_key,
+        },
+        "scope": {
+            "retailer": retailer,
+            "category_key": category_key,
+            "row_type": "parent",
+            "source_package": str(package),
+            "source_package_sha256": _package_fingerprint(
+                package,
+                _package_source_paths(package, manifest),
+            ),
+            "source_pack_manifest_sha256": _sha256_file(manifest_path),
+            "source_matrix_sha256": _sha256_file(matrix_path),
+            "summary_sha256": _sha256_file(summary_path),
+            "package_integrity_sha256": _sha256_file(integrity_path),
+        },
+        "coverage": {
+            **coverage_counts,
+            "task_count_before_limit": total_tasks,
+            "task_count": len(tasks),
+            "truncated": truncated,
+            "include_resolved": include_resolved,
+        },
+        "tasks": tasks,
+    }
+    mapping_output = output_path.expanduser().resolve()
+    _assert_safe_output_dir(mapping_output.parent)
+    _write_json(mapping_output, payload)
+    return payload
+
+
+def verify_mapping_tasks_against_source(
+    tasks: Mapping[str, Any],
+    taxonomy: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Prove a complete workset was regenerated from its unchanged source matrix."""
+
+    if tasks.get("schema_version") != MAPPING_TASK_SCHEMA:
+        raise ContractError("Unsupported mapping task schema")
+    scope = tasks.get("scope")
+    coverage = tasks.get("coverage")
+    raw_tasks = tasks.get("tasks")
+    if not isinstance(scope, dict) or not isinstance(coverage, dict):
+        raise ContractError("Mapping tasks require source scope and coverage objects")
+    if not isinstance(raw_tasks, list):
+        raise ContractError("Mapping tasks must contain a tasks list")
+    if coverage.get("truncated") is not False:
+        raise ContractError("Only a complete, non-truncated workset may be applied")
+    include_resolved = coverage.get("include_resolved")
+    if not isinstance(include_resolved, bool):
+        raise ContractError("Mapping coverage requires include_resolved boolean")
+
+    package = Path(str(scope.get("source_package") or "")).expanduser().resolve()
+    source_files = {
+        "pack_manifest.json": str(scope.get("source_pack_manifest_sha256") or ""),
+        "product_filter_matrix.csv": str(scope.get("source_matrix_sha256") or ""),
+        "summary.json": str(scope.get("summary_sha256") or ""),
+        "package_integrity.json": str(scope.get("package_integrity_sha256") or ""),
+    }
+    for file_name, expected_sha256 in source_files.items():
+        path = _contained_package_path(package, file_name, label="pinned source")
+        if not expected_sha256 or not path.is_file():
+            raise ContractError(f"Pinned mapping source is unavailable: {path}")
+        if _sha256_file(path) != expected_sha256:
+            raise ContractError(f"Pinned mapping source changed: {path}")
+
+    manifest = _load_json(
+        _contained_package_path(package, "pack_manifest.json", label="pack manifest")
+    )
+    expected_package_sha256 = str(scope.get("source_package_sha256") or "")
+    if (
+        not expected_package_sha256
+        or _package_fingerprint(
+            package,
+            _package_source_paths(package, manifest),
+        )
+        != expected_package_sha256
+    ):
+        raise ContractError("Pinned mapping source package fingerprint changed")
+
+    integrity = _load_json(
+        _contained_package_path(
+            package, "package_integrity.json", label="package integrity"
+        )
+    )
+    if str(integrity.get("status") or "").casefold() != "pass":
+        raise ContractError("Pinned mapping source package integrity is not pass")
+    summary = _load_json(
+        _contained_package_path(package, "summary.json", label="package summary")
+    )
+    retailer = str(summary.get("retailer") or "").strip()
+    category_key = str(summary.get("category_key") or "").strip()
+    if (
+        not retailer
+        or not category_key
+        or str(scope.get("retailer") or "") != retailer
+        or str(scope.get("category_key") or "") != category_key
+        or str(scope.get("row_type") or "") != "parent"
+    ):
+        raise ContractError("Mapping scope differs from the pinned package summary")
+
+    snapshot = tasks.get("taxonomy_snapshot")
+    if not isinstance(snapshot, dict):
+        raise ContractError("Mapping tasks require a taxonomy snapshot")
+    if (
+        str(snapshot.get("version") or "") != str(taxonomy.get("version") or "")
+        or str(snapshot.get("sha256") or "") != _canonical_json_sha256(taxonomy)
+        or str(snapshot.get("category_key") or "") != category_key
+    ):
+        raise ContractError("Mapping workset differs from the current central taxonomy")
+
+    categories = taxonomy.get("categories")
+    if not isinstance(categories, list):
+        raise ContractError("Central taxonomy has no categories list")
+    category = next(
+        (
+            item
+            for item in categories
+            if isinstance(item, dict)
+            and _normalise_mapping_token(item.get("id"))
+            == _normalise_mapping_token(category_key)
+        ),
+        None,
+    )
+    if category is None or not isinstance(category.get("attributes"), list):
+        raise ContractError(
+            f"Category {category_key!r} is absent from the central taxonomy"
+        )
+    _columns, rows = _read_csv(
+        _contained_package_path(
+            package, "product_filter_matrix.csv", label="product filter matrix"
+        )
+    )
+    expected_tasks, coverage_counts = _build_mapping_workset(
+        package,
+        retailer=retailer,
+        category_key=category_key,
+        rows=rows,
+        attributes=category["attributes"],
+        include_resolved=include_resolved,
+    )
+    expected_coverage = {
+        **coverage_counts,
+        "task_count_before_limit": len(expected_tasks),
+        "task_count": len(expected_tasks),
+        "truncated": False,
+        "include_resolved": include_resolved,
+    }
+    if coverage != expected_coverage:
+        raise ContractError("Mapping coverage differs from the pinned source workset")
+    if raw_tasks != expected_tasks:
+        raise ContractError("Mapping tasks differ from the pinned source workset")
+    return dict(scope)
+
+
+def _package_source_paths(package_dir: Path, manifest: Mapping[str, Any]) -> list[Path]:
+    package_root = package_dir.resolve()
+    paths: set[Path] = {
+        _contained_package_path(
+            package_root, "pack_manifest.json", label="pack manifest"
+        )
+    }
+    raw_warnings_path = package_root / "package_warnings.json"
+    if raw_warnings_path.exists():
+        warnings_path = _contained_package_path(
+            package_root, "package_warnings.json", label="package warnings"
+        )
+        if warnings_path.is_file():
+            paths.add(warnings_path)
+    files = manifest.get("files")
+    if not isinstance(files, dict):
+        raise ContractError("pack_manifest.json must contain a files object")
+    for file_key, raw_value in files.items():
+        # Image bytes are hydrated locally and do not affect analytical
+        # arithmetic. Selected mapping/report images are pinned separately by
+        # exact hashes, so excluding this directory keeps the structured server
+        # package fingerprint stable before and after local hydration.
+        if str(file_key) == "images_dir":
+            continue
+        if not isinstance(raw_value, str) or not raw_value.strip():
+            continue
+        relative = _safe_relative_path(raw_value, label="pack manifest file")
+        candidate = _contained_package_path(
+            package_root, relative, label="pack manifest file"
+        )
+        if candidate.is_file():
+            paths.add(candidate)
+        elif candidate.is_dir():
+            for raw_path in candidate.rglob("*"):
+                if not raw_path.is_file():
+                    continue
+                relative_child = raw_path.relative_to(package_root)
+                paths.add(
+                    _contained_package_path(
+                        package_root,
+                        relative_child,
+                        label="pack manifest directory file",
+                    )
+                )
+    return sorted(paths, key=lambda item: item.relative_to(package_root).as_posix())
+
+
+def _package_fingerprint(package_dir: Path, paths: Sequence[Path]) -> str:
+    digest = hashlib.sha256()
+    package_root = package_dir.resolve()
+    for path in paths:
+        relative = path.relative_to(package_root).as_posix().encode("utf-8")
+        digest.update(relative)
+        digest.update(b"\0")
+        digest.update(_sha256_file(path).encode("ascii"))
+        digest.update(b"\n")
+    return digest.hexdigest()
+
+
+def _normalise_warning(
+    code: str,
+    message: str,
+    *,
+    source: str,
+    interpretation: str = "",
+) -> dict[str, str]:
+    return {
+        "code": code,
+        "message": message.strip(),
+        "interpretation": interpretation.strip(),
+        "source": source,
+    }
+
+
+def _collect_package_warnings(
+    package_dir: Path,
+    summary: Mapping[str, Any],
+    manifest: Mapping[str, Any],
+    integrity: Mapping[str, Any],
+) -> list[dict[str, str]]:
+    warnings: list[dict[str, str]] = []
+    seen: set[str] = set()
+
+    def add(item: dict[str, str]) -> None:
+        if item["code"] not in seen:
+            warnings.append(item)
+            seen.add(item["code"])
+
+    overlap = manifest.get("sort_overlap_quality") or summary.get(
+        "sort_overlap_quality"
+    )
+    if isinstance(overlap, dict) and str(overlap.get("status") or "").lower() not in {
+        "",
+        "pass",
+        "ok",
+    }:
+        add(
+            _normalise_warning(
+                "sort_overlap_quality",
+                str(overlap.get("warning") or "Ranked cohort overlap needs care."),
+                source="pack_manifest.json:sort_overlap_quality",
+                interpretation=str(overlap.get("interpretation") or ""),
+            )
+        )
+
+    diagnostic_warnings = summary.get("diagnostic_warnings")
+    if isinstance(diagnostic_warnings, list):
+        for index, value in enumerate(diagnostic_warnings, start=1):
+            if isinstance(value, dict):
+                message = str(value.get("message") or value.get("warning") or "")
+                code = str(value.get("code") or f"diagnostic_warning_{index}")
+            else:
+                message = str(value)
+                code = f"diagnostic_warning_{index}"
+            if message.strip():
+                add(
+                    _normalise_warning(
+                        code,
+                        message,
+                        source="summary.json:diagnostic_warnings",
+                    )
+                )
+
+    issues = integrity.get("issues")
+    if isinstance(issues, list):
+        for index, value in enumerate(issues, start=1):
+            if not isinstance(value, dict):
+                continue
+            severity = str(value.get("severity") or value.get("status") or "").lower()
+            if severity not in {"warning", "caveat"}:
+                continue
+            code = str(
+                value.get("check_id")
+                or value.get("code")
+                or f"integrity_warning_{index}"
+            )
+            message = str(value.get("message") or value.get("detail") or code)
+            add(
+                _normalise_warning(
+                    code,
+                    message,
+                    source="package_integrity.json:issues",
+                )
+            )
+
+    raw_warnings_path = package_dir / "package_warnings.json"
+    if raw_warnings_path.exists():
+        warnings_path = _contained_package_path(
+            package_dir, "package_warnings.json", label="package warnings"
+        )
+        payload = _load_json(warnings_path)
+        raw_items = payload.get("warnings") or payload.get("issues") or []
+        if isinstance(raw_items, list):
+            for index, value in enumerate(raw_items, start=1):
+                if isinstance(value, dict):
+                    code = str(
+                        value.get("code")
+                        or value.get("check_id")
+                        or f"package_warning_{index}"
+                    )
+                    message = str(value.get("message") or value.get("warning") or code)
+                    interpretation = str(value.get("interpretation") or "")
+                else:
+                    code = f"package_warning_{index}"
+                    message = str(value)
+                    interpretation = ""
+                add(
+                    _normalise_warning(
+                        code,
+                        message,
+                        source="package_warnings.json",
+                        interpretation=interpretation,
+                    )
+                )
+    return warnings
+
+
+def _load_attribute_table_runtime() -> Any:
+    plugin_root = Path(__file__).resolve().parents[1]
+    candidates = [plugin_root / "vendor", plugin_root.parents[1]]
+    for candidate in candidates:
+        template = candidate / "modules" / "pdp" / "attribute_table_templates.py"
+        if template.is_file():
+            loaded = sys.modules.get("attribute_reporting_table_templates")
+            if loaded is not None and getattr(loaded, "__file__", None) == str(
+                template
+            ):
+                return loaded
+            candidate_text = str(candidate)
+            if candidate_text not in sys.path:
+                sys.path.insert(0, candidate_text)
+            # The table module is standalone. Importing its parent PDP package
+            # in a source checkout also loads scraping adapters and their
+            # unrelated dependencies, which are absent from this component.
+            spec = importlib.util.spec_from_file_location(
+                "attribute_reporting_table_templates", template
+            )
+            if spec is None or spec.loader is None:
+                raise ContractError(f"Cannot load attribute-table runtime: {template}")
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[spec.name] = module
+            spec.loader.exec_module(module)
+            return module
+    raise ContractError(
+        "The deterministic attribute-table runtime is unavailable. Run the plugin "
+        "dependency checker and use the packaged plugin or the app repository."
+    )
+
+
+def _load_attribute_table_builder() -> Any:
+    return _load_attribute_table_runtime().build_attribute_tables_from_package
+
+
+def _display(text: str, language: str) -> str:
+    return str(_load_attribute_table_runtime().report_display_text(text, language))
+
+
+def _report_language(value: Any) -> str:
+    if value not in ("en", "it", "fr", "de", "es"):
+        raise ContractError("Report language must be en, it, fr, de or es")
+    return str(value)
+
+
+def _verdict_placeholder(language: str) -> str:
+    result = VERDICT_PLACEHOLDER_HTML
+    for text in (
+        "Correctness review pending",
+        "The final evidence-backed verdict will replace this banner after independent semantic review and browser QA.",
+    ):
+        result = result.replace(text, html.escape(_display(text, language)))
+    return result
+
+
+def _build_attribute_tables(
+    package_dir: Path, evidence_dir: Path, language: str
+) -> dict[str, Any]:
+    builder = _load_attribute_table_builder()
+    result = dict(builder(package_dir, output_dir=evidence_dir, language=language))
+    enriched_tables: list[dict[str, Any]] = []
+    for raw_item in result.get("tables") or []:
+        item = dict(raw_item)
+        csv_relative = _safe_relative_path(
+            str(item["csv"]), label="attribute table CSV"
+        )
+        html_relative = _safe_relative_path(
+            str(item["html"]), label="attribute table HTML"
+        )
+        item["csv_sha256"] = _sha256_file(evidence_dir / csv_relative)
+        item["html_sha256"] = _sha256_file(evidence_dir / html_relative)
+        enriched_tables.append(item)
+    result["tables"] = enriched_tables
+    return result
+
+
+def _catalog_source(
+    package_dir: Path, file_name: str, preview_rows: int
+) -> dict[str, Any]:
+    raw_path = package_dir / file_name
+    if not raw_path.exists():
+        return {
+            "file": file_name,
+            "status": "missing",
+            "sha256": None,
+            "row_count": 0,
+            "columns": [],
+            "preview": [],
+        }
+    path = _contained_package_path(package_dir, file_name, label="catalog source")
+    if path.suffix.lower() == ".csv":
+        columns, rows = _read_csv(path)
+        return {
+            "file": file_name,
+            "status": "available",
+            "sha256": _sha256_file(path),
+            "row_count": len(rows),
+            "columns": columns,
+            "preview": rows[:preview_rows],
+        }
+    payload = _load_json(path)
+    return {
+        "file": file_name,
+        "status": "available",
+        "sha256": _sha256_file(path),
+        "row_count": 1,
+        "columns": sorted(payload),
+        "preview": [payload],
+    }
+
+
+def _report_model_template(
+    *,
+    report_id: str,
+    author_agent_id: str,
+    summary: Mapping[str, Any],
+    warnings: Sequence[Mapping[str, str]],
+    language: str = "en",
+) -> dict[str, Any]:
+    retailer = str(
+        summary.get("retailer_label") or summary.get("retailer") or "Retailer"
+    )
+    category = str(
+        summary.get("category_label") or summary.get("category_key") or "Category"
+    )
+    titles = {
+        "executive_summary": "Executive summary",
+        "winning_now": "Winning now",
+        "brand_context": "Brand context",
+        "emerging_signal": "Emerging signal",
+        "winner_emerging_bridge": "Winners and emerging signals",
+        "product_evidence": "Product evidence",
+        "method_and_caveats": "Method and caveats",
+    }
+    return {
+        "schema_version": MODEL_SCHEMA,
+        "language": language,
+        "report_id": report_id,
+        "author": {
+            "execution": "codex_agent",
+            "agent_id": author_agent_id,
+            "role": "report_author",
+        },
+        "title": f"{retailer} {category}",
+        "subtitle": _display(
+            "Attribute signals across retailer-defined newness and sales rank", language
+        ),
+        "audience": _display("Market and product teams", language),
+        "acknowledged_warning_codes": [item["code"] for item in warnings],
+        "sections": [
+            {
+                "section_id": section_id,
+                "title": _display(titles[section_id], language),
+                "summary": "",
+                "claim_ids": [],
+                "table_keys": [],
+            }
+            for section_id in REQUIRED_SECTION_IDS
+        ],
+        "claims": [],
+        "featured_products": [],
+        "limitations": [
+            {
+                "code": item["code"],
+                "text": item["message"],
+            }
+            for item in warnings
+        ],
+        "authoring_status": "template_requires_codex",
+    }
+
+
+def _semantic_review_template(
+    *,
+    report_id: str,
+    author_agent_id: str,
+) -> dict[str, Any]:
+    return {
+        "schema_version": REVIEW_SCHEMA,
+        "review_id": "replace-with-independent-review-id",
+        "reviewer": {
+            "execution": "codex_agent",
+            "agent_id": "replace-with-independent-agent-id",
+            "role": "independent_reviewer",
+            "tier": "low_cost",
+            "independent_from_author": True,
+        },
+        "author_agent_id": author_agent_id,
+        "targets": {
+            "report_id": report_id,
+            "evidence_catalog_sha256": "replace-after-render",
+            "report_model_sha256": "replace-after-render",
+            "draft_html_sha256": "replace-after-render",
+        },
+        "overall_verdict": "unable_to_determine",
+        "summary": "Independent semantic review has not run.",
+        "dimensions": {
+            dimension: {
+                "status": "unable_to_determine",
+                "rationale": "Not reviewed.",
+            }
+            for dimension in REQUIRED_REVIEW_DIMENSIONS
+        },
+        "claim_reviews": [],
+        "report_level_findings": [],
+        "images_reviewed": [],
+    }
+
+
+def _receipt_integer(value: Any, *, label: str) -> int:
+    """Return one non-negative receipt integer without accepting booleans."""
+
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise ContractError(f"{label} must be a non-negative integer")
+    return value
+
+
+def _receipt_sha256(value: Any, *, label: str) -> str:
+    """Return one canonical SHA-256 receipt value."""
+
+    checksum = str(value or "")
+    if not re.fullmatch(r"[0-9a-f]{64}", checksum):
+        raise ContractError(f"{label} must be a lowercase SHA-256 value")
+    return checksum
+
+
+def _receipt_relative_path(value: Any, *, label: str) -> Path:
+    """Return one canonical POSIX path from an extraction receipt."""
+
+    raw_value = str(value or "")
+    if "\\" in raw_value:
+        raise ContractError(f"{label} must use POSIX separators")
+    relative = _safe_relative_path(raw_value, label=label)
+    if relative.as_posix() != raw_value:
+        raise ContractError(f"{label} is not a canonical relative path: {raw_value!r}")
+    return relative
+
+
+def _path_without_symlink_components(path: Path, *, label: str) -> Path:
+    """Resolve an existing path after rejecting every symlink component."""
+
+    expanded = path.expanduser()
+    absolute = expanded if expanded.is_absolute() else Path.cwd() / expanded
+    absolute = Path(os.path.abspath(absolute))
+    current = Path(absolute.anchor)
+    for part in absolute.parts[1:]:
+        current /= part
+        if current.is_symlink():
+            raise ContractError(f"{label} cannot contain symlinks: {path}")
+    return absolute.resolve()
+
+
+def _load_local_transport_receipt(path: Path, *, label: str) -> dict[str, Any]:
+    """Load one small ordinary receipt from a path without symlinks."""
+
+    resolved = _path_without_symlink_components(path, label=label)
+    if not resolved.is_file():
+        raise ContractError(f"{label} is unavailable: {resolved}")
+    if resolved.stat().st_size > MAX_LOCAL_TRANSPORT_RECEIPT_BYTES:
+        raise ContractError(f"{label} exceeds the local receipt size limit")
+    return _load_json(resolved)
+
+
+def _load_no_work_workset(path: Path) -> tuple[Path, dict[str, Any]]:
+    """Load one bounded public no-work envelope without following symlinks."""
+
+    resolved = _path_without_symlink_components(
+        path,
+        label="No-work mapping workset",
+    )
+    if not resolved.is_file():
+        raise ContractError(f"No-work mapping workset is unavailable: {resolved}")
+    if resolved.stat().st_size > MAX_NO_WORK_WORKSET_BYTES:
+        raise ContractError("No-work mapping workset exceeds the local size limit")
+    return resolved, _load_json(resolved)
+
+
+def _validate_no_work_workset(
+    workset: Mapping[str, Any],
+    *,
+    package_summary: Mapping[str, Any],
+    expected_job_id: str,
+) -> dict[str, Any]:
+    """Validate an explicit server no-work branch against its preliminary pack."""
+
+    if workset.get("schema_version") != (
+        f"{SERVER_BRIDGE_SCHEMA_PREFIX}.mapping_workset.v1"
+    ):
+        raise ContractError("Unsupported no-work mapping-workset schema")
+    if workset.get("status") != "no_work":
+        raise ContractError("No-work mapping workset must have status no_work")
+    if workset.get("mapping_mode") != "unresolved":
+        raise ContractError("No-work mapping workset must use unresolved mode")
+    if workset.get("correction_reason") not in {None, ""}:
+        raise ContractError("No-work mapping workset cannot carry a correction reason")
+
+    evidence_job_id = str(workset.get("evidence_job_id") or "").strip()
+    if not evidence_job_id or evidence_job_id != expected_job_id:
+        raise ContractError(
+            "No-work mapping workset belongs to another evidence download"
+        )
+    tasks = workset.get("mapping_tasks")
+    if (
+        not isinstance(tasks, dict)
+        or tasks.get("schema_version") != MAPPING_TASK_SCHEMA
+    ):
+        raise ContractError("No-work mapping workset has invalid mapping tasks")
+    task_rows = tasks.get("tasks")
+    if task_rows != []:
+        raise ContractError("No-work mapping workset must contain zero tasks")
+    coverage = tasks.get("coverage")
+    if not isinstance(coverage, dict):
+        raise ContractError("No-work mapping workset has no coverage object")
+
+    integer_fields = (
+        "task_count",
+        "task_count_before_limit",
+        "resolved_attribute_cells",
+        "unresolved_attribute_cells",
+        "variant_attribute_cells_skipped",
+    )
+    counts: dict[str, int] = {}
+    for field in integer_fields:
+        value = coverage.get(field)
+        if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+            raise ContractError(
+                f"No-work mapping coverage {field} must be a non-negative integer"
+            )
+        counts[field] = value
+    if counts["task_count"] != 0 or counts["task_count_before_limit"] != 0:
+        raise ContractError("No-work mapping coverage must report zero tasks")
+    if counts["unresolved_attribute_cells"] != 0:
+        raise ContractError(
+            "No-work mapping coverage cannot report unresolved product cells"
+        )
+    if coverage.get("include_resolved") is not False:
+        raise ContractError("No-work mapping coverage must exclude resolved cells")
+    if coverage.get("truncated") is not False:
+        raise ContractError("No-work mapping coverage cannot be truncated")
+
+    scope = tasks.get("scope")
+    if not isinstance(scope, dict):
+        raise ContractError("No-work mapping tasks have no source scope")
+    expected_retailer = str(package_summary.get("retailer") or "")
+    expected_category = str(package_summary.get("category_key") or "")
+    if (
+        str(scope.get("retailer") or "") != expected_retailer
+        or str(scope.get("category_key") or "") != expected_category
+    ):
+        raise ContractError("No-work mapping workset belongs to another package scope")
+    if str(scope.get("source_package") or "") != f"evidence-job:{evidence_job_id}":
+        raise ContractError("No-work mapping workset has an invalid evidence locator")
+    if str(workset.get("workset_sha256") or "") != _canonical_json_sha256(tasks):
+        raise ContractError("No-work mapping workset hash is inconsistent")
+
+    return {
+        "schema_version": NO_WORK_MAPPING_BASIS_SCHEMA,
+        "status": "no_work",
+        "mapping_mode": "unresolved",
+        "mapping_review": "not_applicable",
+        "evidence_job_id": evidence_job_id,
+        "workset_id": str(workset.get("workset_id") or ""),
+        "task_count": 0,
+        "include_resolved": False,
+        "resolved_attribute_cells": counts["resolved_attribute_cells"],
+        "unresolved_attribute_cells": 0,
+        "variant_attribute_cells_skipped": counts["variant_attribute_cells_skipped"],
+    }
+
+
+def _package_file_ledger(package_dir: Path) -> dict[str, Path]:
+    """Return every ordinary package file while rejecting links/special files."""
+
+    package = package_dir.resolve()
+    files: dict[str, Path] = {}
+    for candidate in package.rglob("*"):
+        relative = candidate.relative_to(package).as_posix()
+        if candidate.is_symlink():
+            raise ContractError(
+                f"Evidence package contains a symlink after extraction: {relative}"
+            )
+        if candidate.is_dir():
+            continue
+        if not candidate.is_file():
+            raise ContractError(
+                f"Evidence package contains a non-regular file: {relative}"
+            )
+        files[relative] = candidate
+    return files
+
+
+def _validate_hydration_additions(
+    package_dir: Path,
+    *,
+    current_files: Mapping[str, Path],
+    addition_paths: set[str],
+) -> None:
+    """Verify that post-extraction files are genuine local image hydration output."""
+
+    if not addition_paths:
+        return
+    manifest_path = current_files.get("local_image_manifest.json")
+    if manifest_path is None:
+        raise ContractError(
+            "Post-extraction image files require local_image_manifest.json"
+        )
+    manifest = _load_json(manifest_path)
+    if manifest.get("schema_version") != LOCAL_IMAGE_MANIFEST_SCHEMA:
+        raise ContractError("Unsupported local image manifest schema")
+    manifest_package = Path(str(manifest.get("package_dir") or "")).expanduser()
+    if manifest_package.resolve() != package_dir.resolve():
+        raise ContractError("Local image manifest belongs to another package")
+
+    referenced_images: dict[str, tuple[str, int]] = {}
+    products = manifest.get("products")
+    if not isinstance(products, list):
+        raise ContractError("Local image manifest products must be a list")
+    for product in products:
+        if not isinstance(product, dict):
+            raise ContractError("Local image manifest contains an invalid product")
+        raw_image_path = str(product.get("image_path") or "")
+        if not raw_image_path:
+            continue
+        if product.get("status") not in {"downloaded", "existing", "reused"}:
+            raise ContractError(
+                f"Local image manifest has an image for invalid status: {raw_image_path}"
+            )
+        image_relative = _receipt_relative_path(
+            raw_image_path,
+            label="local image manifest path",
+        )
+        if image_relative.parts[:2] != ("images", "local"):
+            continue
+        image_sha256 = _receipt_sha256(
+            product.get("sha256"),
+            label=f"local image hash for {raw_image_path}",
+        )
+        image_size = _receipt_integer(
+            product.get("byte_count"),
+            label=f"local image size for {raw_image_path}",
+        )
+        prior = referenced_images.setdefault(
+            image_relative.as_posix(),
+            (image_sha256, image_size),
+        )
+        if prior != (image_sha256, image_size):
+            raise ContractError(
+                f"Local image manifest conflicts for {image_relative.as_posix()}"
+            )
+
+    for relative in sorted(addition_paths):
+        if relative == "local_image_manifest.json":
+            continue
+        path = current_files[relative]
+        expected = referenced_images.get(relative)
+        if expected is None:
+            raise ContractError(
+                f"Unpinned post-extraction image file is not allowed: {relative}"
+            )
+        if not _is_supported_local_image(path):
+            raise ContractError(
+                f"Post-extraction image is not a supported raster: {relative}"
+            )
+        expected_sha256, expected_size = expected
+        if (
+            path.stat().st_size != expected_size
+            or _sha256_file(path) != expected_sha256
+        ):
+            raise ContractError(
+                f"Post-extraction image differs from its manifest: {relative}"
+            )
+
+
+def _validate_local_transport_receipts(
+    package_dir: Path,
+    download_receipt: Mapping[str, Any],
+    extraction_receipt: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Validate authenticated-download lineage against the current local package."""
+
+    expected_download_keys = {
+        "schema_version",
+        "job_id",
+        "path",
+        "sha256",
+        "size_bytes",
+    }
+    expected_extraction_keys = {
+        "schema_version",
+        "archive_path",
+        "archive_sha256",
+        "output_dir",
+        "file_count",
+        "total_size_bytes",
+        "files",
+    }
+    if set(download_receipt) != expected_download_keys:
+        raise ContractError("Local download receipt has an invalid v1 schema")
+    if set(extraction_receipt) != expected_extraction_keys:
+        raise ContractError("Local extraction receipt has an invalid v1 schema")
+    if download_receipt.get("schema_version") != LOCAL_DOWNLOAD_RECEIPT_SCHEMA:
+        raise ContractError("Unsupported local download receipt schema")
+    if extraction_receipt.get("schema_version") != LOCAL_EXTRACTION_RECEIPT_SCHEMA:
+        raise ContractError("Unsupported local extraction receipt schema")
+    job_id = str(download_receipt.get("job_id") or "").strip()
+    if not job_id or len(job_id) > 256:
+        raise ContractError("Local download receipt requires a bounded job_id")
+
+    archive = _path_without_symlink_components(
+        Path(str(download_receipt.get("path") or "")),
+        label="Downloaded evidence archive",
+    )
+    extraction_archive = _path_without_symlink_components(
+        Path(str(extraction_receipt.get("archive_path") or "")),
+        label="Extracted evidence archive",
+    )
+    if archive != extraction_archive:
+        raise ContractError(
+            "Download and extraction receipts identify different archives"
+        )
+    if not archive.is_file():
+        raise ContractError(f"Downloaded evidence archive is unavailable: {archive}")
+    archive_sha256 = _receipt_sha256(
+        download_receipt.get("sha256"),
+        label="download receipt archive hash",
+    )
+    extraction_archive_sha256 = _receipt_sha256(
+        extraction_receipt.get("archive_sha256"),
+        label="extraction receipt archive hash",
+    )
+    if archive_sha256 != extraction_archive_sha256:
+        raise ContractError("Download and extraction archive hashes differ")
+    archive_size = _receipt_integer(
+        download_receipt.get("size_bytes"),
+        label="download receipt archive size",
+    )
+    if (
+        archive.stat().st_size != archive_size
+        or _sha256_file(archive) != archive_sha256
+    ):
+        raise ContractError("Downloaded evidence archive changed after verification")
+
+    package = package_dir.expanduser().resolve()
+    extraction_output = _path_without_symlink_components(
+        Path(str(extraction_receipt.get("output_dir") or "")),
+        label="Evidence extraction output",
+    )
+    if extraction_output != package:
+        raise ContractError("Extraction receipt belongs to another package directory")
+    raw_files = extraction_receipt.get("files")
+    if not isinstance(raw_files, list) or len(raw_files) > 1_000:
+        raise ContractError("Local extraction receipt has an invalid files ledger")
+    expected_files: dict[str, tuple[str, int]] = {}
+    casefold_paths: set[str] = set()
+    for item in raw_files:
+        if not isinstance(item, dict) or set(item) != {
+            "path",
+            "sha256",
+            "size_bytes",
+        }:
+            raise ContractError("Local extraction receipt has an invalid file row")
+        relative = _receipt_relative_path(
+            item.get("path"),
+            label="extraction receipt file",
+        ).as_posix()
+        collision_key = relative.casefold()
+        if relative in expected_files or collision_key in casefold_paths:
+            raise ContractError(
+                f"Local extraction receipt has a duplicate file: {relative}"
+            )
+        casefold_paths.add(collision_key)
+        expected_files[relative] = (
+            _receipt_sha256(
+                item.get("sha256"),
+                label=f"extraction receipt hash for {relative}",
+            ),
+            _receipt_integer(
+                item.get("size_bytes"),
+                label=f"extraction receipt size for {relative}",
+            ),
+        )
+    expected_count = _receipt_integer(
+        extraction_receipt.get("file_count"),
+        label="extraction receipt file_count",
+    )
+    expected_total = _receipt_integer(
+        extraction_receipt.get("total_size_bytes"),
+        label="extraction receipt total_size_bytes",
+    )
+    if expected_count != len(expected_files) or expected_total != sum(
+        size for _checksum, size in expected_files.values()
+    ):
+        raise ContractError("Local extraction receipt summary differs from its ledger")
+
+    current_files = _package_file_ledger(package)
+    for relative, (expected_sha256, expected_size) in expected_files.items():
+        path = current_files.get(relative)
+        if path is None:
+            raise ContractError(
+                f"Extracted package file is missing after extraction: {relative}"
+            )
+        if (
+            path.stat().st_size != expected_size
+            or _sha256_file(path) != expected_sha256
+        ):
+            raise ContractError(
+                f"Extracted package file changed after extraction: {relative}"
+            )
+    addition_paths = set(current_files) - set(expected_files)
+    invalid_additions = sorted(
+        relative
+        for relative in addition_paths
+        if relative != "local_image_manifest.json"
+        and not relative.startswith("images/local/")
+    )
+    if invalid_additions:
+        raise ContractError(
+            "Evidence package has unapproved post-extraction files: "
+            + ", ".join(invalid_additions)
+        )
+    _validate_hydration_additions(
+        package,
+        current_files=current_files,
+        addition_paths=addition_paths,
+    )
+    return {
+        "schema_version": TRANSPORT_LINEAGE_SCHEMA,
+        "status": "verified",
+        "download": {
+            "job_id": job_id,
+            "archive_path": str(archive),
+            "archive_sha256": archive_sha256,
+            "archive_size_bytes": archive_size,
+        },
+        "extraction": {
+            "package_dir": str(package),
+            "file_count": expected_count,
+            "total_size_bytes": expected_total,
+            "hydration_additions": sorted(addition_paths),
+        },
+    }
+
+
+def _load_transport_receipts(
+    package_dir: Path,
+    *,
+    download_receipt_path: Path | None,
+    extraction_receipt_path: Path | None,
+    required: bool,
+) -> tuple[dict[str, Any] | None, tuple[Path, Path] | None]:
+    """Load and validate a complete local receipt pair when supplied or required."""
+
+    supplied = (download_receipt_path is not None, extraction_receipt_path is not None)
+    if required and not all(supplied):
+        raise ContractError(
+            "Server provenance requires both --download-receipt and "
+            "--extraction-receipt"
+        )
+    if any(supplied) and not all(supplied):
+        raise ContractError(
+            "Download and extraction receipts must be supplied together"
+        )
+    if not any(supplied):
+        return None, None
+    if download_receipt_path is None or extraction_receipt_path is None:
+        raise ContractError(
+            "Download and extraction receipts must be supplied together"
+        )
+    download_source = _path_without_symlink_components(
+        download_receipt_path,
+        label="Local download receipt",
+    )
+    extraction_source = _path_without_symlink_components(
+        extraction_receipt_path,
+        label="Local extraction receipt",
+    )
+    download = _load_local_transport_receipt(
+        download_source,
+        label="Local download receipt",
+    )
+    extraction = _load_local_transport_receipt(
+        extraction_source,
+        label="Local extraction receipt",
+    )
+    lineage = _validate_local_transport_receipts(package_dir, download, extraction)
+    return lineage, (download_source, extraction_source)
+
+
+def _copy_transport_receipts(
+    package_dir: Path,
+    output_dir: Path,
+    receipt_sources: tuple[Path, Path],
+) -> dict[str, Any]:
+    """Copy validated transport receipts and bind their exact output hashes."""
+
+    targets = tuple(
+        output_dir / file_name for file_name in LOCAL_TRANSPORT_RECEIPT_FILES
+    )
+    for source, target in zip(receipt_sources, targets, strict=True):
+        if source != target.resolve():
+            shutil.copyfile(source, target)
+    download = _load_local_transport_receipt(
+        targets[0],
+        label="Copied local download receipt",
+    )
+    extraction = _load_local_transport_receipt(
+        targets[1],
+        label="Copied local extraction receipt",
+    )
+    lineage = _validate_local_transport_receipts(package_dir, download, extraction)
+    return {
+        **lineage,
+        "artifacts": {target.name: _sha256_file(target) for target in targets},
+    }
+
+
+def _validate_server_mapping_acceptance(
+    *,
+    provenance_root: Path,
+    provenance_payloads: Mapping[str, Mapping[str, Any]],
+    review_validation: Mapping[str, Any],
+    package_summary: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Validate the server receipts that prove reviewed mappings were accepted."""
+
+    submission = _load_json(provenance_root / "mapping_submission_receipt.json")
+    server_review = _load_json(provenance_root / "mapping_review_validation.json")
+    sanitization = _load_json(provenance_root / "server_sanitization_receipt.json")
+    if submission.get("schema_version") != (
+        f"{SERVER_BRIDGE_SCHEMA_PREFIX}.mapping_submission_receipt.v1"
+    ):
+        raise ContractError("Unsupported server mapping-submission receipt schema")
+    if server_review.get("schema_version") != MAPPING_REVIEW_VALIDATION_SCHEMA:
+        raise ContractError("Unsupported server mapping-review validation schema")
+    if sanitization.get("schema_version") != (
+        f"{SERVER_BRIDGE_SCHEMA_PREFIX}.package_sanitization.v1"
+    ):
+        raise ContractError("Unsupported server package-sanitization receipt schema")
+
+    stable_server_review = {
+        key: value for key, value in server_review.items() if key != "validated_at"
+    }
+    stable_local_review = {
+        key: value for key, value in review_validation.items() if key != "validated_at"
+    }
+    if stable_server_review != stable_local_review:
+        raise ContractError(
+            "Server mapping-review validation differs from the reviewed mappings"
+        )
+
+    tasks = provenance_payloads["mapping_tasks.json"]
+    decisions = provenance_payloads["mapping_decisions.json"]
+    validated = provenance_payloads["validated_mappings.json"]
+    expected_validation = validate_mapping_payloads(tasks, decisions)
+    if _stable_mapping_validation(validated) != _stable_mapping_validation(
+        expected_validation
+    ) or validated.get("validation_sha256") != expected_validation.get(
+        "validation_sha256"
+    ):
+        raise ContractError(
+            "Server-accepted validated mappings differ from their task decisions"
+        )
+    expected_operation_id = _canonical_json_sha256(
+        {
+            "validation_sha256": expected_validation["validation_sha256"],
+            "mapping_review_validation_sha256": review_validation[
+                "review_validation_sha256"
+            ],
+        }
+    )
+    taxonomy_snapshot = tasks.get("taxonomy_snapshot")
+    task_scope = tasks.get("scope")
+    if not isinstance(taxonomy_snapshot, dict) or not isinstance(task_scope, dict):
+        raise ContractError("Server mapping provenance has no pinned taxonomy or scope")
+    expected_submission_fields = {
+        "operation_id": expected_operation_id,
+        "validation_sha256": expected_validation["validation_sha256"],
+        "mapping_review_sha256": review_validation["mapping_review_sha256"],
+        "mapping_review_validation_sha256": review_validation[
+            "review_validation_sha256"
+        ],
+        "mapping_review_state": review_validation["review_state"],
+        "taxonomy_snapshot": {
+            "version": taxonomy_snapshot.get("version"),
+            "sha256": taxonomy_snapshot.get("sha256"),
+        },
+    }
+    if any(
+        submission.get(key) != value
+        for key, value in expected_submission_fields.items()
+    ):
+        raise ContractError("Server mapping-submission receipt is inconsistent")
+    if submission.get("database_write") not in {"applied", "already_applied"}:
+        raise ContractError("Server mapping-submission receipt has no accepted write")
+    if not str(submission.get("submitted_by") or "").strip():
+        raise ContractError("Server mapping-submission receipt has no actor")
+    if review_validation.get("review_state") not in {
+        "approved",
+        "approved_with_caveats",
+    }:
+        raise ContractError("Server mapping review does not approve the mappings")
+
+    if str(task_scope.get("retailer") or "") != str(
+        package_summary.get("retailer") or ""
+    ) or str(task_scope.get("category_key") or "") != str(
+        package_summary.get("category_key") or ""
+    ):
+        raise ContractError(
+            "Server-accepted mappings belong to another retailer/category scope"
+        )
+    expected_hash_files = (
+        *MAPPING_PROVENANCE_FILES,
+        *SERVER_MAPPING_PROVENANCE_FILES[:2],
+    )
+    expected_hashes = {
+        file_name: _sha256_file(provenance_root / file_name)
+        for file_name in expected_hash_files
+    }
+    if sanitization.get("mapping_provenance") != expected_hashes:
+        raise ContractError(
+            "Server package-sanitization receipt does not pin mapping provenance"
+        )
+    if (
+        sanitization.get("image_policy") != "urls_only_no_image_bytes"
+        or sanitization.get("package_integrity_status") != "pass"
+    ):
+        raise ContractError("Server package-sanitization receipt is not approved")
+    return {
+        "status": "server_accepted",
+        "operation_id": expected_operation_id,
+        "submitted_by": submission["submitted_by"],
+        "database_write": submission["database_write"],
+        "artifacts": {
+            file_name: _sha256_file(provenance_root / file_name)
+            for file_name in SERVER_MAPPING_PROVENANCE_FILES
+        },
+    }
+
+
+def _validate_preliminary_sanitization_receipt(package_dir: Path) -> str:
+    """Validate the URL-only, no-mapping receipt on a preliminary server pack."""
+
+    receipt_path = _contained_package_path(
+        package_dir,
+        "server_sanitization_receipt.json",
+        label="preliminary server sanitization receipt",
+    )
+    if not receipt_path.is_file():
+        raise ContractError(
+            "A no-work server package requires server_sanitization_receipt.json"
+        )
+    receipt = _load_json(receipt_path)
+    if receipt.get("schema_version") != (
+        f"{SERVER_BRIDGE_SCHEMA_PREFIX}.package_sanitization.v1"
+    ):
+        raise ContractError("Unsupported preliminary server sanitization schema")
+    if (
+        receipt.get("image_policy") != "urls_only_no_image_bytes"
+        or receipt.get("package_integrity_status") != "pass"
+        or receipt.get("mapping_provenance") != {}
+    ):
+        raise ContractError(
+            "Preliminary server sanitization does not prove a URL-only, "
+            "no-mapping-provenance package"
+        )
+    for field in (
+        "removed_image_file_count",
+        "sanitized_private_path_field_count",
+    ):
+        value = receipt.get(field)
+        if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+            raise ContractError(f"Preliminary server sanitization {field} is invalid")
+    return _sha256_file(receipt_path)
+
+
+def prepare_run(
+    package_dir: Path,
+    output_dir: Path,
+    *,
+    author_agent_id: str,
+    language: str = "en",
+    preview_rows: int = 12,
+    require_browser_qa: bool = False,
+    mapping_provenance_dir: Path | None = None,
+    download_receipt_path: Path | None = None,
+    extraction_receipt_path: Path | None = None,
+    no_work_workset_path: Path | None = None,
+) -> dict[str, Any]:
+    """Prepare immutable evidence views and Codex authoring templates."""
+
+    language = _report_language(language)
+    package = package_dir.expanduser().resolve()
+    if not package.is_dir():
+        raise ContractError(f"Evidence package directory not found: {package}")
+    output = _assert_safe_output_dir(output_dir)
+    if not author_agent_id.strip():
+        raise ContractError("author_agent_id is required")
+    if preview_rows < 1 or preview_rows > 100:
+        raise ContractError("preview_rows must be between 1 and 100")
+
+    summary_path = _contained_package_path(
+        package, "summary.json", label="package summary"
+    )
+    manifest_path = _contained_package_path(
+        package, "pack_manifest.json", label="pack manifest"
+    )
+    integrity_path = _contained_package_path(
+        package, "package_integrity.json", label="package integrity"
+    )
+    summary = _load_json(summary_path)
+    manifest = _load_json(manifest_path)
+    integrity = _load_json(integrity_path)
+    if str(integrity.get("status") or "").lower() != "pass":
+        raise ContractError(
+            "Evidence package integrity is not pass; report authoring is blocked."
+        )
+
+    provenance_root = (
+        mapping_provenance_dir.expanduser().resolve()
+        if mapping_provenance_dir is not None
+        else package
+    )
+    provenance_present = {
+        file_name: (provenance_root / file_name).is_file()
+        for file_name in MAPPING_PROVENANCE_FILES
+    }
+    server_provenance_present = {
+        file_name: (provenance_root / file_name).is_file()
+        for file_name in SERVER_MAPPING_PROVENANCE_FILES
+    }
+    present_server_count = sum(server_provenance_present.values())
+    no_work_source: Path | None = None
+    no_work_payload: dict[str, Any] | None = None
+    if no_work_workset_path is not None:
+        no_work_source, no_work_payload = _load_no_work_workset(no_work_workset_path)
+        mapping_server_receipts_present = any(
+            server_provenance_present[file_name]
+            for file_name in SERVER_MAPPING_PROVENANCE_FILES[:2]
+        )
+        if (
+            mapping_provenance_dir is not None
+            or any(provenance_present.values())
+            or mapping_server_receipts_present
+        ):
+            raise ContractError(
+                "A no-work mapping branch cannot also carry new-mapping provenance"
+            )
+        if not server_provenance_present["server_sanitization_receipt.json"]:
+            raise ContractError(
+                "A no-work server package requires its preliminary sanitization receipt"
+            )
+    transport_validation, receipt_sources = _load_transport_receipts(
+        package,
+        download_receipt_path=download_receipt_path,
+        extraction_receipt_path=extraction_receipt_path,
+        required=bool(present_server_count or no_work_payload is not None),
+    )
+    no_work_basis: dict[str, Any] | None = None
+    if no_work_payload is not None:
+        if transport_validation is None:
+            raise ContractError(
+                "A no-work mapping branch requires verified preliminary transport lineage"
+            )
+        no_work_basis = _validate_no_work_workset(
+            no_work_payload,
+            package_summary=summary,
+            expected_job_id=str(transport_validation["download"]["job_id"]),
+        )
+        no_work_basis["server_sanitization_receipt_sha256"] = (
+            _validate_preliminary_sanitization_receipt(package)
+        )
+
+    source_paths = _package_source_paths(package, manifest)
+    package_sha256 = _package_fingerprint(package, source_paths)
+    warnings = _collect_package_warnings(package, summary, manifest, integrity)
+    report_id = "--".join(
+        [
+            str(summary.get("retailer") or "retailer"),
+            str(summary.get("category_key") or "category"),
+            datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ"),
+        ]
+    )
+    sources = [
+        _catalog_source(package, file_name, preview_rows)
+        for file_name in sorted(ALLOWED_EVIDENCE_FILES)
+    ]
+    output.mkdir(parents=True, exist_ok=True)
+    os.chmod(output, 0o700)
+    transport_lineage = (
+        _copy_transport_receipts(package, output, receipt_sources)
+        if receipt_sources is not None
+        else None
+    )
+    if no_work_basis is not None and no_work_source is not None:
+        no_work_target = output / NO_WORK_WORKSET_FILE
+        if no_work_source != no_work_target.resolve():
+            shutil.copyfile(no_work_source, no_work_target)
+        os.chmod(no_work_target, 0o600)
+        no_work_basis = {
+            **no_work_basis,
+            "artifact": NO_WORK_WORKSET_FILE,
+            "artifact_sha256": _sha256_file(no_work_target),
+        }
+    evidence_dir = output / "evidence"
+    tables_result = _build_attribute_tables(package, evidence_dir, language)
+    provenance: dict[str, Any] | None = None
+    if no_work_basis is None and (
+        mapping_provenance_dir is not None
+        or any(provenance_present.values())
+        or present_server_count
+    ):
+        missing = sorted(
+            file_name
+            for file_name, is_present in provenance_present.items()
+            if not is_present
+        )
+        if missing:
+            raise ContractError(
+                "Mapping provenance is incomplete; missing: " + ", ".join(missing)
+            )
+        provenance_payloads = {
+            file_name: _load_json(provenance_root / file_name)
+            for file_name in MAPPING_PROVENANCE_FILES
+        }
+        provenance_validation = validate_mapping_review_payloads(
+            provenance_payloads["mapping_tasks.json"],
+            provenance_payloads["mapping_decisions.json"],
+            provenance_payloads["validated_mappings.json"],
+            provenance_payloads["mapping_review.json"],
+        )
+        if provenance_validation["review_state"] not in {
+            "approved",
+            "approved_with_caveats",
+        }:
+            raise ContractError(
+                "Mapping provenance is not approved by its independent review."
+            )
+        if present_server_count not in {0, len(SERVER_MAPPING_PROVENANCE_FILES)}:
+            missing_server = sorted(
+                file_name
+                for file_name, is_present in server_provenance_present.items()
+                if not is_present
+            )
+            raise ContractError(
+                "Server mapping provenance is incomplete; missing: "
+                + ", ".join(missing_server)
+            )
+        server_acceptance = (
+            _validate_server_mapping_acceptance(
+                provenance_root=provenance_root,
+                provenance_payloads=provenance_payloads,
+                review_validation=provenance_validation,
+                package_summary=summary,
+            )
+            if present_server_count
+            else {
+                "status": "local_review_only",
+                "operation_id": None,
+                "submitted_by": None,
+                "database_write": None,
+                "artifacts": {},
+            }
+        )
+        provenance_hashes: dict[str, str] = {}
+        for file_name in MAPPING_PROVENANCE_FILES:
+            source = provenance_root / file_name
+            target = output / file_name
+            if source.resolve() != target.resolve():
+                shutil.copyfile(source, target)
+            provenance_hashes[file_name] = _sha256_file(target)
+        server_provenance_hashes: dict[str, str] = {}
+        if present_server_count:
+            for file_name in SERVER_MAPPING_PROVENANCE_FILES:
+                source = provenance_root / file_name
+                target = output / file_name
+                if source.resolve() != target.resolve():
+                    shutil.copyfile(source, target)
+                server_provenance_hashes[file_name] = _sha256_file(target)
+            if server_acceptance["artifacts"] != server_provenance_hashes:
+                raise ContractError(
+                    "Copied server mapping provenance differs from its validated hashes"
+                )
+        provenance = {
+            "source_dir": str(provenance_root),
+            "review_state": provenance_validation["review_state"],
+            "review_validation_sha256": provenance_validation[
+                "review_validation_sha256"
+            ],
+            "artifacts": provenance_hashes,
+            "server_acceptance": {
+                **server_acceptance,
+                "artifacts": server_provenance_hashes,
+            },
+        }
+    source_hashes = {
+        path.relative_to(package).as_posix(): _sha256_file(path)
+        for path in source_paths
+    }
+    catalog = {
+        "schema_version": CATALOG_SCHEMA,
+        "generated_at": _utc_now(),
+        "report_id": report_id,
+        "package": {
+            "path": str(package),
+            "sha256": package_sha256,
+            "integrity_sha256": _sha256_file(integrity_path),
+            "retailer": summary.get("retailer"),
+            "retailer_label": summary.get("retailer_label"),
+            "category_key": summary.get("category_key"),
+            "category_label": summary.get("category_label"),
+            "discovery_crawl_ts": summary.get("discovery_crawl_ts"),
+            "recent_definition": manifest.get("definitions", {}).get("recent"),
+            "top_seller_definition": manifest.get("definitions", {}).get("top_sellers"),
+        },
+        "warnings": warnings,
+        "source_hashes": source_hashes,
+        "sources": sources,
+        "attribute_tables": tables_result.get("tables", []),
+        "preview_policy": {
+            "rows_per_source": preview_rows,
+            "meaning": "Preview only; Codex may inspect any full whitelisted source before selecting a claim.",
+        },
+    }
+    if transport_lineage is not None:
+        catalog["transport_lineage"] = transport_lineage
+    if no_work_basis is not None:
+        catalog["mapping_review_basis"] = no_work_basis
+    run_intake = {
+        "schema_version": RUN_SCHEMA,
+        "created_at": _utc_now(),
+        "plugin": "attribute-reporting",
+        "workflow": "existing_evidence_package_to_private_html",
+        "report_id": report_id,
+        "inputs": {
+            "package_dir": str(package),
+            "package_sha256": package_sha256,
+            "mapping_provenance": provenance,
+            "mapping_review_basis": no_work_basis,
+            "transport_lineage": transport_lineage,
+        },
+        "output_dir": str(output),
+        "data_posture": {
+            "scrape_execution": "local",
+            "structured_data_persistence": "server_database",
+            "taxonomy_authority": "central_per_category",
+            "product_images": "local_machine",
+            "report_storage": "private_local_only",
+            "report_uploaded_to_server": False,
+            "model_api_calls_from_scripts": False,
+            "codex_agent_judgment": True,
+        },
+        "assumptions": [
+            "The supplied database-derived package is treated as the current data snapshot for this run.",
+            "New means the retailer-defined newest or new-arrivals cohort already encoded by the package.",
+        ],
+        "quality_gates": {
+            "browser_qa_required": require_browser_qa,
+            "mapping_review_required_when_new_mappings_are_present": True,
+            "independent_report_review_required": True,
+        },
+        "execution_trace": [
+            {
+                "step_id": "package_integrity",
+                "kind": "deterministic",
+                "status": "pass",
+                "execution_location": "local",
+                "inputs": [str(package / "package_integrity.json")],
+                "outputs": [],
+            },
+            {
+                "step_id": "attribute_tables",
+                "kind": "deterministic",
+                "status": "pass",
+                "execution_location": "local",
+                "inputs": [str(package)],
+                "outputs": [str(evidence_dir / "attribute_tables")],
+            },
+            *(
+                [
+                    {
+                        "step_id": "transport_lineage",
+                        "kind": "deterministic",
+                        "status": "pass",
+                        "execution_location": "local",
+                        "inputs": [str(path) for path in receipt_sources],
+                        "outputs": [
+                            str(output / file_name)
+                            for file_name in LOCAL_TRANSPORT_RECEIPT_FILES
+                        ],
+                    }
+                ]
+                if receipt_sources is not None
+                else []
+            ),
+            *(
+                [
+                    {
+                        "step_id": "mapping_review_basis",
+                        "kind": "deterministic",
+                        "status": "not_applicable",
+                        "execution_location": "local",
+                        "inputs": [str(no_work_source)],
+                        "outputs": [str(output / NO_WORK_WORKSET_FILE)],
+                    }
+                ]
+                if no_work_basis is not None
+                else []
+            ),
+            *(
+                [
+                    {
+                        "step_id": "mapping_provenance",
+                        "kind": "deterministic",
+                        "status": "pass",
+                        "execution_location": "local",
+                        "inputs": [str(provenance_root)],
+                        "outputs": [
+                            str(output / file_name)
+                            for file_name in (
+                                *MAPPING_PROVENANCE_FILES,
+                                *(
+                                    SERVER_MAPPING_PROVENANCE_FILES
+                                    if present_server_count
+                                    else ()
+                                ),
+                            )
+                        ],
+                    }
+                ]
+                if provenance is not None
+                else []
+            ),
+        ],
+    }
+    report_model = _report_model_template(
+        report_id=report_id,
+        author_agent_id=author_agent_id,
+        summary=summary,
+        warnings=warnings,
+        language=language,
+    )
+    semantic_review = _semantic_review_template(
+        report_id=report_id,
+        author_agent_id=author_agent_id,
+    )
+    catalog["run_intake_sha256"] = _canonical_json_sha256(run_intake)
+    catalog["language"] = language
+    _write_json(output / "run_intake.json", run_intake)
+    _write_json(output / "evidence_catalog.json", catalog)
+    _write_json(output / "report_model.json", report_model)
+    _write_json(output / "semantic_review.json", semantic_review)
+    result = {
+        "output_dir": str(output),
+        "run_intake": str(output / "run_intake.json"),
+        "evidence_catalog": str(output / "evidence_catalog.json"),
+        "report_model": str(output / "report_model.json"),
+        "semantic_review": str(output / "semantic_review.json"),
+    }
+    if provenance is not None:
+        result["mapping_provenance"] = provenance
+    if no_work_basis is not None:
+        result["mapping_review_basis"] = no_work_basis
+    if transport_lineage is not None:
+        result["transport_lineage"] = transport_lineage
+    return result
+
+
+def _json_path_value(payload: Mapping[str, Any], path_parts: Sequence[str]) -> Any:
+    current: Any = payload
+    for part in path_parts:
+        if not isinstance(current, dict) or part not in current:
+            raise ContractError(f"JSON path does not exist: {'.'.join(path_parts)}")
+        current = current[part]
+    return current
+
+
+def _match_csv_row(
+    rows: Sequence[Mapping[str, str]],
+    match: Mapping[str, Any],
+    *,
+    source: str,
+) -> Mapping[str, str]:
+    if not match:
+        raise ContractError(f"CSV evidence selector for {source} requires match keys")
+    matches = [
+        row
+        for row in rows
+        if all(str(row.get(key, "")) == str(value) for key, value in match.items())
+    ]
+    if len(matches) != 1:
+        raise ContractError(
+            f"CSV selector for {source} must match exactly one row; matched={len(matches)} selector={dict(match)}"
+        )
+    return matches[0]
+
+
+def _numeric(value: Any, *, label: str) -> float:
+    if value is None or isinstance(value, bool):
+        raise ContractError(f"{label} is not numeric: {value!r}")
+    try:
+        number = float(str(value).strip())
+    except ValueError as exc:
+        raise ContractError(f"{label} is not numeric: {value!r}") from exc
+    if not math.isfinite(number):
+        raise ContractError(f"{label} must be finite: {value!r}")
+    return number
+
+
+def _format_value(value: Any, format_name: str) -> str:
+    if format_name not in SUPPORTED_FORMATS:
+        raise ContractError(f"Unsupported evidence format: {format_name}")
+    if format_name == "text":
+        return str(value).strip()
+    number = _numeric(value, label="evidence value")
+    if format_name == "integer":
+        return f"{int(round(number)):,}"
+    if format_name == "decimal_1":
+        return f"{number:.1f}"
+    if format_name == "decimal_2":
+        return f"{number:.2f}"
+    if format_name == "percent_1":
+        return f"{number * 100:.1f}%"
+    if format_name == "percentage_point_1":
+        sign = "+" if number > 0 else ""
+        return f"{sign}{number * 100:.1f} pp"
+    if format_name == "ratio_2":
+        return f"{number:.2f}x"
+    if format_name == "currency_0":
+        return f"${number:,.0f}"
+    raise ContractError(f"Unsupported evidence format: {format_name}")
+
+
+def _resolve_evidence_ref(
+    ref: Mapping[str, Any],
+    *,
+    package_dir: Path,
+) -> ResolvedEvidence:
+    ref_id = str(ref.get("ref_id") or "").strip()
+    if not SAFE_ID_RE.fullmatch(ref_id):
+        raise ContractError(f"Invalid evidence ref_id: {ref_id!r}")
+    source = str(ref.get("source") or "").strip()
+    if source not in ALLOWED_EVIDENCE_FILES:
+        raise ContractError(f"Evidence source is not whitelisted: {source!r}")
+    source_path = _contained_package_path(package_dir, source, label="evidence source")
+    selector = ref.get("selector")
+    if not isinstance(selector, dict):
+        raise ContractError(f"Evidence ref {ref_id} requires a selector object")
+    format_name = str(ref.get("format") or "text")
+    source_row_sha256: str | None = None
+    if source_path.suffix.lower() == ".csv":
+        columns, rows = _read_csv(source_path)
+        match = selector.get("match")
+        field = str(selector.get("field") or "")
+        if not isinstance(match, dict):
+            raise ContractError(f"CSV evidence ref {ref_id} requires selector.match")
+        if field not in columns:
+            raise ContractError(f"CSV evidence field {field!r} is absent from {source}")
+        row = _match_csv_row(rows, match, source=source)
+        raw_value = row.get(field)
+        source_row_sha256 = _source_row_sha256(row)
+    else:
+        raw_path = selector.get("json_path")
+        if (
+            not isinstance(raw_path, list)
+            or not raw_path
+            or not all(isinstance(item, str) and item for item in raw_path)
+        ):
+            raise ContractError(
+                f"JSON evidence ref {ref_id} requires selector.json_path"
+            )
+        raw_value = _json_path_value(_load_json(source_path), raw_path)
+    formatted = _format_value(raw_value, format_name)
+    return ResolvedEvidence(
+        ref_id=ref_id,
+        source=source,
+        raw_value=raw_value,
+        formatted_value=formatted,
+        source_sha256=_sha256_file(source_path),
+        selector=dict(selector),
+        source_row_sha256=source_row_sha256,
+    )
+
+
+def _contains_unbound_number(text: str) -> bool:
+    without_tokens = TOKEN_RE.sub("", text)
+    return bool(NUMERIC_LITERAL_RE.search(without_tokens))
+
+
+def _validate_authored_text(text: Any, *, label: str, allow_empty: bool = True) -> str:
+    if not isinstance(text, str):
+        raise ContractError(f"{label} must be text")
+    stripped = text.strip()
+    if not stripped and not allow_empty:
+        raise ContractError(f"{label} cannot be empty")
+    if _contains_unbound_number(stripped):
+        raise ContractError(
+            f"{label} contains an unbound numeric literal; bind displayed numbers to evidence tokens"
+        )
+    return stripped
+
+
+def _validate_report_model(
+    model: Mapping[str, Any],
+    *,
+    catalog: Mapping[str, Any],
+) -> tuple[dict[str, Mapping[str, Any]], list[Mapping[str, Any]]]:
+    if model.get("schema_version") != MODEL_SCHEMA:
+        raise ContractError(
+            f"Unsupported report model schema: {model.get('schema_version')!r}"
+        )
+    if model.get("report_id") != catalog.get("report_id"):
+        raise ContractError("report_model report_id does not match evidence_catalog")
+    language = _report_language(model.get("language", "en"))
+    if language != catalog.get("language", "en"):
+        raise ContractError(
+            "Report language differs from prepared evidence; prepare a new run in the requested language"
+        )
+    if model.get("authoring_status") != "codex_complete":
+        raise ContractError(
+            "report_model authoring_status must be codex_complete before rendering"
+        )
+    author = model.get("author")
+    if not isinstance(author, dict) or author.get("execution") != "codex_agent":
+        raise ContractError("report_model author must be a Codex agent")
+    if not str(author.get("agent_id") or "").strip():
+        raise ContractError("report_model author.agent_id is required")
+    _validate_authored_text(model.get("title"), label="report title", allow_empty=False)
+    _validate_authored_text(model.get("subtitle", ""), label="report subtitle")
+
+    claims = model.get("claims")
+    if not isinstance(claims, list) or not claims:
+        raise ContractError("report_model requires at least one claim")
+    claim_by_id: dict[str, Mapping[str, Any]] = {}
+    for claim in claims:
+        if not isinstance(claim, dict):
+            raise ContractError("Each report claim must be an object")
+        claim_id = str(claim.get("claim_id") or "")
+        if not SAFE_ID_RE.fullmatch(claim_id) or claim_id in claim_by_id:
+            raise ContractError(f"Invalid or duplicate claim_id: {claim_id!r}")
+        kind = str(claim.get("kind") or "")
+        if kind not in {"deterministic", "semantic"}:
+            raise ContractError(f"Claim {claim_id} has unsupported kind: {kind!r}")
+        _validate_authored_text(
+            claim.get("headline"), label=f"claim {claim_id} headline", allow_empty=False
+        )
+        _validate_authored_text(
+            claim.get("text_template"),
+            label=f"claim {claim_id} text_template",
+            allow_empty=False,
+        )
+        _validate_authored_text(
+            claim.get("interpretation", ""), label=f"claim {claim_id} interpretation"
+        )
+        _validate_authored_text(
+            claim.get("caveat", ""), label=f"claim {claim_id} caveat"
+        )
+        if claim.get("confidence") not in {"high", "medium", "low"}:
+            raise ContractError(
+                f"Claim {claim_id} requires high, medium, or low confidence"
+            )
+        evidence_refs = claim.get("evidence_refs") or []
+        supporting = claim.get("supporting_claim_ids") or []
+        if not isinstance(evidence_refs, list) or not isinstance(supporting, list):
+            raise ContractError(
+                f"Claim {claim_id} evidence/support fields must be lists"
+            )
+        if kind == "deterministic" and not evidence_refs:
+            raise ContractError(
+                f"Deterministic claim {claim_id} requires evidence_refs"
+            )
+        if kind == "semantic" and not supporting:
+            raise ContractError(
+                f"Semantic claim {claim_id} requires supporting_claim_ids"
+            )
+        if kind == "semantic" and evidence_refs:
+            raise ContractError(
+                f"Semantic claim {claim_id} cannot introduce fresh evidence refs"
+            )
+        claim_by_id[claim_id] = claim
+
+    for claim_id, claim in claim_by_id.items():
+        for supporting_id in claim.get("supporting_claim_ids") or []:
+            if supporting_id not in claim_by_id or supporting_id == claim_id:
+                raise ContractError(
+                    f"Claim {claim_id} has invalid supporting claim {supporting_id!r}"
+                )
+            if claim_by_id[supporting_id].get("kind") != "deterministic":
+                raise ContractError(
+                    f"Semantic claim {claim_id} must be supported by deterministic claims"
+                )
+
+    sections = model.get("sections")
+    if not isinstance(sections, list):
+        raise ContractError("report_model sections must be a list")
+    section_ids = [
+        str(item.get("section_id") or "") for item in sections if isinstance(item, dict)
+    ]
+    if tuple(section_ids) != REQUIRED_SECTION_IDS:
+        raise ContractError(
+            "report_model sections must appear exactly once in the required order: "
+            + ", ".join(REQUIRED_SECTION_IDS)
+        )
+    used_claim_ids: list[str] = []
+    for section in sections:
+        section_id = str(section["section_id"])
+        _validate_authored_text(
+            section.get("title"),
+            label=f"section {section_id} title",
+            allow_empty=False,
+        )
+        section_summary = _validate_authored_text(
+            section.get("summary", ""),
+            label=f"section {section_id} summary",
+        )
+        raw_claim_ids = section.get("claim_ids") or []
+        raw_table_keys = section.get("table_keys") or []
+        if not isinstance(raw_claim_ids, list) or not isinstance(raw_table_keys, list):
+            raise ContractError(
+                f"Section {section_id} claim_ids/table_keys must be lists"
+            )
+        for claim_id in raw_claim_ids:
+            if claim_id not in claim_by_id:
+                raise ContractError(
+                    f"Section {section_id} references unknown claim {claim_id!r}"
+                )
+            used_claim_ids.append(claim_id)
+        invalid_tables = sorted(set(raw_table_keys) - ALLOWED_TABLE_KEYS)
+        if invalid_tables:
+            raise ContractError(
+                f"Section {section_id} references unsupported tables: {invalid_tables}"
+            )
+        if not section_summary and not raw_claim_ids and not raw_table_keys:
+            raise ContractError(f"Section {section_id} cannot be empty")
+    if sorted(used_claim_ids) != sorted(claim_by_id) or len(used_claim_ids) != len(
+        set(used_claim_ids)
+    ):
+        raise ContractError(
+            "Every report claim must be referenced by exactly one section"
+        )
+
+    expected_warnings = {
+        str(item.get("code"))
+        for item in catalog.get("warnings") or []
+        if isinstance(item, dict)
+    }
+    acknowledged = set(model.get("acknowledged_warning_codes") or [])
+    if acknowledged != expected_warnings:
+        raise ContractError(
+            "report_model must acknowledge every active package warning and no others"
+        )
+    limitations = model.get("limitations")
+    if not isinstance(limitations, list):
+        raise ContractError("report_model limitations must be a list")
+    limitation_codes = {
+        str(item.get("code")) for item in limitations if isinstance(item, dict)
+    }
+    if not expected_warnings <= limitation_codes:
+        raise ContractError(
+            "Every active package warning must be visible in limitations"
+        )
+    for item in limitations:
+        if not isinstance(item, dict):
+            raise ContractError("Each limitation must be an object")
+        _validate_authored_text(
+            item.get("text"),
+            label=f"limitation {item.get('code')} text",
+            allow_empty=False,
+        )
+
+    products = model.get("featured_products")
+    if not isinstance(products, list) or len(products) > 8:
+        raise ContractError("featured_products must be a list with at most eight items")
+    for item in products:
+        if not isinstance(item, dict):
+            raise ContractError("Each featured product must be an object")
+        if not str(item.get("product_id") or "").strip():
+            raise ContractError("Featured product requires product_id")
+        if item.get("role") not in {"winning_now", "emerging_signal"}:
+            raise ContractError(
+                "Featured product role must be winning_now or emerging_signal"
+            )
+        _validate_authored_text(
+            item.get("rationale"), label="featured product rationale", allow_empty=False
+        )
+        supporting = item.get("supporting_claim_ids") or []
+        if not supporting or any(
+            claim_id not in claim_by_id for claim_id in supporting
+        ):
+            raise ContractError("Featured product requires valid supporting_claim_ids")
+    return claim_by_id, sections
+
+
+def _selected_csv_row(
+    ref: Mapping[str, Any],
+    *,
+    package_dir: Path,
+) -> Mapping[str, str] | None:
+    source = str(ref.get("source") or "")
+    if not source.endswith(".csv"):
+        return None
+    selector = ref.get("selector")
+    if not isinstance(selector, dict) or not isinstance(selector.get("match"), dict):
+        return None
+    source_path = _contained_package_path(
+        package_dir, source, label="claim checker source"
+    )
+    _columns, rows = _read_csv(source_path)
+    return _match_csv_row(rows, selector["match"], source=source)
+
+
+def _claim_checker(
+    claim: Mapping[str, Any],
+    *,
+    package_dir: Path,
+) -> list[dict[str, Any]]:
+    claim_id = str(claim["claim_id"])
+    checker = str(claim.get("checker") or "")
+    allowed = {
+        "cohort_summary",
+        "bundle_signal_winning_now",
+        "bundle_signal_emerging",
+        "bundle_bridge",
+        "brand_fact",
+        "review_availability",
+        "source_fact",
+    }
+    if checker not in allowed:
+        raise ContractError(
+            f"Deterministic claim {claim_id} has unsupported checker {checker!r}"
+        )
+    refs = claim.get("evidence_refs") or []
+    rows = [
+        (
+            str(ref.get("source") or ""),
+            _selected_csv_row(ref, package_dir=package_dir),
+            ref,
+        )
+        for ref in refs
+        if isinstance(ref, dict)
+    ]
+    checks: list[dict[str, Any]] = [
+        {"check_id": "checker_registered", "status": "pass", "checker": checker}
+    ]
+
+    def require_bundle_row(
+        sources: set[str],
+        *,
+        focus_count: str,
+        focus_brands: str,
+        focus_share: str,
+        baseline_share: str,
+    ) -> tuple[str, Mapping[str, str]]:
+        selected = [
+            (source, row, ref)
+            for source, row, ref in rows
+            if source in sources and row is not None
+        ]
+        if not selected:
+            raise ContractError(
+                f"Claim {claim_id} checker {checker} requires evidence from {sorted(sources)}"
+            )
+        row_identities = {
+            (source, _source_row_sha256(row)) for source, row, _ref in selected
+        }
+        if len(row_identities) != 1:
+            raise ContractError(
+                f"Claim {claim_id} must bind every layer-specific value to one exact bundle row"
+            )
+        source, row, _ref = selected[0]
+        referenced_fields = {
+            str(ref.get("selector", {}).get("field") or "")
+            for _source, _row, ref in selected
+            if isinstance(ref.get("selector"), dict)
+        }
+        missing_share_fields = {focus_share, baseline_share} - referenced_fields
+        if missing_share_fields:
+            raise ContractError(
+                f"Claim {claim_id} must display both focus and baseline shares; missing={sorted(missing_share_fields)}"
+            )
+        bundle_key = str(row.get("bundle_key") or "").strip()
+        if not bundle_key:
+            raise ContractError(f"Claim {claim_id} requires a non-empty bundle_key")
+        count = _numeric(row.get(focus_count), label=f"{claim_id}.{focus_count}")
+        brands = _numeric(row.get(focus_brands), label=f"{claim_id}.{focus_brands}")
+        focus = _numeric(row.get(focus_share), label=f"{claim_id}.{focus_share}")
+        baseline = _numeric(
+            row.get(baseline_share), label=f"{claim_id}.{baseline_share}"
+        )
+        if count < 3 or brands < 2 or focus <= baseline:
+            raise ContractError(
+                f"Claim {claim_id} does not satisfy the preserved bundle signal thresholds"
+            )
+        checks.extend(
+            [
+                {
+                    "check_id": "one_exact_bundle_row",
+                    "status": "pass",
+                    "source": source,
+                    "source_row_sha256": _source_row_sha256(row),
+                    "bundle_key": bundle_key,
+                },
+                {
+                    "check_id": "focus_product_count_at_least_three",
+                    "status": "pass",
+                    "actual": count,
+                },
+                {
+                    "check_id": "focus_brand_count_at_least_two",
+                    "status": "pass",
+                    "actual": brands,
+                },
+                {
+                    "check_id": "focus_share_above_baseline",
+                    "status": "pass",
+                    "actual": focus,
+                    "baseline": baseline,
+                },
+            ]
+        )
+        return source, row
+
+    if checker == "bundle_signal_winning_now":
+        allowed_sources = {"top_seller_pairs.csv", "top_seller_triples.csv"}
+        invalid_sources = sorted(
+            {source for source, _row, _ref in rows} - allowed_sources
+        )
+        if invalid_sources:
+            raise ContractError(
+                f"Claim {claim_id} has evidence outside its winning layer: {invalid_sources}"
+            )
+        require_bundle_row(
+            allowed_sources,
+            focus_count="count_top_seller",
+            focus_brands="top_seller_brand_count",
+            focus_share="pct_top_seller",
+            baseline_share="pct_other",
+        )
+    elif checker == "bundle_signal_emerging":
+        allowed_sources = {"innovation_pairs.csv", "innovation_triples.csv"}
+        invalid_sources = sorted(
+            {source for source, _row, _ref in rows} - allowed_sources
+        )
+        if invalid_sources:
+            raise ContractError(
+                f"Claim {claim_id} has evidence outside its emerging layer: {invalid_sources}"
+            )
+        require_bundle_row(
+            allowed_sources,
+            focus_count="count_recent",
+            focus_brands="recent_brand_count",
+            focus_share="pct_recent",
+            baseline_share="pct_rest",
+        )
+    elif checker == "bundle_bridge":
+        winner_sources = {"top_seller_pairs.csv", "top_seller_triples.csv"}
+        emerging_sources = {"innovation_pairs.csv", "innovation_triples.csv"}
+        invalid_sources = sorted(
+            {source for source, _row, _ref in rows} - winner_sources - emerging_sources
+        )
+        if invalid_sources:
+            raise ContractError(
+                f"Bridge claim {claim_id} has evidence outside its two layers: {invalid_sources}"
+            )
+        winner_source, winner = require_bundle_row(
+            winner_sources,
+            focus_count="count_top_seller",
+            focus_brands="top_seller_brand_count",
+            focus_share="pct_top_seller",
+            baseline_share="pct_other",
+        )
+        emerging_source, emerging = require_bundle_row(
+            emerging_sources,
+            focus_count="count_recent",
+            focus_brands="recent_brand_count",
+            focus_share="pct_recent",
+            baseline_share="pct_rest",
+        )
+        winner_key = str(winner.get("bundle_key") or "").strip()
+        emerging_key = str(emerging.get("bundle_key") or "").strip()
+        if winner_key != emerging_key:
+            raise ContractError(f"Bridge claim {claim_id} must use the same bundle_key")
+        if winner_source.removeprefix("top_seller_") != emerging_source.removeprefix(
+            "innovation_"
+        ):
+            raise ContractError(
+                f"Bridge claim {claim_id} must compare matching pair or triple layers"
+            )
+        checks.append(
+            {
+                "check_id": "same_bundle_key_across_layers",
+                "status": "pass",
+                "bundle_key": winner_key,
+            }
+        )
+    elif checker == "brand_fact":
+        if not any(
+            source == "top_seller_brand_comparison.csv" for source, _row, _ref in rows
+        ):
+            raise ContractError(
+                f"Brand claim {claim_id} requires brand comparison evidence"
+            )
+    elif checker == "cohort_summary":
+        if not any(str(ref.get("source")) == "summary.json" for ref in refs):
+            raise ContractError(
+                f"Cohort claim {claim_id} requires summary.json evidence"
+            )
+    elif checker == "review_availability":
+        review_files = (
+            "top_seller_review_validation.csv",
+            "bundle_review_validation.csv",
+        )
+        row_counts = []
+        for file_name in review_files:
+            raw_path = package_dir / file_name
+            if raw_path.exists():
+                path = _contained_package_path(
+                    package_dir, file_name, label="review evidence source"
+                )
+                _columns, review_rows = _read_csv(path)
+                row_counts.append(len(review_rows))
+            else:
+                row_counts.append(0)
+        checks.append(
+            {
+                "check_id": "review_evidence_row_counts",
+                "status": "pass",
+                "top_seller_rows": row_counts[0],
+                "emerging_rows": row_counts[1],
+            }
+        )
+    return checks
+
+
+def _resolve_claims(
+    claim_by_id: Mapping[str, Mapping[str, Any]],
+    *,
+    package_dir: Path,
+) -> tuple[dict[str, str], list[dict[str, Any]]]:
+    resolved_text: dict[str, str] = {}
+    ledger: list[dict[str, Any]] = []
+    for claim_id, claim in claim_by_id.items():
+        template = str(claim["text_template"])
+        kind = str(claim["kind"])
+        raw_refs = claim.get("evidence_refs") or []
+        resolved_refs: list[ResolvedEvidence] = []
+        ref_ids: set[str] = set()
+        for raw_ref in raw_refs:
+            if not isinstance(raw_ref, dict):
+                raise ContractError(f"Claim {claim_id} evidence refs must be objects")
+            resolved = _resolve_evidence_ref(raw_ref, package_dir=package_dir)
+            if resolved.ref_id in ref_ids:
+                raise ContractError(
+                    f"Claim {claim_id} has duplicate evidence ref {resolved.ref_id}"
+                )
+            ref_ids.add(resolved.ref_id)
+            resolved_refs.append(resolved)
+        token_ids = set(TOKEN_RE.findall(template))
+        if token_ids != ref_ids:
+            raise ContractError(
+                f"Claim {claim_id} tokens must exactly match evidence ref_ids; tokens={sorted(token_ids)} refs={sorted(ref_ids)}"
+            )
+        text = template
+        for item in resolved_refs:
+            text = text.replace("{{" + item.ref_id + "}}", item.formatted_value)
+        if TOKEN_RE.search(text):
+            raise ContractError(f"Claim {claim_id} has unresolved evidence tokens")
+        checks = (
+            _claim_checker(claim, package_dir=package_dir)
+            if kind == "deterministic"
+            else [
+                {
+                    "check_id": "semantic_claim_has_deterministic_support",
+                    "status": "pass",
+                    "supporting_claim_ids": list(
+                        claim.get("supporting_claim_ids") or []
+                    ),
+                }
+            ]
+        )
+        resolved_text[claim_id] = text
+        ledger.append(
+            {
+                "claim_id": claim_id,
+                "kind": kind,
+                "checker": claim.get("checker"),
+                "resolved_text": text,
+                "supporting_claim_ids": list(claim.get("supporting_claim_ids") or []),
+                "evidence": [
+                    {
+                        "ref_id": item.ref_id,
+                        "source": item.source,
+                        "selector": item.selector,
+                        "raw_value": item.raw_value,
+                        "formatted_value": item.formatted_value,
+                        "source_sha256": item.source_sha256,
+                        "source_row_sha256": item.source_row_sha256,
+                    }
+                    for item in resolved_refs
+                ],
+                "checks": checks,
+                "status": "pass",
+            }
+        )
+    return resolved_text, ledger
+
+
+def _table_manifest_by_key(catalog: Mapping[str, Any]) -> dict[str, Mapping[str, Any]]:
+    output: dict[str, Mapping[str, Any]] = {}
+    for item in catalog.get("attribute_tables") or []:
+        if not isinstance(item, dict):
+            continue
+        table_key = str(item.get("table_key") or "")
+        if table_key:
+            output[table_key] = item
+    missing = sorted(ALLOWED_TABLE_KEYS - set(output))
+    if missing:
+        raise ContractError(
+            f"Evidence catalog is missing deterministic tables: {missing}"
+        )
+    return output
+
+
+def _render_table(
+    table: Mapping[str, Any],
+    *,
+    output_dir: Path,
+    language: str = "en",
+) -> tuple[str, dict[str, Any]]:
+    relative = _safe_relative_path(str(table["csv"]), label="table CSV")
+    path = output_dir / "evidence" / relative
+    expected_sha = str(table.get("csv_sha256") or "")
+    actual_sha = _sha256_file(path)
+    if expected_sha != actual_sha:
+        raise ContractError(
+            f"Deterministic table changed after preparation: {table['table_key']}"
+        )
+    columns, rows = _read_csv(path)
+    if int(table.get("row_count") or 0) != len(rows):
+        raise ContractError(
+            f"Deterministic table row count changed: {table['table_key']}"
+        )
+    title, labels, display_rows = _load_attribute_table_runtime().table_display_labels(
+        str(table["table_key"]), columns, rows, language
+    )
+    header = "".join(f'<th scope="col">{html.escape(label)}</th>' for label in labels)
+    body_rows = []
+    for row in display_rows:
+        cells = "".join(f"<td>{html.escape(value)}</td>" for value in row)
+        body_rows.append(f"<tr>{cells}</tr>")
+    row_count_label = _display(
+        "1 evidence row" if len(rows) == 1 else "{count} evidence rows", language
+    ).format(count=len(rows))
+    scroll_hint = {
+        "it": "Se la tabella supera lo schermo, scorri orizzontalmente per leggere tutte le colonne.",
+        "en": "If the table exceeds the screen, scroll horizontally to read all columns.",
+        "fr": "Si le tableau dépasse l’écran, faites défiler horizontalement pour lire toutes les colonnes.",
+        "de": "Wenn die Tabelle breiter als der Bildschirm ist, horizontal scrollen, um alle Spalten zu lesen.",
+        "es": "Si la tabla supera la pantalla, desplázate horizontalmente para leer todas las columnas.",
+    }[language]
+    table_html = (
+        f"<figure class=\"evidence-table\" data-table-key=\"{html.escape(str(table['table_key']))}\" "
+        f'data-table-sha256="{actual_sha}">'
+        f"<figcaption><span>{html.escape(title)}</span>"
+        f"<small>{html.escape(row_count_label)}</small></figcaption>"
+        f'<p class="source-note">{html.escape(scroll_hint)}</p>'
+        f'<div class="table-scroll" tabindex="0" role="region" aria-label="{html.escape(title)}"><table><thead><tr>'
+        + header
+        + "</tr></thead><tbody>"
+        + "".join(body_rows)
+        + "</tbody></table></div>"
+        f"<p class=\"source-note\">{html.escape(_display('Source:', language))} {html.escape(', '.join(table.get('source_files') or []))}</p>"
+        "</figure>"
+    )
+    record = {
+        "table_key": table["table_key"],
+        "csv": str(relative),
+        "sha256": actual_sha,
+        "row_count": len(rows),
+        "columns": columns,
+    }
+    return table_html, record
+
+
+def _safe_http_url(value: Any) -> str:
+    text = str(value or "").strip()
+    parts = urlsplit(text)
+    return text if parts.scheme in {"http", "https"} and parts.netloc else ""
+
+
+def _product_index(package_dir: Path) -> dict[str, dict[str, str]]:
+    products: dict[str, dict[str, str]] = {}
+    for file_name in ("recent_products.csv", "top_seller_products.csv"):
+        raw_path = package_dir / file_name
+        if not raw_path.exists():
+            continue
+        path = _contained_package_path(
+            package_dir, file_name, label="product evidence source"
+        )
+        _columns, rows = _read_csv(path)
+        for row in rows:
+            product_id = str(row.get("parent_product_id") or "").strip()
+            if product_id and product_id not in products:
+                products[product_id] = dict(row)
+    return products
+
+
+def _local_product_image(package_dir: Path, row: Mapping[str, str]) -> Path | None:
+    package_root = package_dir.resolve()
+    image_root = (package_root / "images").resolve()
+    if not image_root.is_relative_to(package_root):
+        raise ContractError("Evidence-package image directory escapes the package")
+    relative_value = str(row.get("pack_image_file") or "").strip()
+    if relative_value:
+        relative = _safe_relative_path(relative_value, label="pack image")
+        candidate = (package_dir / relative).resolve()
+        if candidate.is_file():
+            if not candidate.is_relative_to(image_root):
+                raise ContractError(
+                    f"Pack image escapes the package image directory: {candidate}"
+                )
+            if not _is_supported_local_image(candidate):
+                raise ContractError(
+                    f"Pack image is not a supported raster image: {candidate}"
+                )
+            return candidate
+    for field in ("pack_image_path",):
+        value = str(row.get(field) or "").strip()
+        if value:
+            candidate = Path(value).expanduser()
+            if candidate.is_file():
+                resolved = candidate.resolve()
+                if not resolved.is_relative_to(image_root):
+                    raise ContractError(
+                        f"Pack image escapes the package image directory: {resolved}"
+                    )
+                if not _is_supported_local_image(resolved):
+                    raise ContractError(
+                        f"Local product image is not a supported raster image: {resolved}"
+                    )
+                return resolved
+    sidecar = _local_sidecar_image(package_dir, row)
+    return sidecar[0] if sidecar is not None else None
+
+
+def _copy_featured_products(
+    featured: Sequence[Mapping[str, Any]],
+    *,
+    package_dir: Path,
+    output_dir: Path,
+    language: str = "en",
+) -> tuple[str, list[dict[str, Any]]]:
+    products = _product_index(package_dir)
+    assets_dir = output_dir / "assets" / "products"
+    cards: list[str] = []
+    records: list[dict[str, Any]] = []
+    for item in featured:
+        product_id = str(item["product_id"])
+        if product_id not in products:
+            raise ContractError(
+                f"Featured product is absent from cohort files: {product_id}"
+            )
+        row = products[product_id]
+        image_source = _local_product_image(package_dir, row)
+        image_relative = ""
+        image_sha = ""
+        if image_source is not None:
+            assets_dir.mkdir(parents=True, exist_ok=True)
+            suffix = image_source.suffix.lower() or ".img"
+            safe_id = re.sub(r"[^A-Za-z0-9_-]+", "-", product_id).strip("-")
+            target = assets_dir / f"{safe_id}{suffix}"
+            shutil.copy2(image_source, target)
+            image_relative = target.relative_to(output_dir).as_posix()
+            image_sha = _sha256_file(target)
+            image_markup = (
+                f'<img src="{html.escape(image_relative)}" '
+                f"alt=\"{html.escape(str(row.get('product_name') or product_id))}\">"
+            )
+        else:
+            image_markup = f'<div class="image-placeholder" aria-label="{html.escape(_display("Image unavailable", language))}">{html.escape(_display("No local image", language))}</div>'
+        product_url = _safe_http_url(row.get("pdp_url"))
+        name = str(row.get("product_name") or product_id)
+        linked_name = (
+            f'<a href="{html.escape(product_url)}" target="_blank" rel="noreferrer">{html.escape(name)}</a>'
+            if product_url
+            else html.escape(name)
+        )
+        cards.append(
+            f'<article class="product-card" data-product-id="{html.escape(product_id)}">'
+            f'<div class="product-image">{image_markup}</div>'
+            f"<div class=\"product-copy\"><p class=\"product-role\">{html.escape(_display('Winning now' if item['role'] == 'winning_now' else 'Emerging signal', language))}</p>"
+            f"<h3>{linked_name}</h3><p class=\"brand\">{html.escape(str(row.get('brand') or ''))}</p>"
+            f"<p>{html.escape(str(item['rationale']))}</p></div></article>"
+        )
+        records.append(
+            {
+                "product_id": product_id,
+                "source_row_sha256": _source_row_sha256(row),
+                "image_source": str(image_source) if image_source else None,
+                "image_path": image_relative or None,
+                "image_sha256": image_sha or None,
+                "pdp_url": product_url or None,
+            }
+        )
+    if not cards:
+        return "", records
+    return f'<div class="product-grid">{"".join(cards)}</div>', records
+
+
+def _claim_html(
+    claim: Mapping[str, Any], resolved_text: str, language: str = "en"
+) -> str:
+    claim_id = str(claim["claim_id"])
+    interpretation = str(claim.get("interpretation") or "").strip()
+    caveat = str(claim.get("caveat") or "").strip()
+    supporting = " ".join(str(item) for item in claim.get("supporting_claim_ids") or [])
+    extras = ""
+    if interpretation:
+        extras += f'<p class="interpretation">{html.escape(interpretation)}</p>'
+    if caveat:
+        extras += f'<p class="claim-caveat">{html.escape(caveat)}</p>'
+    return (
+        f'<article class="claim" data-claim-id="{html.escape(claim_id)}" '
+        f"data-claim-kind=\"{html.escape(str(claim['kind']))}\" "
+        f'data-supporting-claims="{html.escape(supporting)}">'
+        f"<div class=\"claim-meta\"><span>{html.escape(_display(str(claim['kind']), language))}</span>"
+        f"<span>{html.escape(_display(str(claim['confidence']) + ' confidence', language))}</span></div>"
+        f"<h3>{html.escape(str(claim['headline']))}</h3>"
+        f'<p class="claim-statement">{html.escape(resolved_text)}</p>{extras}</article>'
+    )
+
+
+def _report_css() -> str:
+    return """
+:root{--ink:#172019;--muted:#667069;--paper:#f7f4ec;--card:#fffefa;--line:#d9d5c9;--green:#516254;--sage:#a8b7a6;--amber:#c88d42;--red:#a44738;--shadow:0 18px 48px rgba(28,35,29,.09)}
+*{box-sizing:border-box}html{scroll-behavior:smooth}body{margin:0;background:var(--paper);color:var(--ink);font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;line-height:1.55}
+a{color:inherit}.report-shell{max-width:1240px;margin:0 auto;padding:28px}.hero{position:relative;overflow:hidden;border-radius:30px;background:var(--ink);color:white;padding:64px;box-shadow:var(--shadow)}.hero:after{content:"";position:absolute;width:380px;height:380px;border-radius:50%;right:-120px;top:-150px;background:radial-gradient(circle,var(--sage),transparent 66%);opacity:.45}.eyebrow,.product-role{font-size:.72rem;text-transform:uppercase;letter-spacing:.16em;font-weight:750}.hero h1{max-width:780px;margin:.4rem 0 .3rem;font-family:Georgia,serif;font-size:clamp(2.5rem,6vw,5.7rem);line-height:.96;font-weight:500}.hero .subtitle{max-width:680px;color:#d9dfda;font-size:1.12rem}.hero-meta{display:flex;gap:12px;flex-wrap:wrap;margin-top:30px}.hero-meta span{border:1px solid rgba(255,255,255,.24);border-radius:99px;padding:8px 13px;font-size:.82rem}.verdict-slot{margin:20px 0}.verdict{display:grid;grid-template-columns:auto minmax(0,1fr);gap:18px;align-items:center;min-width:0;border:1px solid var(--line);border-radius:18px;background:var(--card);padding:18px 22px}.verdict>div,.verdict span,.verdict-details{min-width:0;overflow-wrap:anywhere}.verdict strong{display:block;font-size:1.15rem}.verdict .mark{width:48px;height:48px;border-radius:50%;display:grid;place-items:center;background:var(--green);color:white;font-weight:800}.verdict-details{margin:.55rem 0 0;padding-left:1.1rem;color:var(--muted);font-size:.84rem}.verdict.correct_with_caveats .mark{background:var(--amber)}.verdict.incorrect .mark{background:var(--red)}.verdict.unable_to_determine .mark{background:#737a75}
+.report-nav{position:sticky;top:10px;z-index:4;display:flex;gap:8px;overflow:auto;margin:20px 0;padding:10px;border:1px solid var(--line);border-radius:16px;background:rgba(247,244,236,.92);backdrop-filter:blur(12px)}.report-nav a{white-space:nowrap;text-decoration:none;padding:7px 11px;border-radius:10px;font-size:.78rem}.report-nav a:hover{background:#e5e8df}
+.report-section{display:grid;grid-template-columns:minmax(210px,300px) 1fr;gap:34px;padding:54px 0;border-top:1px solid var(--line)}.section-heading{position:sticky;top:90px;align-self:start}.section-number{color:var(--amber);font-family:Georgia,serif;font-size:1.5rem}.section-heading h2{font-family:Georgia,serif;font-weight:500;font-size:clamp(1.8rem,3vw,3rem);line-height:1.05;margin:.25rem 0}.section-summary{color:var(--muted)}.section-body{min-width:0}.claim-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:16px}.claim{background:var(--card);border:1px solid var(--line);border-radius:18px;padding:24px;box-shadow:0 8px 25px rgba(28,35,29,.04)}.claim-meta{display:flex;justify-content:space-between;gap:10px;color:var(--muted);font-size:.7rem;text-transform:uppercase;letter-spacing:.08em}.claim h3{font-family:Georgia,serif;font-size:1.45rem;font-weight:500;margin:1rem 0 .6rem}.claim-statement{font-size:1.06rem}.interpretation{border-left:3px solid var(--sage);padding-left:13px}.claim-caveat{color:#755027;background:#faf0dd;border-radius:10px;padding:10px 12px;font-size:.9rem}
+.evidence-table{margin:20px 0 0;background:var(--card);border:1px solid var(--line);border-radius:18px;overflow:hidden}.evidence-table figcaption{display:flex;justify-content:space-between;gap:20px;padding:18px 20px;border-bottom:1px solid var(--line);font-family:Georgia,serif;font-size:1.25rem}.evidence-table figcaption small{font-family:inherit;color:var(--muted);font-size:.76rem}.table-scroll{overflow:auto}table{border-collapse:collapse;width:100%;font-size:.78rem}th,td{padding:11px 13px;text-align:left;border-bottom:1px solid #ece8de;vertical-align:top}th{position:sticky;top:0;background:#eeece4;text-transform:uppercase;letter-spacing:.05em;font-size:.66rem}tbody tr:hover{background:#f5f4ef}.source-note{padding:0 18px 12px;color:var(--muted);font-size:.72rem}
+.product-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:16px;margin-top:20px}.product-card{display:grid;grid-template-columns:42% 1fr;overflow:hidden;background:var(--card);border:1px solid var(--line);border-radius:18px}.product-image{min-height:230px;background:#e9e7df}.product-image img{width:100%;height:100%;object-fit:cover;display:block}.image-placeholder{height:100%;min-height:230px;display:grid;place-items:center;color:var(--muted)}.product-copy{padding:20px}.product-copy h3{font-family:Georgia,serif;font-weight:500;margin:.3rem 0}.brand{color:var(--muted)}.product-role{color:var(--amber)}
+.limitations{display:grid;gap:10px}.limitation{border-left:4px solid var(--amber);background:#f5ead6;padding:15px 18px;border-radius:0 12px 12px 0}.limitation code{font-size:.72rem}.footer{display:flex;justify-content:space-between;gap:20px;padding:32px 0 12px;color:var(--muted);font-size:.75rem}.print-button{border:1px solid var(--line);background:var(--card);border-radius:99px;padding:8px 14px;cursor:pointer}
+.evidence-table th,.evidence-table td{min-width:84px}.evidence-table[data-table-key="product_signal_evidence_table"] td:nth-child(4){min-width:130px}.evidence-table[data-table-key="product_signal_evidence_table"] td:nth-child(9){min-width:240px}
+@media(max-width:850px){.report-shell{padding:14px}.hero{padding:38px 25px;border-radius:20px}.report-section{grid-template-columns:1fr;gap:18px;padding:38px 0}.section-heading{position:static}.claim-grid,.product-grid{grid-template-columns:1fr}.product-card{grid-template-columns:38% 1fr}.footer{flex-direction:column}}
+@media(max-width:520px){.claim-grid{display:block}.claim{margin-bottom:12px}.product-card{grid-template-columns:1fr}.product-image{max-height:360px}.evidence-table figcaption{display:block}.evidence-table figcaption small{display:block;margin-top:5px}.hero h1{font-size:2.6rem}}
+@media print{body{background:white}.report-shell{max-width:none;padding:0}.hero{box-shadow:none;border-radius:0}.report-nav,.print-button{display:none}.report-section{break-inside:avoid}.claim,.evidence-table,.product-card{break-inside:avoid;box-shadow:none}}
+"""
+
+
+def _render_draft_html(
+    model: Mapping[str, Any],
+    sections: Sequence[Mapping[str, Any]],
+    claim_by_id: Mapping[str, Mapping[str, Any]],
+    resolved_text: Mapping[str, str],
+    *,
+    catalog: Mapping[str, Any],
+    table_html_by_key: Mapping[str, str],
+    product_html: str,
+) -> str:
+    package = catalog["package"]
+    language = _report_language(model.get("language", "en"))
+    nav = "".join(
+        f"<a href=\"#{html.escape(str(section['section_id']))}\">{html.escape(str(section['title']))}</a>"
+        for section in sections
+    )
+    section_markup: list[str] = []
+    for index, section in enumerate(sections, start=1):
+        section_id = str(section["section_id"])
+        claims = "".join(
+            _claim_html(claim_by_id[claim_id], resolved_text[claim_id], language)
+            for claim_id in section.get("claim_ids") or []
+        )
+        claim_grid = f'<div class="claim-grid">{claims}</div>' if claims else ""
+        tables = "".join(
+            table_html_by_key[table_key]
+            for table_key in section.get("table_keys") or []
+        )
+        products = product_html if section_id == "product_evidence" else ""
+        limitations = ""
+        if section_id == "method_and_caveats":
+            limitations = (
+                '<div class="limitations">'
+                + "".join(
+                    f"<div class=\"limitation\" data-warning-code=\"{html.escape(str(item['code']))}\">"
+                    f"<code>{html.escape(str(item['code']))}</code><p>{html.escape(str(item['text']))}</p></div>"
+                    for item in model.get("limitations") or []
+                )
+                + "</div>"
+            )
+        section_markup.append(
+            f'<section class="report-section" id="{html.escape(section_id)}" data-section-id="{html.escape(section_id)}">'
+            f'<header class="section-heading"><span class="section-number">{index:02d}</span>'
+            f"<h2>{html.escape(str(section['title']))}</h2>"
+            f"<p class=\"section-summary\">{html.escape(str(section.get('summary') or ''))}</p></header>"
+            f'<div class="section-body">{claim_grid}{tables}{products}{limitations}</div></section>'
+        )
+    return f"""<!doctype html>
+<html lang="{language}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<meta name="color-scheme" content="light"><title>{html.escape(str(model['title']))}</title><style>{_report_css()}</style></head>
+<body data-report-id="{html.escape(str(model['report_id']))}" data-package-sha256="{html.escape(str(package['sha256']))}">
+<main class="report-shell"><header class="hero"><p class="eyebrow">{html.escape(_display('Assortment report · private local file', language))}</p>
+<h1>{html.escape(str(model['title']))}</h1><p class="subtitle">{html.escape(str(model['subtitle']))}</p>
+<div class="hero-meta"><span>{html.escape(str(package.get('retailer_label') or package.get('retailer') or ''))}</span>
+<span>{html.escape(str(package.get('category_label') or package.get('category_key') or ''))}</span>
+<span>{html.escape(_display('Snapshot', language))} {html.escape(str(package.get('discovery_crawl_ts') or _display('unknown', language)))}</span></div></header>
+<div class="verdict-slot">{_verdict_placeholder(language)}</div><nav class="report-nav" aria-label="{html.escape(_display('Report sections', language))}">{nav}</nav>
+{''.join(section_markup)}
+<footer class="footer"><span>{html.escape(_display('Generated and checked locally. This report is not stored on the server.', language))}</span>
+<button class="print-button" type="button" onclick="window.print()">{html.escape(_display('Print report', language))}</button></footer></main></body></html>
+"""
+
+
+def render_report(output_dir: Path) -> dict[str, Any]:
+    """Resolve evidence tokens and render a private local HTML draft."""
+
+    output = _assert_safe_output_dir(output_dir)
+    catalog = _load_json(output / "evidence_catalog.json")
+    model = _load_json(output / "report_model.json")
+    if catalog.get("schema_version") != CATALOG_SCHEMA:
+        raise ContractError("Unsupported evidence catalog schema")
+    package_dir = Path(str(catalog["package"]["path"])).resolve()
+    claim_by_id, sections = _validate_report_model(model, catalog=catalog)
+    language = _report_language(model.get("language", "en"))
+    resolved_text, claim_ledger = _resolve_claims(claim_by_id, package_dir=package_dir)
+    table_manifest = _table_manifest_by_key(catalog)
+    used_table_keys = {
+        table_key
+        for section in sections
+        for table_key in section.get("table_keys") or []
+    }
+    table_html_by_key: dict[str, str] = {}
+    rendered_tables: list[dict[str, Any]] = []
+    for table_key in sorted(used_table_keys):
+        table_html, record = _render_table(
+            table_manifest[table_key], output_dir=output, language=language
+        )
+        table_html_by_key[table_key] = table_html
+        rendered_tables.append(record)
+    product_html, product_records = _copy_featured_products(
+        model.get("featured_products") or [],
+        package_dir=package_dir,
+        output_dir=output,
+        language=language,
+    )
+    draft = _render_draft_html(
+        model,
+        sections,
+        claim_by_id,
+        resolved_text,
+        catalog=catalog,
+        table_html_by_key=table_html_by_key,
+        product_html=product_html,
+    )
+    draft_path = output / "report_draft.html"
+    draft_path.write_text(draft, encoding="utf-8")
+    model_sha = _canonical_json_sha256(model)
+    catalog_sha = _canonical_json_sha256(catalog)
+    ledger_payload = {
+        "schema_version": "attribute_reporting.claim_ledger.v1",
+        "report_id": model["report_id"],
+        "report_model_sha256": model_sha,
+        "claims": claim_ledger,
+        "summary": {
+            "claim_count": len(claim_ledger),
+            "deterministic_count": sum(
+                item["kind"] == "deterministic" for item in claim_ledger
+            ),
+            "semantic_count": sum(item["kind"] == "semantic" for item in claim_ledger),
+            "failed_count": 0,
+        },
+    }
+    _write_json(output / "claim_ledger.json", ledger_payload)
+    render_manifest = {
+        "schema_version": RENDER_SCHEMA,
+        "rendered_at": _utc_now(),
+        "report_id": model["report_id"],
+        "package_sha256": catalog["package"]["sha256"],
+        "evidence_catalog_sha256": catalog_sha,
+        "report_model_sha256": model_sha,
+        "claim_ledger_sha256": _canonical_json_sha256(ledger_payload),
+        "draft_html": "report_draft.html",
+        "draft_html_sha256": _sha256_file(draft_path),
+        "rendered_tables": rendered_tables,
+        "featured_products": product_records,
+        "external_assets": [],
+        "status": "ready_for_independent_semantic_review",
+    }
+    _write_json(output / "render_manifest.json", render_manifest)
+    review_path = output / "semantic_review.json"
+    review = _load_json(review_path)
+    if (
+        review.get("schema_version") == REVIEW_SCHEMA
+        and review.get("overall_verdict") == "unable_to_determine"
+    ):
+        review["targets"] = {
+            "report_id": model["report_id"],
+            "evidence_catalog_sha256": catalog_sha,
+            "report_model_sha256": model_sha,
+            "draft_html_sha256": render_manifest["draft_html_sha256"],
+        }
+        _write_json(review_path, review)
+    return render_manifest
+
+
+def _mechanical_findings(
+    *,
+    output_dir: Path,
+    catalog: Mapping[str, Any],
+    model: Mapping[str, Any],
+    render_manifest: Mapping[str, Any],
+    claim_ledger: Mapping[str, Any],
+    draft: str,
+) -> list[dict[str, str]]:
+    findings: list[dict[str, str]] = []
+
+    def fail(code: str, message: str) -> None:
+        findings.append({"code": code, "message": message})
+
+    if _canonical_json_sha256(catalog) != render_manifest.get(
+        "evidence_catalog_sha256"
+    ):
+        fail(
+            "catalog_sha256_mismatch",
+            "The evidence catalog changed after rendering and semantic review.",
+        )
+    intake: Mapping[str, Any] | None = None
+    expected_intake_sha = str(catalog.get("run_intake_sha256") or "")
+    if expected_intake_sha:
+        intake_path = output_dir / "run_intake.json"
+        if not intake_path.is_file():
+            fail("run_intake_missing", "The hash-pinned run intake is missing.")
+        else:
+            try:
+                intake = _load_json(intake_path)
+            except ContractError as exc:
+                fail("run_intake_invalid", str(exc))
+            else:
+                if _canonical_json_sha256(intake) != expected_intake_sha:
+                    fail(
+                        "run_intake_changed",
+                        "The run intake changed after evidence preparation.",
+                    )
+    try:
+        _validate_report_model(model, catalog=catalog)
+    except ContractError as exc:
+        fail("report_model_contract_failed", str(exc))
+
+    package_dir = Path(str(catalog.get("package", {}).get("path") or "")).resolve()
+    if not package_dir.is_dir():
+        fail("package_missing", f"Evidence package is unavailable: {package_dir}")
+        return findings
+
+    catalog_lineage = catalog.get("transport_lineage")
+    intake_lineage = None
+    if isinstance(intake, dict) and isinstance(intake.get("inputs"), dict):
+        intake_lineage = intake["inputs"].get("transport_lineage")
+    if catalog_lineage != intake_lineage:
+        fail(
+            "transport_lineage_intake_mismatch",
+            "Evidence catalog and run intake disagree on transport lineage.",
+        )
+    if catalog_lineage is not None:
+        if not isinstance(catalog_lineage, dict):
+            fail(
+                "transport_lineage_invalid",
+                "Evidence catalog transport lineage must be an object.",
+            )
+        else:
+            artifacts = catalog_lineage.get("artifacts")
+            if not isinstance(artifacts, dict) or set(artifacts) != set(
+                LOCAL_TRANSPORT_RECEIPT_FILES
+            ):
+                fail(
+                    "transport_receipt_ledger_invalid",
+                    "Transport lineage does not pin both local receipt copies.",
+                )
+            else:
+                receipt_paths = tuple(
+                    output_dir / file_name
+                    for file_name in LOCAL_TRANSPORT_RECEIPT_FILES
+                )
+                receipt_hashes_valid = True
+                for receipt_path in receipt_paths:
+                    expected_sha256 = str(artifacts.get(receipt_path.name) or "")
+                    if (
+                        not receipt_path.is_file()
+                        or not re.fullmatch(r"[0-9a-f]{64}", expected_sha256)
+                        or _sha256_file(receipt_path) != expected_sha256
+                    ):
+                        receipt_hashes_valid = False
+                        fail(
+                            "transport_receipt_changed",
+                            f"Pinned transport receipt changed: {receipt_path.name}",
+                        )
+                if receipt_hashes_valid:
+                    try:
+                        current_lineage = _validate_local_transport_receipts(
+                            package_dir,
+                            _load_local_transport_receipt(
+                                receipt_paths[0],
+                                label="Pinned local download receipt",
+                            ),
+                            _load_local_transport_receipt(
+                                receipt_paths[1],
+                                label="Pinned local extraction receipt",
+                            ),
+                        )
+                    except ContractError as exc:
+                        fail("transport_lineage_failed", str(exc))
+                    else:
+                        expected_lineage = {
+                            key: value
+                            for key, value in catalog_lineage.items()
+                            if key != "artifacts"
+                        }
+                        if current_lineage != expected_lineage:
+                            fail(
+                                "transport_lineage_changed",
+                                "Current package transport lineage differs from preparation.",
+                            )
+    elif isinstance(intake, dict):
+        inputs = intake.get("inputs")
+        provenance = (
+            inputs.get("mapping_provenance") if isinstance(inputs, dict) else None
+        )
+        acceptance = (
+            provenance.get("server_acceptance")
+            if isinstance(provenance, dict)
+            else None
+        )
+        if isinstance(acceptance, dict) and acceptance.get("status") == (
+            "server_accepted"
+        ):
+            fail(
+                "transport_lineage_missing",
+                "Server-accepted provenance has no verified download/extraction lineage.",
+            )
+    manifest: Mapping[str, Any] = {}
+    try:
+        manifest = _load_json(
+            _contained_package_path(
+                package_dir, "pack_manifest.json", label="pack manifest"
+            )
+        )
+        source_paths = _package_source_paths(package_dir, manifest)
+        current_package_sha = _package_fingerprint(package_dir, source_paths)
+    except ContractError as exc:
+        fail("package_fingerprint_unavailable", str(exc))
+        current_package_sha = ""
+    expected_package_sha = str(catalog.get("package", {}).get("sha256") or "")
+    if current_package_sha != expected_package_sha:
+        fail(
+            "package_sha256_mismatch",
+            "The evidence package changed after run preparation.",
+        )
+
+    source_hashes = catalog.get("source_hashes")
+    if not isinstance(source_hashes, dict):
+        fail("source_hashes_missing", "The evidence catalog has no source hash ledger.")
+    else:
+        for raw_relative, expected_sha in source_hashes.items():
+            try:
+                relative = _safe_relative_path(
+                    str(raw_relative), label="catalog source"
+                )
+                path = _contained_package_path(
+                    package_dir, relative, label="catalog source"
+                )
+            except ContractError as exc:
+                fail("source_path_invalid", str(exc))
+                continue
+            if not path.is_file():
+                fail(
+                    "source_missing",
+                    f"Package source is missing: {relative.as_posix()}",
+                )
+            elif _sha256_file(path) != expected_sha:
+                fail(
+                    "source_sha256_mismatch",
+                    f"Package source changed: {relative.as_posix()}",
+                )
+
+    catalog_sources = catalog.get("sources")
+    if not isinstance(catalog_sources, list):
+        fail("source_catalog_missing", "The evidence source catalog is missing.")
+    else:
+        for item in catalog_sources:
+            if not isinstance(item, dict) or item.get("status") != "available":
+                continue
+            raw_source = str(item.get("file") or "")
+            expected_sha = str(item.get("sha256") or "")
+            try:
+                relative = _safe_relative_path(
+                    raw_source, label="available catalog source"
+                )
+                path = _contained_package_path(
+                    package_dir, relative, label="available catalog source"
+                )
+            except ContractError as exc:
+                fail("source_catalog_path_invalid", str(exc))
+                continue
+            if not expected_sha:
+                fail(
+                    "source_catalog_sha256_missing",
+                    f"Available catalog source has no hash: {relative.as_posix()}",
+                )
+            elif not path.is_file():
+                fail(
+                    "source_catalog_missing",
+                    f"Available catalog source is missing: {relative.as_posix()}",
+                )
+            elif _sha256_file(path) != expected_sha:
+                fail(
+                    "source_catalog_sha256_mismatch",
+                    f"Available catalog source changed: {relative.as_posix()}",
+                )
+
+    checked_ledger_sources: set[tuple[str, str]] = set()
+    for claim in claim_ledger.get("claims") or []:
+        if not isinstance(claim, dict):
+            continue
+        for evidence in claim.get("evidence") or []:
+            if not isinstance(evidence, dict):
+                continue
+            raw_source = str(evidence.get("source") or "")
+            expected_sha = str(evidence.get("source_sha256") or "")
+            source_identity = (raw_source, expected_sha)
+            if source_identity in checked_ledger_sources:
+                continue
+            checked_ledger_sources.add(source_identity)
+            try:
+                relative = _safe_relative_path(raw_source, label="claim-ledger source")
+                path = _contained_package_path(
+                    package_dir, relative, label="claim-ledger source"
+                )
+            except ContractError as exc:
+                fail("source_ledger_path_invalid", str(exc))
+                continue
+            if not expected_sha:
+                fail(
+                    "source_ledger_sha256_missing",
+                    f"Claim-ledger source has no hash: {relative.as_posix()}",
+                )
+            elif not path.is_file():
+                fail(
+                    "source_ledger_missing",
+                    f"Claim-ledger source is missing: {relative.as_posix()}",
+                )
+            elif _sha256_file(path) != expected_sha:
+                fail(
+                    "source_ledger_sha256_mismatch",
+                    f"Claim-ledger source changed: {relative.as_posix()}",
+                )
+
+    try:
+        integrity_path = _contained_package_path(
+            package_dir, "package_integrity.json", label="package integrity"
+        )
+        integrity = _load_json(integrity_path)
+    except ContractError as exc:
+        fail("package_integrity_unavailable", str(exc))
+    else:
+        if str(integrity.get("status") or "").lower() != "pass":
+            fail("package_integrity_failed", "Package integrity is not pass.")
+        expected_integrity_sha = str(
+            catalog.get("package", {}).get("integrity_sha256") or ""
+        )
+        if _sha256_file(integrity_path) != expected_integrity_sha:
+            fail(
+                "package_integrity_sha256_mismatch",
+                "Package integrity artifact changed.",
+            )
+        try:
+            summary = _load_json(
+                _contained_package_path(
+                    package_dir, "summary.json", label="package summary"
+                )
+            )
+            expected_warnings = _collect_package_warnings(
+                package_dir,
+                summary,
+                manifest,
+                integrity,
+            )
+        except ContractError as exc:
+            fail("catalog_warning_check_failed", str(exc))
+        else:
+            catalog_warnings = catalog.get("warnings")
+            if (
+                not isinstance(catalog_warnings, list)
+                or catalog_warnings != expected_warnings
+            ):
+                fail(
+                    "catalog_warning_mismatch",
+                    "Evidence-catalog warnings differ from the current package warnings.",
+                )
+
+    model_sha = _canonical_json_sha256(model)
+    if model_sha != render_manifest.get("report_model_sha256"):
+        fail("report_model_changed", "The report model changed after rendering.")
+    if render_manifest.get("report_id") != model.get("report_id"):
+        fail(
+            "report_id_mismatch",
+            "Render manifest and report model disagree on report_id.",
+        )
+    if render_manifest.get("package_sha256") != expected_package_sha:
+        fail(
+            "render_package_mismatch",
+            "Render manifest targets another evidence package.",
+        )
+
+    draft_path = output_dir / str(render_manifest.get("draft_html") or "")
+    if not draft_path.is_file():
+        fail("draft_missing", "Rendered HTML draft is missing.")
+    elif _sha256_file(draft_path) != render_manifest.get("draft_html_sha256"):
+        fail("draft_sha256_mismatch", "Rendered HTML draft changed after rendering.")
+
+    if _canonical_json_sha256(claim_ledger) != render_manifest.get(
+        "claim_ledger_sha256"
+    ):
+        fail("claim_ledger_changed", "The claim ledger changed after rendering.")
+    ledger_claims = claim_ledger.get("claims")
+    if not isinstance(ledger_claims, list) or not ledger_claims:
+        fail("claim_ledger_empty", "The claim ledger has no claims.")
+    else:
+        for item in ledger_claims:
+            if not isinstance(item, dict) or item.get("status") != "pass":
+                fail(
+                    "claim_check_failed",
+                    "At least one deterministic claim check is not pass.",
+                )
+                break
+
+    for table in render_manifest.get("rendered_tables") or []:
+        if not isinstance(table, dict):
+            fail(
+                "table_manifest_invalid",
+                "Rendered table manifest contains a non-object row.",
+            )
+            continue
+        try:
+            relative = _safe_relative_path(
+                str(table.get("csv") or ""), label="rendered table"
+            )
+        except ContractError as exc:
+            fail("table_path_invalid", str(exc))
+            continue
+        path = output_dir / "evidence" / relative
+        if not path.is_file() or _sha256_file(path) != table.get("sha256"):
+            fail(
+                "table_sha256_mismatch",
+                f"Rendered table changed: {table.get('table_key')}",
+            )
+
+    for product in render_manifest.get("featured_products") or []:
+        if not isinstance(product, dict) or not product.get("image_path"):
+            continue
+        try:
+            relative = _safe_relative_path(
+                str(product["image_path"]), label="product image"
+            )
+        except ContractError as exc:
+            fail("product_image_path_invalid", str(exc))
+            continue
+        path = output_dir / relative
+        if not path.is_file() or _sha256_file(path) != product.get("image_sha256"):
+            fail(
+                "product_image_sha256_mismatch",
+                f"Featured image changed: {product.get('product_id')}",
+            )
+
+    report_id = html.escape(str(model.get("report_id") or ""))
+    if f'data-report-id="{report_id}"' not in draft:
+        fail("html_report_id_missing", "HTML does not carry the report id.")
+    for claim in model.get("claims") or []:
+        claim_id = html.escape(str(claim.get("claim_id") or ""))
+        if draft.count(f'data-claim-id="{claim_id}"') != 1:
+            fail("html_claim_parity", f"HTML claim parity failed for {claim_id}.")
+    for section in model.get("sections") or []:
+        section_id = html.escape(str(section.get("section_id") or ""))
+        if draft.count(f'data-section-id="{section_id}"') != 1:
+            fail("html_section_parity", f"HTML section parity failed for {section_id}.")
+    for warning in catalog.get("warnings") or []:
+        warning_code = html.escape(str(warning.get("code") or ""))
+        if draft.count(f'data-warning-code="{warning_code}"') != 1:
+            fail(
+                "html_warning_parity",
+                f"HTML does not visibly disclose warning {warning_code}.",
+            )
+    if re.search(r"<(?:script|img)[^>]+src=[\"']https?://", draft, re.IGNORECASE):
+        fail(
+            "external_asset_detected",
+            "HTML contains an external script or image asset.",
+        )
+    return findings
+
+
+def _semantic_review_state(
+    review: Mapping[str, Any],
+    *,
+    model: Mapping[str, Any],
+    render_manifest: Mapping[str, Any],
+) -> tuple[str, list[dict[str, str]], bool]:
+    findings: list[dict[str, str]] = []
+
+    def invalid(code: str, message: str) -> None:
+        findings.append({"code": code, "message": message})
+
+    def finding_code(kind: str, identity: str) -> str:
+        token = _normalise_mapping_token(identity)[:64] or "item"
+        digest = hashlib.sha256(identity.encode("utf-8")).hexdigest()[:8]
+        return f"semantic_{kind}_{token}_{digest}"
+
+    if review.get("schema_version") != REVIEW_SCHEMA:
+        invalid(
+            "semantic_review_schema",
+            "Semantic review schema is missing or unsupported.",
+        )
+        return "unable_to_determine", findings, False
+    reviewer = review.get("reviewer")
+    author = model.get("author")
+    if not isinstance(author, dict):
+        invalid("semantic_author_invalid", "Report author identity is invalid.")
+        author = {}
+    if not SAFE_ID_RE.fullmatch(str(review.get("review_id") or "")):
+        invalid("semantic_review_id", "Semantic review_id is missing or invalid.")
+    if review.get("author_agent_id") != author.get("agent_id"):
+        invalid(
+            "semantic_review_author_mismatch",
+            "Semantic review does not identify the report author.",
+        )
+    if not str(review.get("summary") or "").strip():
+        invalid("semantic_review_summary", "Semantic review summary is required.")
+    if not isinstance(reviewer, dict) or reviewer.get("execution") != "codex_agent":
+        invalid(
+            "semantic_reviewer_invalid",
+            "Semantic review was not attributed to a Codex agent.",
+        )
+    elif (
+        not reviewer.get("independent_from_author")
+        or reviewer.get("role") != "independent_reviewer"
+        or not str(reviewer.get("agent_id") or "").strip()
+        or reviewer.get("agent_id") == author.get("agent_id")
+    ):
+        invalid(
+            "semantic_reviewer_not_independent",
+            "Semantic reviewer is not independent from the author.",
+        )
+    targets = review.get("targets")
+    if not isinstance(targets, dict):
+        invalid(
+            "semantic_review_targets_missing", "Semantic review has no target hashes."
+        )
+    else:
+        expected_targets = {
+            "report_id": model.get("report_id"),
+            "evidence_catalog_sha256": render_manifest.get("evidence_catalog_sha256"),
+            "report_model_sha256": render_manifest.get("report_model_sha256"),
+            "draft_html_sha256": render_manifest.get("draft_html_sha256"),
+        }
+        if any(targets.get(key) != value for key, value in expected_targets.items()):
+            invalid(
+                "semantic_review_target_mismatch",
+                "Semantic review targets another draft or model.",
+            )
+
+    dimensions = review.get("dimensions")
+    if not isinstance(dimensions, dict) or set(dimensions) != set(
+        REQUIRED_REVIEW_DIMENSIONS
+    ):
+        invalid(
+            "semantic_review_dimensions",
+            "Semantic review must cover every required dimension.",
+        )
+        dimension_statuses: list[str] = []
+    else:
+        dimension_statuses = []
+        for dimension in REQUIRED_REVIEW_DIMENSIONS:
+            item = dimensions[dimension]
+            if (
+                not isinstance(item, dict)
+                or item.get("status")
+                not in {
+                    "pass",
+                    "caveat",
+                    "fail",
+                    "unable_to_determine",
+                }
+                or not str(item.get("rationale") or "").strip()
+            ):
+                invalid(
+                    "semantic_review_dimension_invalid",
+                    f"Invalid semantic review dimension: {dimension}",
+                )
+                continue
+            status = str(item["status"])
+            dimension_statuses.append(status)
+            if status != "pass":
+                findings.append(
+                    {
+                        "code": finding_code("dimension", dimension),
+                        "message": str(item["rationale"]).strip(),
+                        "status": status,
+                    }
+                )
+
+    report_level_statuses: list[str] = []
+    report_level_findings = review.get("report_level_findings")
+    if not isinstance(report_level_findings, list):
+        invalid(
+            "semantic_report_findings_missing",
+            "Semantic review has no report-level findings list.",
+        )
+    else:
+        seen_finding_codes: set[str] = set()
+        for item in report_level_findings:
+            if not isinstance(item, dict):
+                invalid(
+                    "semantic_report_finding_invalid",
+                    "A report-level finding is not an object.",
+                )
+                continue
+            code = str(item.get("code") or "")
+            status = str(item.get("status") or "")
+            message = str(item.get("finding") or "").strip()
+            if (
+                not SAFE_ID_RE.fullmatch(code)
+                or code in seen_finding_codes
+                or status not in {"caveat", "fail", "unable_to_determine"}
+                or not message
+            ):
+                invalid(
+                    "semantic_report_finding_invalid",
+                    f"Invalid report-level finding: {code or '(missing code)' }.",
+                )
+                continue
+            seen_finding_codes.add(code)
+            report_level_statuses.append(status)
+            findings.append({"code": code, "message": message, "status": status})
+
+    model_claim_ids = {str(item.get("claim_id")) for item in model.get("claims") or []}
+    claim_reviews = review.get("claim_reviews")
+    review_by_id: dict[str, Mapping[str, Any]] = {}
+    if not isinstance(claim_reviews, list):
+        invalid(
+            "semantic_claim_reviews_missing",
+            "Semantic review has no claim review list.",
+        )
+    else:
+        for item in claim_reviews:
+            if not isinstance(item, dict):
+                invalid(
+                    "semantic_claim_review_invalid", "A claim review is not an object."
+                )
+                continue
+            claim_id = str(item.get("claim_id") or "")
+            if claim_id in review_by_id:
+                invalid(
+                    "semantic_claim_review_duplicate",
+                    f"Claim {claim_id} was reviewed more than once.",
+                )
+                continue
+            if (
+                item.get("verdict")
+                not in {
+                    "supported",
+                    "supported_with_caveat",
+                    "unsupported",
+                    "unable_to_determine",
+                }
+                or not str(item.get("reason") or "").strip()
+            ):
+                invalid(
+                    "semantic_claim_review_invalid",
+                    f"Claim {claim_id} has an invalid semantic verdict.",
+                )
+                continue
+            review_by_id[claim_id] = item
+            verdict = str(item["verdict"])
+            if verdict != "supported":
+                findings.append(
+                    {
+                        "code": finding_code("claim", claim_id),
+                        "message": str(item["reason"]).strip(),
+                        "status": {
+                            "supported_with_caveat": "caveat",
+                            "unsupported": "fail",
+                            "unable_to_determine": "unable_to_determine",
+                        }[verdict],
+                    }
+                )
+        if set(review_by_id) != model_claim_ids:
+            invalid(
+                "semantic_claim_coverage",
+                "Semantic review must cover every report claim exactly once.",
+            )
+
+    image_statuses: list[str] = []
+    expected_images = {
+        str(item.get("product_id")): item
+        for item in render_manifest.get("featured_products") or []
+        if isinstance(item, dict) and item.get("image_path")
+    }
+    images_reviewed = review.get("images_reviewed")
+    reviewed_images: dict[str, Mapping[str, Any]] = {}
+    if not isinstance(images_reviewed, list):
+        invalid(
+            "semantic_image_reviews_missing",
+            "Semantic review has no image review list.",
+        )
+    else:
+        for item in images_reviewed:
+            if not isinstance(item, dict):
+                invalid(
+                    "semantic_image_review_invalid",
+                    "An image review is not an object.",
+                )
+                continue
+            product_id = str(item.get("product_id") or "")
+            expected = expected_images.get(product_id)
+            status = str(item.get("status") or "")
+            if (
+                expected is None
+                or product_id in reviewed_images
+                or item.get("image_path") != expected.get("image_path")
+                or item.get("image_sha256") != expected.get("image_sha256")
+                or status not in {"pass", "caveat", "fail", "unable_to_determine"}
+                or not str(item.get("observation") or "").strip()
+            ):
+                invalid(
+                    "semantic_image_review_invalid",
+                    f"Invalid semantic image review for {product_id or '(missing product)' }.",
+                )
+                continue
+            reviewed_images[product_id] = item
+            image_statuses.append(status)
+            if status != "pass":
+                findings.append(
+                    {
+                        "code": finding_code("image", product_id),
+                        "message": str(item["observation"]).strip(),
+                        "status": status,
+                    }
+                )
+        if set(reviewed_images) != set(expected_images):
+            invalid(
+                "semantic_image_review_coverage",
+                "Semantic review must cover every rendered local product image exactly once.",
+            )
+
+    overall = str(review.get("overall_verdict") or "")
+    if overall not in VERDICT_LABELS:
+        invalid("semantic_overall_verdict", "Semantic overall verdict is invalid.")
+    elif overall != "correct":
+        overall_status = {
+            "correct_with_caveats": "caveat",
+            "incorrect": "fail",
+            "unable_to_determine": "unable_to_determine",
+        }[overall]
+        if not any(item.get("status") == overall_status for item in findings):
+            findings.append(
+                {
+                    "code": "semantic_overall_review",
+                    "message": str(review.get("summary") or "").strip(),
+                    "status": overall_status,
+                }
+            )
+    structural_findings = [item for item in findings if "status" not in item]
+    if structural_findings:
+        return "unable_to_determine", findings, False
+
+    claim_verdicts = {str(item.get("verdict")) for item in review_by_id.values()}
+    if (
+        overall == "incorrect"
+        or "unsupported" in claim_verdicts
+        or "fail" in dimension_statuses
+        or "fail" in report_level_statuses
+        or "fail" in image_statuses
+    ):
+        state = "incorrect"
+    elif (
+        overall == "unable_to_determine"
+        or "unable_to_determine" in claim_verdicts
+        or "unable_to_determine" in dimension_statuses
+        or "unable_to_determine" in report_level_statuses
+        or "unable_to_determine" in image_statuses
+    ):
+        state = "unable_to_determine"
+    elif (
+        overall == "correct_with_caveats"
+        or "supported_with_caveat" in claim_verdicts
+        or "caveat" in dimension_statuses
+        or "caveat" in report_level_statuses
+        or "caveat" in image_statuses
+    ):
+        state = "correct_with_caveats"
+    else:
+        state = "correct"
+    return state, findings, True
+
+
+def _no_work_mapping_review_state(
+    output_dir: Path,
+    *,
+    basis: Any,
+    intake_inputs: Mapping[str, Any],
+) -> tuple[str, list[dict[str, str]], bool, dict[str, Any] | None]:
+    """Validate and disclose one explicit zero-task current-package branch."""
+
+    invalid_finding = {
+        "code": "mapping_no_work_basis_invalid",
+        "message": (
+            "The no-work mapping basis is missing, stale, or inconsistent with "
+            "the preliminary current-database package."
+        ),
+        "status": "unable_to_determine",
+    }
+    if not isinstance(basis, dict):
+        return "unable_to_determine", [invalid_finding], False, None
+    artifact_name = str(basis.get("artifact") or "")
+    artifact_path = output_dir / artifact_name
+    expected_sha256 = str(basis.get("artifact_sha256") or "")
+    transport_lineage = intake_inputs.get("transport_lineage")
+    download_lineage = (
+        transport_lineage.get("download")
+        if isinstance(transport_lineage, dict)
+        else None
+    )
+    expected_job_id = (
+        str(download_lineage.get("job_id") or "")
+        if isinstance(download_lineage, dict)
+        else ""
+    )
+    try:
+        if artifact_name != NO_WORK_WORKSET_FILE:
+            raise ContractError("Unexpected no-work workset artifact")
+        if (
+            not re.fullmatch(r"[0-9a-f]{64}", expected_sha256)
+            or not artifact_path.is_file()
+            or _sha256_file(artifact_path) != expected_sha256
+        ):
+            raise ContractError("No-work workset artifact changed")
+        _source, workset = _load_no_work_workset(artifact_path)
+        catalog = _load_json(output_dir / "evidence_catalog.json")
+        package = catalog.get("package")
+        if not isinstance(package, dict):
+            raise ContractError("Evidence catalog has no package scope")
+        validated = _validate_no_work_workset(
+            workset,
+            package_summary=package,
+            expected_job_id=expected_job_id,
+        )
+        package_dir = Path(str(package.get("path") or "")).resolve()
+        validated["server_sanitization_receipt_sha256"] = (
+            _validate_preliminary_sanitization_receipt(package_dir)
+        )
+        expected_basis = {
+            **validated,
+            "artifact": NO_WORK_WORKSET_FILE,
+            "artifact_sha256": expected_sha256,
+        }
+        if basis != expected_basis or catalog.get("mapping_review_basis") != basis:
+            raise ContractError("No-work mapping basis changed")
+    except ContractError:
+        return "unable_to_determine", [invalid_finding], False, None
+
+    resolved_count = int(basis["resolved_attribute_cells"])
+    if resolved_count > 0:
+        cell_label = "cell" if resolved_count == 1 else "cells"
+        message = (
+            "No unresolved product/parent mapping tasks were issued. "
+            f"{resolved_count} pre-existing resolved attribute {cell_label} from the "
+            "central current-database package were treated as trusted input and "
+            "were not re-reviewed in this run; mapping review is not applicable."
+        )
+    else:
+        message = (
+            "No unresolved product/parent mapping tasks were issued, so no new "
+            "mapping was authored or reviewed. The report uses the preliminary "
+            "current-database package as-is; mapping review is not applicable."
+        )
+    findings = [
+        {
+            "code": "mapping_no_work_trusted_current_package",
+            "message": message,
+            "status": "caveat",
+        }
+    ]
+    skipped_variants = int(basis["variant_attribute_cells_skipped"])
+    if skipped_variants > 0:
+        findings.append(
+            {
+                "code": "variant_mapping_coverage_incomplete",
+                "message": (
+                    f"{skipped_variants} variant-level attribute cells were outside "
+                    "the parent-product zero-task workset and remain a coverage caveat."
+                ),
+                "status": "caveat",
+            }
+        )
+    validation = {
+        "review_state": "not_applicable",
+        "summary": message,
+        "resolved_attribute_cells": resolved_count,
+        "include_resolved": False,
+        "task_count": 0,
+        "variant_attribute_cells_skipped": skipped_variants,
+    }
+    return "not_applicable", findings, True, validation
+
+
+def _mapping_review_state(
+    output_dir: Path,
+) -> tuple[str, list[dict[str, str]], bool, dict[str, Any] | None]:
+    """Validate mapping-review mechanics when this report run carries mappings."""
+
+    artifact_names = {
+        "tasks": "mapping_tasks.json",
+        "decisions": "mapping_decisions.json",
+        "validated": "validated_mappings.json",
+        "review": "mapping_review.json",
+    }
+    present = {
+        key: (output_dir / file_name).is_file()
+        for key, file_name in artifact_names.items()
+    }
+    intake_path = output_dir / "run_intake.json"
+    intake = _load_json(intake_path) if intake_path.is_file() else {}
+    intake_inputs = intake.get("inputs")
+    expected_provenance = (
+        intake_inputs.get("mapping_provenance")
+        if isinstance(intake_inputs, dict)
+        else None
+    )
+    mapping_review_basis = (
+        intake_inputs.get("mapping_review_basis")
+        if isinstance(intake_inputs, dict)
+        else None
+    )
+    if not any(present.values()) and expected_provenance is None:
+        if mapping_review_basis is not None and isinstance(intake_inputs, dict):
+            return _no_work_mapping_review_state(
+                output_dir,
+                basis=mapping_review_basis,
+                intake_inputs=intake_inputs,
+            )
+        return "not_applicable", [], True, None
+    if mapping_review_basis is not None:
+        return (
+            "unable_to_determine",
+            [
+                {
+                    "code": "mapping_review_basis_conflict",
+                    "message": (
+                        "The run carries both a no-work basis and new-mapping "
+                        "review artifacts."
+                    ),
+                    "status": "unable_to_determine",
+                }
+            ],
+            False,
+            None,
+        )
+    missing = [
+        artifact_names[key] for key, is_present in present.items() if not is_present
+    ]
+    if missing:
+        return (
+            "unable_to_determine",
+            [
+                {
+                    "code": "mapping_review_artifacts_missing",
+                    "message": (
+                        "Mapping provenance is incomplete; missing: "
+                        + ", ".join(sorted(missing))
+                    ),
+                    "status": "unable_to_determine",
+                }
+            ],
+            False,
+            None,
+        )
+    acceptance_status = "local_review_only"
+    if expected_provenance is not None:
+        if not isinstance(expected_provenance, dict) or not isinstance(
+            expected_provenance.get("artifacts"), dict
+        ):
+            return (
+                "unable_to_determine",
+                [
+                    {
+                        "code": "mapping_review_provenance_invalid",
+                        "message": "Run intake contains an invalid mapping provenance contract.",
+                        "status": "unable_to_determine",
+                    }
+                ],
+                False,
+                None,
+            )
+        server_acceptance = expected_provenance.get("server_acceptance")
+        if not isinstance(server_acceptance, dict) or server_acceptance.get(
+            "status"
+        ) not in {"server_accepted", "local_review_only"}:
+            return (
+                "unable_to_determine",
+                [
+                    {
+                        "code": "mapping_server_acceptance_invalid",
+                        "message": (
+                            "Run intake contains an invalid server mapping-acceptance "
+                            "contract."
+                        ),
+                        "status": "unable_to_determine",
+                    }
+                ],
+                False,
+                None,
+            )
+        acceptance_status = str(server_acceptance["status"])
+        server_hashes = server_acceptance.get("artifacts")
+        if not isinstance(server_hashes, dict):
+            return (
+                "unable_to_determine",
+                [
+                    {
+                        "code": "mapping_server_acceptance_invalid",
+                        "message": "Server mapping-acceptance artifact pins are invalid.",
+                        "status": "unable_to_determine",
+                    }
+                ],
+                False,
+                None,
+            )
+        expected_server_names = (
+            set(SERVER_MAPPING_PROVENANCE_FILES)
+            if acceptance_status == "server_accepted"
+            else set()
+        )
+        if set(server_hashes) != expected_server_names or any(
+            not (output_dir / file_name).is_file()
+            or not re.fullmatch(r"[0-9a-f]{64}", str(expected_sha256 or ""))
+            or _sha256_file(output_dir / file_name) != str(expected_sha256)
+            for file_name, expected_sha256 in server_hashes.items()
+        ):
+            return (
+                "unable_to_determine",
+                [
+                    {
+                        "code": "mapping_server_acceptance_changed",
+                        "message": (
+                            "Server mapping-acceptance provenance is missing or differs "
+                            "from the run intake hashes."
+                        ),
+                        "status": "unable_to_determine",
+                    }
+                ],
+                False,
+                None,
+            )
+        expected_hashes = expected_provenance["artifacts"]
+        if set(expected_hashes) != set(artifact_names.values()) or any(
+            not re.fullmatch(r"[0-9a-f]{64}", str(expected_hashes.get(file_name) or ""))
+            or _sha256_file(output_dir / file_name) != str(expected_hashes[file_name])
+            for file_name in artifact_names.values()
+        ):
+            return (
+                "unable_to_determine",
+                [
+                    {
+                        "code": "mapping_review_provenance_changed",
+                        "message": "Mapping provenance differs from the run intake hashes.",
+                        "status": "unable_to_determine",
+                    }
+                ],
+                False,
+                None,
+            )
+    try:
+        validation = validate_mapping_review_payloads(
+            _load_json(output_dir / artifact_names["tasks"]),
+            _load_json(output_dir / artifact_names["decisions"]),
+            _load_json(output_dir / artifact_names["validated"]),
+            _load_json(output_dir / artifact_names["review"]),
+        )
+    except ContractError as exc:
+        return (
+            "unable_to_determine",
+            [
+                {
+                    "code": "mapping_review_invalid",
+                    "message": str(exc),
+                    "status": "unable_to_determine",
+                }
+            ],
+            False,
+            None,
+        )
+
+    state = str(validation["review_state"])
+    findings: list[dict[str, str]] = []
+    status_by_verdict = {
+        "supported_with_caveat": "caveat",
+        "unsupported": "fail",
+        "unable_to_determine": "unable_to_determine",
+    }
+    for finding in validation.get("findings") or []:
+        task_id = str(finding.get("task_id") or "mapping-task")
+        digest = hashlib.sha256(task_id.encode("utf-8")).hexdigest()[:8]
+        findings.append(
+            {
+                "code": f"mapping_review_{digest}",
+                "message": str(finding.get("reason") or "").strip(),
+                "status": status_by_verdict[str(finding["verdict"])],
+            }
+        )
+    if acceptance_status != "server_accepted":
+        findings.append(
+            {
+                "code": "mapping_not_server_accepted",
+                "message": (
+                    "The mappings passed independent local review but this report run "
+                    "does not carry proof that the shared server database accepted them."
+                ),
+                "status": "caveat",
+            }
+        )
+    tasks_payload = _load_json(output_dir / artifact_names["tasks"])
+    coverage = tasks_payload.get("coverage")
+    skipped_variants = (
+        coverage.get("variant_attribute_cells_skipped", 0)
+        if isinstance(coverage, dict)
+        else 0
+    )
+    if not isinstance(skipped_variants, int) or isinstance(skipped_variants, bool):
+        skipped_variants = 0
+    if skipped_variants > 0:
+        findings.append(
+            {
+                "code": "variant_mapping_coverage_incomplete",
+                "message": (
+                    f"{skipped_variants} variant-level attribute cells were outside "
+                    "the parent-product mapping workset and remain a coverage caveat."
+                ),
+                "status": "caveat",
+            }
+        )
+    include_resolved = (
+        coverage.get("include_resolved") if isinstance(coverage, dict) else None
+    )
+    resolved_attribute_cells = (
+        coverage.get("resolved_attribute_cells", 0) if isinstance(coverage, dict) else 0
+    )
+    if (
+        include_resolved is False
+        and isinstance(resolved_attribute_cells, int)
+        and not isinstance(resolved_attribute_cells, bool)
+        and resolved_attribute_cells > 0
+    ):
+        cell_label = "cell" if resolved_attribute_cells == 1 else "cells"
+        findings.append(
+            {
+                "code": "central_resolved_mappings_trusted_input",
+                "message": (
+                    "This incremental review covered unresolved tasks only. "
+                    f"{resolved_attribute_cells} pre-existing resolved attribute "
+                    f"{cell_label} from the central package were trusted input and were "
+                    "not re-reviewed in this run."
+                ),
+                "status": "caveat",
+            }
+        )
+    correction_selection = tasks_payload.get("correction_selection")
+    correction_counts: dict[str, int] = {}
+    if correction_selection is not None:
+        if (
+            not isinstance(correction_selection, dict)
+            or correction_selection.get("schema_version")
+            != CORRECTION_TASK_SELECTION_SCHEMA
+            or not isinstance(correction_selection.get("criteria"), dict)
+        ):
+            return (
+                "unable_to_determine",
+                [
+                    *findings,
+                    {
+                        "code": "correction_mapping_scope_invalid",
+                        "message": "The correction workset scope disclosure is invalid.",
+                        "status": "unable_to_determine",
+                    },
+                ],
+                False,
+                None,
+            )
+        for field in (
+            "task_count_before_selection",
+            "task_count",
+            "excluded_unresolved_count",
+            "excluded_non_codex_effective_count",
+            "excluded_not_pinned_count",
+        ):
+            value = correction_selection.get(field)
+            if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+                return (
+                    "unable_to_determine",
+                    [
+                        *findings,
+                        {
+                            "code": "correction_mapping_scope_invalid",
+                            "message": (
+                                "The correction workset scope disclosure is invalid."
+                            ),
+                            "status": "unable_to_determine",
+                        },
+                    ],
+                    False,
+                    None,
+                )
+            correction_counts[field] = value
+        if (
+            include_resolved is not True
+            or correction_counts["task_count"] != len(tasks_payload.get("tasks") or [])
+            or correction_counts["task_count_before_selection"]
+            != correction_counts["task_count"]
+            + correction_counts["excluded_unresolved_count"]
+            + correction_counts["excluded_non_codex_effective_count"]
+            + correction_counts["excluded_not_pinned_count"]
+        ):
+            return (
+                "unable_to_determine",
+                [
+                    *findings,
+                    {
+                        "code": "correction_mapping_scope_invalid",
+                        "message": "The correction workset scope disclosure is invalid.",
+                        "status": "unable_to_determine",
+                    },
+                ],
+                False,
+                None,
+            )
+        excluded_unresolved = correction_counts["excluded_unresolved_count"]
+        if excluded_unresolved > 0:
+            findings.append(
+                {
+                    "code": "correction_unresolved_cells_not_reviewed",
+                    "message": (
+                        f"{excluded_unresolved} unresolved attribute cells were outside "
+                        "this accepted-mapping correction review and remain unmapped."
+                    ),
+                    "status": "caveat",
+                }
+            )
+        excluded_non_codex = correction_counts["excluded_non_codex_effective_count"]
+        if excluded_non_codex > 0:
+            findings.append(
+                {
+                    "code": "correction_non_codex_effective_cells_not_reviewed",
+                    "message": (
+                        f"{excluded_non_codex} resolved attribute cells were excluded "
+                        "because their effective value did not come from an accepted "
+                        "Codex mapping; they were trusted package input and were not "
+                        "re-reviewed in this correction run."
+                    ),
+                    "status": "caveat",
+                }
+            )
+        if correction_counts["excluded_not_pinned_count"] > 0:
+            return (
+                "unable_to_determine",
+                [
+                    *findings,
+                    {
+                        "code": "correction_mapping_state_inconsistent",
+                        "message": (
+                            "The correction package contains Codex-effective mappings "
+                            "that are absent from its pinned database state."
+                        ),
+                        "status": "unable_to_determine",
+                    },
+                ],
+                False,
+                None,
+            )
+    report_state = {
+        "approved": "correct",
+        "approved_with_caveats": "correct_with_caveats",
+        "rejected": "incorrect",
+        "unable_to_determine": "unable_to_determine",
+    }[state]
+    if report_state == "correct" and any(
+        item.get("status") == "caveat" for item in findings
+    ):
+        report_state = "correct_with_caveats"
+    validation = {
+        **validation,
+        "server_acceptance_status": acceptance_status,
+        "variant_attribute_cells_skipped": skipped_variants,
+        "include_resolved": include_resolved,
+        "resolved_attribute_cells": resolved_attribute_cells,
+        "correction_selection": correction_counts or None,
+    }
+    return report_state, findings, True, validation
+
+
+def _browser_qa_state(
+    output_dir: Path,
+    *,
+    render_manifest: Mapping[str, Any],
+) -> tuple[str, list[dict[str, str]], bool, dict[str, Any] | None]:
+    """Validate mechanically measured browser QA without judging report meaning."""
+
+    intake_path = output_dir / "run_intake.json"
+    intake = _load_json(intake_path) if intake_path.is_file() else {}
+    quality_gates = intake.get("quality_gates")
+    required = bool(
+        isinstance(quality_gates, dict)
+        and quality_gates.get("browser_qa_required") is True
+    )
+    qa_path = output_dir / "browser_qa.json"
+    if not qa_path.is_file():
+        if not required:
+            return "not_applicable", [], True, None
+        return (
+            "unable_to_determine",
+            [
+                {
+                    "code": "browser_qa_missing",
+                    "message": (
+                        "Required desktop/mobile browser QA has not been recorded."
+                    ),
+                    "status": "unable_to_determine",
+                }
+            ],
+            False,
+            None,
+        )
+    qa = _load_json(qa_path)
+    if qa.get("schema_version") != "attribute_reporting.browser_qa.v1":
+        return (
+            "unable_to_determine",
+            [
+                {
+                    "code": "browser_qa_invalid",
+                    "message": "Browser QA uses an unsupported schema.",
+                    "status": "unable_to_determine",
+                }
+            ],
+            False,
+            qa,
+        )
+    targets = qa.get("targets")
+    expected_targets = {
+        "draft_html_sha256": str(render_manifest.get("draft_html_sha256") or ""),
+        "render_manifest_sha256": _sha256_file(output_dir / "render_manifest.json"),
+    }
+    if not isinstance(targets, dict) or any(
+        str(targets.get(key) or "") != value for key, value in expected_targets.items()
+    ):
+        return (
+            "unable_to_determine",
+            [
+                {
+                    "code": "browser_qa_stale",
+                    "message": "Browser QA targets a different rendered report draft.",
+                    "status": "unable_to_determine",
+                }
+            ],
+            False,
+            qa,
+        )
+    status = str(qa.get("status") or "")
+    raw_findings = qa.get("findings")
+    if status not in {"pass", "fail", "blocked"} or not isinstance(raw_findings, list):
+        return (
+            "unable_to_determine",
+            [
+                {
+                    "code": "browser_qa_invalid",
+                    "message": "Browser QA has an invalid status or findings list.",
+                    "status": "unable_to_determine",
+                }
+            ],
+            False,
+            qa,
+        )
+    if status != "blocked":
+        raw_viewports = qa.get("viewports")
+        expected_viewports = {
+            "desktop": (1440, 1000),
+            "mobile": (390, 844),
+        }
+        expected_suffixes = {
+            "horizontal_overflow",
+            "local_images",
+            "asset_locality",
+            "table_scrolling",
+            "required_elements",
+            "product_links",
+            "runtime",
+        }
+        if not isinstance(raw_viewports, list) or len(raw_viewports) != len(
+            expected_viewports
+        ):
+            return (
+                "unable_to_determine",
+                [
+                    {
+                        "code": "browser_qa_invalid",
+                        "message": "Browser QA must cover desktop and mobile exactly once.",
+                        "status": "unable_to_determine",
+                    }
+                ],
+                False,
+                qa,
+            )
+        observed_names: set[str] = set()
+        flattened_findings: list[dict[str, Any]] = []
+        for viewport in raw_viewports:
+            if not isinstance(viewport, dict):
+                return (
+                    "unable_to_determine",
+                    [
+                        {
+                            "code": "browser_qa_invalid",
+                            "message": "Browser QA viewport evidence is invalid.",
+                            "status": "unable_to_determine",
+                        }
+                    ],
+                    False,
+                    qa,
+                )
+            name = str(viewport.get("name") or "")
+            expected_size = expected_viewports.get(name)
+            viewport_findings = viewport.get("findings")
+            metrics = viewport.get("metrics")
+            screenshot_value = str(viewport.get("screenshot") or "")
+            screenshot_sha = str(viewport.get("screenshot_sha256") or "")
+            try:
+                screenshot_relative = _safe_relative_path(
+                    screenshot_value,
+                    label="browser QA screenshot",
+                )
+            except ContractError:
+                screenshot_relative = Path(".")
+            screenshot_path = (output_dir / screenshot_relative).resolve()
+            expected_codes = {
+                f"browser.{name}.{suffix}" for suffix in expected_suffixes
+            }
+            actual_codes = {
+                str(item.get("code") or "")
+                for item in viewport_findings or []
+                if isinstance(item, dict)
+            }
+            if (
+                expected_size is None
+                or name in observed_names
+                or (viewport.get("width"), viewport.get("height")) != expected_size
+                or not isinstance(metrics, dict)
+                or not isinstance(viewport_findings, list)
+                or actual_codes != expected_codes
+                or len(actual_codes) != len(viewport_findings)
+                or not screenshot_path.is_relative_to(output_dir.resolve())
+                or not screenshot_path.is_file()
+                or not re.fullmatch(r"[0-9a-f]{64}", screenshot_sha)
+                or _sha256_file(screenshot_path) != screenshot_sha
+            ):
+                return (
+                    "unable_to_determine",
+                    [
+                        {
+                            "code": "browser_qa_invalid",
+                            "message": "Browser QA viewport evidence or screenshot is incomplete.",
+                            "status": "unable_to_determine",
+                        }
+                    ],
+                    False,
+                    qa,
+                )
+            for item in viewport_findings:
+                if (
+                    not isinstance(item, dict)
+                    or item.get("status") not in {"pass", "fail"}
+                    or not str(item.get("message") or "").strip()
+                ):
+                    return (
+                        "unable_to_determine",
+                        [
+                            {
+                                "code": "browser_qa_invalid",
+                                "message": "Browser QA contains an invalid viewport finding.",
+                                "status": "unable_to_determine",
+                            }
+                        ],
+                        False,
+                        qa,
+                    )
+            observed_names.add(name)
+            flattened_findings.extend(viewport_findings)
+        if (
+            observed_names != set(expected_viewports)
+            or flattened_findings != raw_findings
+        ):
+            return (
+                "unable_to_determine",
+                [
+                    {
+                        "code": "browser_qa_invalid",
+                        "message": "Browser QA findings do not match its viewport evidence.",
+                        "status": "unable_to_determine",
+                    }
+                ],
+                False,
+                qa,
+            )
+        expected_status = (
+            "fail"
+            if any(item.get("status") == "fail" for item in raw_findings)
+            else "pass"
+        )
+        if status != expected_status or str(qa.get("browser_error") or ""):
+            return (
+                "unable_to_determine",
+                [
+                    {
+                        "code": "browser_qa_invalid",
+                        "message": "Browser QA status does not match its findings.",
+                        "status": "unable_to_determine",
+                    }
+                ],
+                False,
+                qa,
+            )
+    findings: list[dict[str, str]] = []
+    for item in raw_findings:
+        if not isinstance(item, dict) or item.get("status") not in {"pass", "fail"}:
+            return (
+                "unable_to_determine",
+                [
+                    {
+                        "code": "browser_qa_invalid",
+                        "message": "Browser QA contains an invalid finding.",
+                        "status": "unable_to_determine",
+                    }
+                ],
+                False,
+                qa,
+            )
+        if item.get("status") == "fail":
+            findings.append(
+                {
+                    "code": str(item.get("code") or "browser_qa_failure"),
+                    "message": str(item.get("message") or "Browser QA failed."),
+                    "status": "fail",
+                }
+            )
+    if status == "blocked":
+        return (
+            "unable_to_determine",
+            [
+                {
+                    "code": "browser_qa_blocked",
+                    "message": str(
+                        qa.get("browser_error")
+                        or "The browser runtime was unavailable for report QA."
+                    ),
+                    "status": "unable_to_determine",
+                }
+            ],
+            False,
+            qa,
+        )
+    if status == "fail" or findings:
+        return "incorrect", findings, True, qa
+    return "correct", [], True, qa
+
+
+def _verdict_banner(
+    verdict: str,
+    summary: str,
+    details: Sequence[Mapping[str, str]],
+    language: str = "en",
+) -> str:
+    marks = {
+        "correct": "✓",
+        "correct_with_caveats": "!",
+        "incorrect": "×",
+        "unable_to_determine": "?",
+    }
+    detail_html = ""
+    if details:
+        detail_html = (
+            '<ul class="verdict-details">'
+            + "".join(
+                f"<li>{html.escape(_display(str(item['message']), language))}</li>"
+                for item in details
+            )
+            + "</ul>"
+        )
+    return (
+        f'<aside class="verdict {verdict}" data-correctness-verdict="{verdict}">'
+        f'<span class="mark">{marks[verdict]}</span><div><strong>{html.escape(_display(VERDICT_LABELS[verdict], language))}</strong>'
+        f"<span>{html.escape(_display(summary, language))}</span>{detail_html}</div></aside>"
+    )
+
+
+def _write_run_review(
+    output_dir: Path,
+    *,
+    verdict: str,
+    correctness: Mapping[str, Any],
+    language: str = "en",
+) -> None:
+    mechanical = correctness.get("mechanical_findings") or []
+    mapping = correctness.get("mapping_findings") or []
+    browser = correctness.get("browser_findings") or []
+    semantic = correctness.get("semantic_findings") or []
+    caveats = correctness.get("caveats") or []
+    lines = [
+        "# " + _display("Attribute Report Run Review", language),
+        "",
+        f"**{_display('Correctness verdict:', language)}** {_display(VERDICT_LABELS[verdict], language)}",
+        "",
+        "## " + _display("Artifact Card", language),
+        "",
+        f"| {_display('Artifact', language)} | {_display('Purpose', language)} | {_display('Review status', language)} |",
+        "| --- | --- | --- |",
+        f"| `report.html` | {_display('Final private local HTML report', language)} | {_display(VERDICT_LABELS[verdict], language)} |",
+        f"| `correctness_verdict.json` | {_display('Machine-readable direct verdict and basis', language)} | {_display('Written', language)} |",
+        f"| `claim_ledger.json` | {_display('Bound claims and source rows', language)} | {correctness['basis']['mechanical_claims']} |",
+        (
+            f"| `mapping_review.json` | {_display('Independent semantic mapping review', language)} | "
+            f"{str(correctness.get('basis', {}).get('mapping_review') or 'not_applicable')} |"
+        ),
+        (
+            f"| `browser_qa.json` | {_display('Desktop/mobile mechanical browser QA', language)} | "
+            f"{str(correctness.get('basis', {}).get('browser_qa') or 'not_applicable')} |"
+        ),
+        f"| `semantic_review.json` | {_display('Independent Codex semantic review', language)} | {correctness['basis']['semantic_review']} |",
+        "",
+        "## " + _display("Findings", language),
+        "",
+    ]
+    if not mechanical and not mapping and not browser and not semantic and not caveats:
+        lines.append(_display("No blocking mechanical or semantic findings.", language))
+    else:
+        for item in [*mechanical, *mapping, *browser, *semantic]:
+            lines.append(f"- `{item['code']}` — {_display(item['message'], language)}")
+        finding_codes = {item["code"] for item in [*mapping, *browser, *semantic]}
+        for item in caveats:
+            if item["code"] not in finding_codes:
+                lines.append(
+                    f"- `{item['code']}` — {_display(item['message'], language)}"
+                )
+    lines.extend(
+        [
+            "",
+            "## " + _display("Privacy", language),
+            "",
+            _display(
+                "The HTML report, report semantic review, browser QA, and correctness "
+                "artifacts remain in this local output folder and were not uploaded. "
+                "Only approved structured mapping artifacts may have crossed the "
+                "authenticated server boundary.",
+                language,
+            ),
+            "",
+        ]
+    )
+    (output_dir / "codex_run_review.md").write_text("\n".join(lines), encoding="utf-8")
+
+
+def _attribute_table_final_outputs(
+    output_dir: Path,
+    catalog: Mapping[str, Any],
+) -> list[dict[str, Any]]:
+    """Return existing deterministic table artifacts for final handoff."""
+
+    outputs: list[dict[str, Any]] = []
+    manifest_path = output_dir / "evidence" / "attribute_tables" / "manifest.json"
+    if manifest_path.is_file():
+        outputs.append(
+            {
+                "path": "evidence/attribute_tables/manifest.json",
+                "kind": "json",
+                "sha256": _sha256_file(manifest_path),
+                "status": "written",
+                "artifact_role": "attribute_table_manifest",
+            }
+        )
+    for item in catalog.get("attribute_tables") or []:
+        if not isinstance(item, dict):
+            continue
+        table_key = str(item.get("table_key") or "").strip()
+        for field, kind in (("csv", "csv"), ("html", "html")):
+            raw_relative = str(item.get(field) or "").strip()
+            if not raw_relative:
+                continue
+            relative = _safe_relative_path(
+                raw_relative,
+                label=f"attribute table {kind}",
+            )
+            path = output_dir / "evidence" / relative
+            if not path.is_file():
+                continue
+            outputs.append(
+                {
+                    "path": f"evidence/{relative.as_posix()}",
+                    "kind": kind,
+                    "sha256": _sha256_file(path),
+                    "status": "written",
+                    "artifact_role": "attribute_table",
+                    "table_key": table_key,
+                }
+            )
+    return outputs
+
+
+def finalize_report(output_dir: Path) -> dict[str, Any]:
+    """Combine mechanical checks and independent Codex review into a direct verdict."""
+
+    output = _assert_safe_output_dir(output_dir)
+    catalog = _load_json(output / "evidence_catalog.json")
+    model = _load_json(output / "report_model.json")
+    render_manifest = _load_json(output / "render_manifest.json")
+    claim_ledger = _load_json(output / "claim_ledger.json")
+    review = _load_json(output / "semantic_review.json")
+    draft_path = output / str(render_manifest.get("draft_html") or "report_draft.html")
+    try:
+        draft = draft_path.read_text(encoding="utf-8")
+    except FileNotFoundError as exc:
+        raise ContractError(f"Rendered HTML draft is missing: {draft_path}") from exc
+    if "<!-- ATTRIBUTE_REPORTING_VERDICT -->" not in draft:
+        raise ContractError("Rendered HTML draft has no correctness verdict slot")
+
+    mechanical = _mechanical_findings(
+        output_dir=output,
+        catalog=catalog,
+        model=model,
+        render_manifest=render_manifest,
+        claim_ledger=claim_ledger,
+        draft=draft,
+    )
+    semantic_state, semantic_findings, semantic_complete = _semantic_review_state(
+        review,
+        model=model,
+        render_manifest=render_manifest,
+    )
+    mapping_state, mapping_findings, mapping_complete, mapping_validation = (
+        _mapping_review_state(output)
+    )
+    browser_state, browser_findings, browser_complete, browser_validation = (
+        _browser_qa_state(output, render_manifest=render_manifest)
+    )
+    active_warnings = [
+        str(item.get("code"))
+        for item in catalog.get("warnings") or []
+        if isinstance(item, dict)
+    ]
+    warning_caveats = [
+        {
+            "code": str(item.get("code") or "package_warning"),
+            "message": str(item.get("message") or "Active package warning."),
+            "status": "caveat",
+        }
+        for item in catalog.get("warnings") or []
+        if isinstance(item, dict)
+    ]
+    caveats = list(warning_caveats)
+    caveat_codes = {item["code"] for item in caveats}
+    caveats.extend(
+        item
+        for item in semantic_findings
+        if item.get("status") == "caveat" and item.get("code") not in caveat_codes
+    )
+    caveat_codes = {item["code"] for item in caveats}
+    caveats.extend(
+        item
+        for item in mapping_findings
+        if item.get("status") == "caveat" and item.get("code") not in caveat_codes
+    )
+    if mechanical:
+        verdict = "incorrect"
+        verdict_summary = (
+            "Mechanical evidence, integrity, or HTML parity checks failed."
+        )
+    elif browser_state == "incorrect":
+        verdict = "incorrect"
+        verdict_summary = (
+            "Desktop or mobile browser QA found a broken report presentation."
+        )
+    elif mapping_state == "incorrect":
+        verdict = "incorrect"
+        verdict_summary = (
+            "Independent semantic mapping review rejected one or more product mappings."
+        )
+    elif semantic_state == "incorrect":
+        verdict = "incorrect"
+        verdict_summary = "Independent semantic review found unsupported or misleading report content."
+    elif not mapping_complete or mapping_state == "unable_to_determine":
+        verdict = "unable_to_determine"
+        verdict_summary = (
+            "The mappings used in this run lack a complete, current independent review."
+        )
+    elif not browser_complete or browser_state == "unable_to_determine":
+        verdict = "unable_to_determine"
+        verdict_summary = "Required desktop/mobile browser QA is incomplete or stale."
+    elif not semantic_complete or semantic_state == "unable_to_determine":
+        verdict = "unable_to_determine"
+        verdict_summary = "An independent semantic review is incomplete or cannot support a conclusion."
+    elif (
+        mapping_state == "correct_with_caveats"
+        or semantic_state == "correct_with_caveats"
+        or active_warnings
+        or caveats
+    ):
+        verdict = "correct_with_caveats"
+        verdict_summary = "The report is supported, with disclosed evidence or interpretation caveats."
+    else:
+        verdict = "correct"
+        verdict_summary = (
+            "Mechanical checks pass, required browser QA passes, and independent "
+            "semantic review supports every claim."
+        )
+
+    detail_candidates: Sequence[Mapping[str, str]] = caveats
+    if verdict in {"incorrect", "unable_to_determine"}:
+        detail_candidates = [
+            *mechanical,
+            *mapping_findings,
+            *browser_findings,
+            *semantic_findings,
+            *caveats,
+        ]
+    verdict_details: list[Mapping[str, str]] = []
+    seen_detail_messages: set[str] = set()
+    for item in detail_candidates:
+        message = str(item.get("message") or "").strip()
+        if not message or message in seen_detail_messages:
+            continue
+        verdict_details.append(item)
+        seen_detail_messages.add(message)
+
+    correctness = {
+        "schema_version": VERDICT_SCHEMA,
+        "checked_at": _utc_now(),
+        "report_id": model.get("report_id"),
+        "verdict": verdict,
+        "label": VERDICT_LABELS[verdict],
+        "summary": verdict_summary,
+        "basis": {
+            "package_integrity": (
+                "pass"
+                if not any(
+                    item["code"].startswith(
+                        ("catalog_", "package_", "source_", "render_package_")
+                    )
+                    for item in mechanical
+                )
+                else "fail"
+            ),
+            "mechanical_claims": "pass" if not mechanical else "fail",
+            "html_parity": (
+                "pass"
+                if not any(
+                    item["code"].startswith(("html_", "draft_", "external_"))
+                    for item in mechanical
+                )
+                else "fail"
+            ),
+            "mapping_review": mapping_state,
+            "browser_qa": browser_state,
+            "semantic_review": semantic_state,
+        },
+        "mechanical_findings": mechanical,
+        "mapping_findings": mapping_findings,
+        "browser_findings": browser_findings,
+        "semantic_findings": semantic_findings,
+        "mapping_review_summary": (
+            str(mapping_validation.get("summary") or "")
+            if mapping_validation is not None
+            else ""
+        ),
+        "semantic_review_summary": str(review.get("summary") or ""),
+        "caveats": caveats,
+        "active_warning_codes": active_warnings,
+        "report_model_sha256": render_manifest.get("report_model_sha256"),
+        "draft_html_sha256": render_manifest.get("draft_html_sha256"),
+        "mapping_review_sha256": (
+            mapping_validation.get("mapping_review_sha256")
+            if mapping_validation is not None
+            else None
+        ),
+        "mapping_review_validation_sha256": (
+            mapping_validation.get("review_validation_sha256")
+            if mapping_validation is not None
+            else None
+        ),
+        "browser_qa_sha256": (
+            _canonical_json_sha256(browser_validation)
+            if browser_validation is not None
+            else None
+        ),
+        "semantic_review_sha256": _canonical_json_sha256(review),
+    }
+    _write_json(output / "correctness_verdict.json", correctness)
+    final_html = draft.replace(
+        _verdict_placeholder(_report_language(model.get("language", "en"))),
+        _verdict_banner(
+            verdict,
+            verdict_summary,
+            verdict_details,
+            _report_language(model.get("language", "en")),
+        ),
+        1,
+    )
+    final_path = output / "report.html"
+    final_path.write_text(final_html, encoding="utf-8")
+    final_sha = _sha256_file(final_path)
+    _write_run_review(
+        output,
+        verdict=verdict,
+        correctness=correctness,
+        language=_report_language(model.get("language", "en")),
+    )
+    status = (
+        "final_ready"
+        if verdict in {"correct", "correct_with_caveats"}
+        else "not_ready" if verdict == "incorrect" else "partial"
+    )
+    artifact_outputs = [
+        {
+            "path": "report.html",
+            "kind": "html",
+            "sha256": final_sha,
+            "status": "written",
+        },
+        {
+            "path": "correctness_verdict.json",
+            "kind": "json",
+            "sha256": _sha256_file(output / "correctness_verdict.json"),
+            "status": "written",
+        },
+        {
+            "path": "codex_run_review.md",
+            "kind": "markdown",
+            "sha256": _sha256_file(output / "codex_run_review.md"),
+            "status": "written",
+        },
+    ]
+    if (output / "browser_qa.json").is_file():
+        artifact_outputs.append(
+            {
+                "path": "browser_qa.json",
+                "kind": "json",
+                "sha256": _sha256_file(output / "browser_qa.json"),
+                "status": "checked",
+            }
+        )
+    artifact_outputs.extend(_attribute_table_final_outputs(output, catalog))
+    final_artifacts = {
+        "schema_version": "attribute_reporting.final_artifacts.v1",
+        "status": status,
+        "report_id": model.get("report_id"),
+        "correctness_verdict": verdict,
+        "privacy": {
+            "storage": "private_local_only",
+            "uploaded_to_server": False,
+        },
+        "outputs": artifact_outputs,
+    }
+    _write_json(output / "final_artifacts.json", final_artifacts)
+    return correctness
+
+
+def validate_mapping_payloads(
+    tasks: Mapping[str, Any],
+    decisions: Mapping[str, Any],
+    *,
+    taxonomy: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Validate and normalize mapping payloads without writing them."""
+
+    if tasks.get("schema_version") != MAPPING_TASK_SCHEMA:
+        raise ContractError("Unsupported mapping task schema")
+    if decisions.get("schema_version") != MAPPING_DECISION_SCHEMA:
+        raise ContractError("Unsupported mapping decision schema")
+    task_taxonomy = tasks.get("taxonomy_snapshot")
+    decision_taxonomy = decisions.get("taxonomy_snapshot")
+    if not isinstance(task_taxonomy, dict) or not isinstance(decision_taxonomy, dict):
+        raise ContractError("Mapping artifacts require taxonomy_snapshot objects")
+    for field in ("version", "sha256"):
+        if not str(task_taxonomy.get(field) or "").strip():
+            raise ContractError(f"Mapping task taxonomy snapshot requires {field}")
+        if decision_taxonomy.get(field) != task_taxonomy.get(field):
+            raise ContractError(
+                f"Mapping decisions target a different taxonomy {field}"
+            )
+    taxonomy_attributes: dict[tuple[str, str], Mapping[str, Any]] = {}
+    if taxonomy is not None:
+        if str(taxonomy.get("version") or "") != str(
+            task_taxonomy["version"]
+        ) or _canonical_json_sha256(taxonomy) != str(task_taxonomy["sha256"]):
+            raise ContractError(
+                "Mapping tasks do not target the current central taxonomy"
+            )
+        for category in taxonomy.get("categories") or []:
+            if not isinstance(category, dict):
+                continue
+            category_id = _normalise_mapping_token(category.get("id"))
+            for attribute in category.get("attributes") or []:
+                if not isinstance(attribute, dict):
+                    continue
+                attribute_id = str(attribute.get("id") or "").strip()
+                if category_id and attribute_id:
+                    taxonomy_attributes[(category_id, attribute_id)] = attribute
+    agent = decisions.get("agent")
+    if not isinstance(agent, dict) or agent.get("execution") != "codex_agent":
+        raise ContractError("Mapping decisions must be authored by a Codex agent")
+    if not str(agent.get("agent_id") or "").strip():
+        raise ContractError("Mapping decision agent_id is required")
+
+    raw_tasks = tasks.get("tasks")
+    raw_decisions = decisions.get("decisions")
+    if not isinstance(raw_tasks, list) or not isinstance(raw_decisions, list):
+        raise ContractError("Mapping tasks and decisions must be lists")
+    task_by_id: dict[str, Mapping[str, Any]] = {}
+    task_scope = tasks.get("scope") if isinstance(tasks.get("scope"), dict) else {}
+    scoped_retailer = str(task_scope.get("retailer") or "").strip()
+    scoped_category = str(task_scope.get("category_key") or "").strip()
+    snapshot_category = str(task_taxonomy.get("category_key") or "").strip()
+    for task in raw_tasks:
+        if not isinstance(task, dict):
+            raise ContractError("Each mapping task must be an object")
+        task_id = str(task.get("task_id") or "")
+        if not SAFE_ID_RE.fullmatch(task_id) or task_id in task_by_id:
+            raise ContractError(f"Invalid or duplicate mapping task id: {task_id!r}")
+        product = task.get("product")
+        if not isinstance(product, dict):
+            raise ContractError(f"Mapping task {task_id} has no product object")
+        row_type = str(product.get("row_type") or "parent")
+        required_product_fields = (
+            "retailer",
+            "parent_product_id",
+            "category_key",
+        )
+        if row_type not in {"parent", "variant"} or any(
+            not str(product.get(field) or "").strip()
+            for field in required_product_fields
+        ):
+            raise ContractError(
+                f"Mapping task {task_id} has an incomplete product identity"
+            )
+        if row_type == "variant" and not str(product.get("variant_id") or "").strip():
+            raise ContractError(f"Variant mapping task {task_id} requires variant_id")
+        if (
+            (scoped_retailer and product.get("retailer") != scoped_retailer)
+            or (scoped_category and product.get("category_key") != scoped_category)
+            or (snapshot_category and product.get("category_key") != snapshot_category)
+        ):
+            raise ContractError(
+                f"Mapping task {task_id} falls outside its pinned scope"
+            )
+        attribute = task.get("attribute")
+        if not isinstance(attribute, dict) or not isinstance(
+            attribute.get("allowed_values"), list
+        ):
+            raise ContractError(
+                f"Mapping task {task_id} has no allowed taxonomy values"
+            )
+        attribute_id = str(attribute.get("id") or "").strip()
+        attribute_label = str(attribute.get("label") or "").strip()
+        selection = str(attribute.get("selection") or "single").casefold()
+        if (
+            not attribute_id
+            or not attribute_label
+            or selection
+            not in {
+                "single",
+                "multi",
+            }
+        ):
+            raise ContractError(
+                f"Mapping task {task_id} has invalid attribute metadata"
+            )
+        expected_task_id = _mapping_task_id(
+            str(product["retailer"]),
+            str(product["category_key"]),
+            row_type,
+            str(product["parent_product_id"]),
+            str(product.get("variant_id") or ""),
+            attribute_id,
+        )
+        if task_id != expected_task_id:
+            raise ContractError(
+                f"Mapping task {task_id} does not match its product and attribute identity"
+            )
+        if not re.fullmatch(
+            r"[0-9a-f]{64}", str(product.get("source_row_sha256") or "")
+        ):
+            raise ContractError(
+                f"Mapping task {task_id} requires a source-row checksum"
+            )
+        allowed_ids: set[str] = set()
+        for value in attribute["allowed_values"]:
+            if not isinstance(value, dict):
+                raise ContractError(
+                    f"Mapping task {task_id} has an invalid allowed value"
+                )
+            value_id = str(value.get("id") or "").strip()
+            value_label = str(value.get("label") or "").strip()
+            if not value_id or not value_label or value_id in allowed_ids:
+                raise ContractError(
+                    f"Mapping task {task_id} has empty or duplicate allowed values"
+                )
+            allowed_ids.add(value_id)
+        if not allowed_ids:
+            raise ContractError(
+                f"Mapping task {task_id} has no allowed taxonomy values"
+            )
+        if taxonomy is not None:
+            taxonomy_attribute = taxonomy_attributes.get(
+                (
+                    _normalise_mapping_token(product.get("category_key")),
+                    attribute_id,
+                )
+            )
+            if taxonomy_attribute is None:
+                raise ContractError(
+                    f"Mapping task {task_id} attribute is absent from the current taxonomy"
+                )
+            expected_values = _taxonomy_leaf_values(taxonomy_attribute.get("nodes"))
+            if str(
+                taxonomy_attribute.get("selection") or "single"
+            ).casefold() != selection or expected_values != list(
+                attribute["allowed_values"]
+            ):
+                raise ContractError(
+                    f"Mapping task {task_id} allowed values differ from the current taxonomy"
+                )
+        task_by_id[task_id] = task
+
+    decision_by_id: dict[str, Mapping[str, Any]] = {}
+    selected_values_by_id: dict[str, tuple[list[str], list[str]]] = {}
+    for decision in raw_decisions:
+        if not isinstance(decision, dict):
+            raise ContractError("Each mapping decision must be an object")
+        task_id = str(decision.get("task_id") or "")
+        if task_id not in task_by_id or task_id in decision_by_id:
+            raise ContractError(
+                f"Unknown or duplicate mapping decision task id: {task_id!r}"
+            )
+        status = str(decision.get("status") or "")
+        if status not in {"mapped", "no_value", "oov_candidate", "unable_to_determine"}:
+            raise ContractError(
+                f"Mapping decision {task_id} has invalid status {status!r}"
+            )
+        if decision.get("confidence") not in {"high", "medium", "low"}:
+            raise ContractError(f"Mapping decision {task_id} requires a confidence")
+        if not str(decision.get("reason") or "").strip():
+            raise ContractError(f"Mapping decision {task_id} requires a reason")
+        task = task_by_id[task_id]
+        allowed_values = {
+            str(item.get("id")): str(item.get("label") or "")
+            for item in task["attribute"]["allowed_values"]
+            if isinstance(item, dict) and str(item.get("id") or "").strip()
+        }
+        selection = str(task["attribute"].get("selection") or "single").casefold()
+        raw_value_ids = decision.get("value_ids")
+        raw_value_labels = decision.get("value_labels")
+        if raw_value_ids is None and raw_value_labels is None:
+            value_id = str(decision.get("value_id") or "")
+            value_label = str(decision.get("value_label") or "")
+            value_ids = [value_id] if value_id else []
+            value_labels = [value_label] if value_label else []
+        elif isinstance(raw_value_ids, list) and isinstance(raw_value_labels, list):
+            value_ids = [str(value or "").strip() for value in raw_value_ids]
+            value_labels = [str(value or "").strip() for value in raw_value_labels]
+        else:
+            raise ContractError(
+                f"Mapping decision {task_id} must set value_ids and value_labels together"
+            )
+        if status == "mapped":
+            if (
+                not value_ids
+                or len(value_ids) != len(value_labels)
+                or len(value_ids) != len(set(value_ids))
+                or (selection == "single" and len(value_ids) != 1)
+                or any(
+                    value_id not in allowed_values
+                    or value_label != allowed_values[value_id]
+                    for value_id, value_label in zip(value_ids, value_labels)
+                )
+            ):
+                raise ContractError(
+                    f"Mapping decision {task_id} is not an exact value from the pinned taxonomy"
+                )
+            selected = set(value_ids)
+            value_ids = [
+                value_id for value_id in allowed_values if value_id in selected
+            ]
+            value_labels = [allowed_values[value_id] for value_id in value_ids]
+        elif (
+            value_ids
+            or value_labels
+            or str(decision.get("value_id") or "")
+            or str(decision.get("value_label") or "")
+        ):
+            raise ContractError(
+                f"Non-mapped decision {task_id} cannot set a taxonomy value"
+            )
+        if (
+            status == "oov_candidate"
+            and not str(decision.get("oov_candidate") or "").strip()
+        ):
+            raise ContractError(
+                f"OOV mapping decision {task_id} requires oov_candidate"
+            )
+        decision_by_id[task_id] = decision
+        selected_values_by_id[task_id] = (value_ids, value_labels)
+    if set(decision_by_id) != set(task_by_id):
+        missing = sorted(set(task_by_id) - set(decision_by_id))
+        raise ContractError(
+            f"Mapping decisions do not cover every task: missing={missing}"
+        )
+
+    validated_rows = []
+    for task_id, task in task_by_id.items():
+        decision = decision_by_id[task_id]
+        product = task.get("product") if isinstance(task.get("product"), dict) else {}
+        attribute = task["attribute"]
+        value_ids, value_labels = selected_values_by_id[task_id]
+        selection = str(attribute.get("selection") or "single").casefold()
+        validated_rows.append(
+            {
+                "task_id": task_id,
+                "retailer": product.get("retailer"),
+                "row_type": product.get("row_type", "parent"),
+                "parent_product_id": product.get("parent_product_id"),
+                "variant_id": product.get("variant_id", ""),
+                "category_key": product.get("category_key"),
+                "attribute_id": attribute.get("id"),
+                "attribute_label": attribute.get("label"),
+                "selection": selection,
+                "allowed_values": list(attribute["allowed_values"]),
+                "status": decision.get("status"),
+                "value_ids": value_ids,
+                "value_labels": value_labels,
+                "value_id": (
+                    value_ids[0] if selection == "single" and value_ids else None
+                ),
+                "value_label": (
+                    value_labels[0] if selection == "single" and value_labels else None
+                ),
+                "oov_candidate": decision.get("oov_candidate"),
+                "reason": decision.get("reason"),
+                "confidence": decision.get("confidence"),
+                "source": "codex",
+                "taxonomy_version": task_taxonomy["version"],
+                "taxonomy_sha256": task_taxonomy["sha256"],
+            }
+        )
+    stable_validation = {
+        "schema_version": "attribute_reporting.validated_mapping_decisions.v1",
+        "taxonomy_snapshot": dict(task_taxonomy),
+        "agent": dict(agent),
+        "tasks_sha256": _canonical_json_sha256(dict(tasks)),
+        "decisions_sha256": _canonical_json_sha256(dict(decisions)),
+        "status": "valid",
+        "mapping_count": len(validated_rows),
+        "mappings": validated_rows,
+    }
+    validated = {
+        **stable_validation,
+        "validated_at": _utc_now(),
+        "validation_sha256": _canonical_json_sha256(stable_validation),
+    }
+    return validated
+
+
+def validate_mapping_decisions(
+    tasks_path: Path,
+    decisions_path: Path,
+    output_path: Path,
+) -> dict[str, Any]:
+    """Validate Codex mapping decisions against a pinned central taxonomy snapshot."""
+
+    tasks = _load_json(tasks_path)
+    decisions = _load_json(decisions_path)
+    validated = validate_mapping_payloads(tasks, decisions)
+    validation_output = output_path.expanduser().resolve()
+    _assert_safe_output_dir(validation_output.parent)
+    _write_json(validation_output, validated)
+    return validated
+
+
+def _stable_mapping_validation(payload: Mapping[str, Any]) -> dict[str, Any]:
+    keys = (
+        "schema_version",
+        "taxonomy_snapshot",
+        "agent",
+        "tasks_sha256",
+        "decisions_sha256",
+        "status",
+        "mapping_count",
+        "mappings",
+    )
+    return {key: payload.get(key) for key in keys}
+
+
+def _verify_validated_mapping_payload(
+    tasks: Mapping[str, Any],
+    decisions: Mapping[str, Any],
+    validated: Mapping[str, Any],
+    *,
+    taxonomy: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Recompute the mechanical mapping contract before trusting its artifact."""
+
+    expected = validate_mapping_payloads(tasks, decisions, taxonomy=taxonomy)
+    if validated.get("schema_version") != VALIDATED_MAPPING_SCHEMA:
+        raise ContractError("Unsupported validated mapping schema")
+    if _stable_mapping_validation(validated) != _stable_mapping_validation(expected):
+        raise ContractError(
+            "Validated mappings do not match the supplied task and decision content"
+        )
+    if validated.get("validation_sha256") != expected["validation_sha256"]:
+        raise ContractError("Validated mapping checksum does not match")
+    return expected
+
+
+def _mapping_review_targets(
+    tasks: Mapping[str, Any],
+    decisions: Mapping[str, Any],
+    validated: Mapping[str, Any],
+    expected: Mapping[str, Any],
+) -> tuple[dict[str, Any], dict[str, dict[str, Any]]]:
+    raw_tasks = tasks.get("tasks")
+    raw_decisions = decisions.get("decisions")
+    raw_mappings = validated.get("mappings")
+    if not all(
+        isinstance(items, list) for items in (raw_tasks, raw_decisions, raw_mappings)
+    ):
+        raise ContractError(
+            "Mapping review inputs require task, decision, and mapping lists"
+        )
+    task_by_id = {
+        str(item.get("task_id")): item for item in raw_tasks if isinstance(item, dict)
+    }
+    decision_by_id = {
+        str(item.get("task_id")): item
+        for item in raw_decisions
+        if isinstance(item, dict)
+    }
+    mapping_by_id = {
+        str(item.get("task_id")): item
+        for item in raw_mappings
+        if isinstance(item, dict)
+    }
+    task_ids = [
+        str(item.get("task_id")) for item in raw_tasks if isinstance(item, dict)
+    ]
+    if not (
+        len(task_ids) == len(task_by_id)
+        and set(task_by_id) == set(decision_by_id) == set(mapping_by_id)
+    ):
+        raise ContractError(
+            "Mapping review inputs do not share one exact task identity set"
+        )
+    author = expected.get("agent")
+    mapping_coordinator_id = (
+        str(author.get("agent_id") or "").strip() if isinstance(author, dict) else ""
+    )
+    if not SAFE_ID_RE.fullmatch(mapping_coordinator_id):
+        raise ContractError("Mapping author agent_id is missing or invalid")
+
+    global_targets = {
+        "taxonomy_snapshot": dict(expected["taxonomy_snapshot"]),
+        "tasks_sha256": str(expected["tasks_sha256"]),
+        "decisions_sha256": str(expected["decisions_sha256"]),
+        "validated_mappings_sha256": _canonical_json_sha256(dict(validated)),
+        "validation_sha256": str(expected["validation_sha256"]),
+        "mapping_content_sha256": _canonical_json_sha256(
+            {
+                "tasks": list(raw_tasks),
+                "decisions": list(raw_decisions),
+                "mappings": list(raw_mappings),
+            }
+        ),
+    }
+    per_task_targets: dict[str, dict[str, Any]] = {}
+    for task_id in task_ids:
+        task = task_by_id[task_id]
+        decision = decision_by_id[task_id]
+        product = task.get("product") if isinstance(task.get("product"), dict) else {}
+        images = product.get("local_images")
+        if images is None:
+            images = []
+        if not isinstance(images, list):
+            raise ContractError(
+                f"Mapping task {task_id} has invalid local image evidence"
+            )
+        image_sha256s = [
+            str(item.get("sha256") or "") for item in images if isinstance(item, dict)
+        ]
+        if len(image_sha256s) != len(images):
+            raise ContractError(
+                f"Mapping task {task_id} has invalid local image evidence"
+            )
+        contributor_agent_id = str(decision.get("contributor_agent_id") or "").strip()
+        if contributor_agent_id and not SAFE_ID_RE.fullmatch(contributor_agent_id):
+            raise ContractError(
+                f"Mapping task {task_id} has an invalid contributor agent id"
+            )
+        mapping_author_agent_ids = [mapping_coordinator_id]
+        if contributor_agent_id and contributor_agent_id != mapping_coordinator_id:
+            mapping_author_agent_ids.append(contributor_agent_id)
+        mapping_author_agent_ids.sort()
+        per_task_targets[task_id] = {
+            "task_sha256": _canonical_json_sha256(dict(task)),
+            "decision_sha256": _canonical_json_sha256(dict(decision)),
+            "validated_mapping_sha256": _canonical_json_sha256(
+                dict(mapping_by_id[task_id])
+            ),
+            "source_row_sha256": str(product.get("source_row_sha256") or ""),
+            "local_image_sha256s": image_sha256s,
+            "mapping_author_agent_ids": mapping_author_agent_ids,
+        }
+    return global_targets, per_task_targets
+
+
+def create_mapping_review_template(
+    tasks_path: Path,
+    decisions_path: Path,
+    validated_path: Path,
+    output_path: Path,
+    *,
+    reviewer_agent_id: str,
+) -> dict[str, Any]:
+    """Prepare exact pins; an independent Codex reviewer authors the judgments."""
+
+    if not reviewer_agent_id.strip():
+        raise ContractError("Mapping reviewer_agent_id is required")
+    tasks = _load_json(tasks_path)
+    decisions = _load_json(decisions_path)
+    validated = _load_json(validated_path)
+    expected = _verify_validated_mapping_payload(tasks, decisions, validated)
+    author = expected.get("agent")
+    author_agent_id = (
+        str(author.get("agent_id") or "") if isinstance(author, dict) else ""
+    )
+    if reviewer_agent_id == author_agent_id:
+        raise ContractError(
+            "Mapping reviewer must be different from the mapping author"
+        )
+    targets, per_task_targets = _mapping_review_targets(
+        tasks,
+        decisions,
+        validated,
+        expected,
+    )
+    review_id = f"mapping-review-{expected['validation_sha256'][:16]}"
+    review = {
+        "schema_version": MAPPING_REVIEW_SCHEMA,
+        "review_id": review_id,
+        "author_agent_id": author_agent_id,
+        "reviewer": {
+            "execution": "codex_agent",
+            "agent_id": reviewer_agent_id,
+            "role": "independent_mapping_reviewer",
+            "tier": "low_cost",
+            "independent_from_author": True,
+        },
+        "targets": targets,
+        "overall_verdict": "unable_to_determine",
+        "summary": "Independent semantic mapping review has not run.",
+        "task_reviews": [
+            {
+                "task_id": task_id,
+                "targets": task_targets,
+                "verdict": "unable_to_determine",
+                "reason": "This mapping has not been semantically reviewed.",
+            }
+            for task_id, task_targets in per_task_targets.items()
+        ],
+    }
+    review_output = output_path.expanduser().resolve()
+    _assert_safe_output_dir(review_output.parent)
+    _write_json(review_output, review)
+    return review
+
+
+def validate_mapping_review_payloads(
+    tasks: Mapping[str, Any],
+    decisions: Mapping[str, Any],
+    validated: Mapping[str, Any],
+    review: Mapping[str, Any],
+    *,
+    taxonomy: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Enforce review integrity without making semantic mapping judgments.
+
+    Exact hashes, identity separation, and coverage are deterministic because they
+    are mechanically verifiable. The per-task verdicts and reasons remain the
+    independent Codex reviewer's semantic judgment.
+    """
+
+    expected = _verify_validated_mapping_payload(
+        tasks,
+        decisions,
+        validated,
+        taxonomy=taxonomy,
+    )
+    if review.get("schema_version") != MAPPING_REVIEW_SCHEMA:
+        raise ContractError("Unsupported mapping review schema")
+    if not SAFE_ID_RE.fullmatch(str(review.get("review_id") or "")):
+        raise ContractError("Mapping review_id is missing or invalid")
+    author = expected.get("agent")
+    author_agent_id = (
+        str(author.get("agent_id") or "") if isinstance(author, dict) else ""
+    )
+    if review.get("author_agent_id") != author_agent_id:
+        raise ContractError("Mapping review does not identify the mapping author")
+    reviewer = review.get("reviewer")
+    if not isinstance(reviewer, dict) or reviewer.get("execution") != "codex_agent":
+        raise ContractError("Mapping review must be attributed to a Codex agent")
+    reviewer_agent_id = str(reviewer.get("agent_id") or "").strip()
+    if (
+        not reviewer_agent_id
+        or reviewer_agent_id == author_agent_id
+        or reviewer.get("role") != "independent_mapping_reviewer"
+        or reviewer.get("independent_from_author") is not True
+    ):
+        raise ContractError("Mapping reviewer is not independent from the author")
+    if not str(review.get("summary") or "").strip():
+        raise ContractError("Mapping review summary is required")
+
+    expected_targets, per_task_targets = _mapping_review_targets(
+        tasks,
+        decisions,
+        validated,
+        expected,
+    )
+    if review.get("targets") != expected_targets:
+        raise ContractError("Mapping review targets stale or different mapping content")
+    task_reviews = review.get("task_reviews")
+    if not isinstance(task_reviews, list):
+        raise ContractError("Mapping review must contain a task_reviews list")
+    review_by_id: dict[str, Mapping[str, Any]] = {}
+    allowed_verdicts = {
+        "supported",
+        "supported_with_caveat",
+        "unsupported",
+        "unable_to_determine",
+    }
+    for item in task_reviews:
+        if not isinstance(item, dict):
+            raise ContractError("Each mapping task review must be an object")
+        task_id = str(item.get("task_id") or "")
+        if task_id not in per_task_targets or task_id in review_by_id:
+            raise ContractError(
+                f"Unknown or duplicate mapping review task id: {task_id!r}"
+            )
+        if item.get("targets") != per_task_targets[task_id]:
+            raise ContractError(f"Mapping review task {task_id} has stale content pins")
+        task_reviewer_ids = {reviewer_agent_id}
+        contributor_agent_id = str(item.get("contributor_agent_id") or "").strip()
+        if contributor_agent_id:
+            if not SAFE_ID_RE.fullmatch(contributor_agent_id):
+                raise ContractError(
+                    f"Mapping review task {task_id} has an invalid contributor agent id"
+                )
+            task_reviewer_ids.add(contributor_agent_id)
+        mapping_author_agent_ids = set(
+            per_task_targets[task_id]["mapping_author_agent_ids"]
+        )
+        if task_reviewer_ids & mapping_author_agent_ids:
+            raise ContractError(
+                f"Mapping review task {task_id} is not independent from its authors"
+            )
+        if item.get("verdict") not in allowed_verdicts:
+            raise ContractError(f"Mapping review task {task_id} has an invalid verdict")
+        if not str(item.get("reason") or "").strip():
+            raise ContractError(f"Mapping review task {task_id} requires a reason")
+        review_by_id[task_id] = item
+    if set(review_by_id) != set(per_task_targets):
+        missing = sorted(set(per_task_targets) - set(review_by_id))
+        raise ContractError(
+            f"Mapping review must cover every task exactly once: missing={missing}"
+        )
+
+    verdict_counts = {verdict: 0 for verdict in sorted(allowed_verdicts)}
+    for item in review_by_id.values():
+        verdict_counts[str(item["verdict"])] += 1
+    if verdict_counts["unsupported"]:
+        review_state = "rejected"
+    elif verdict_counts["unable_to_determine"]:
+        review_state = "unable_to_determine"
+    elif verdict_counts["supported_with_caveat"]:
+        review_state = "approved_with_caveats"
+    else:
+        review_state = "approved"
+    if review.get("overall_verdict") != review_state:
+        raise ContractError(
+            "Mapping review overall_verdict does not match its per-task verdicts"
+        )
+
+    findings = [
+        {
+            "task_id": task_id,
+            "verdict": str(item["verdict"]),
+            "reason": str(item["reason"]).strip(),
+        }
+        for task_id, item in review_by_id.items()
+        if item.get("verdict") != "supported"
+    ]
+    stable_validation = {
+        "schema_version": MAPPING_REVIEW_VALIDATION_SCHEMA,
+        "status": "valid",
+        "review_state": review_state,
+        "review_id": review.get("review_id"),
+        "author_agent_id": author_agent_id,
+        "reviewer": dict(reviewer),
+        "summary": str(review.get("summary") or "").strip(),
+        "targets": expected_targets,
+        "task_count": len(review_by_id),
+        "task_verdict_counts": verdict_counts,
+        "findings": findings,
+        "mapping_review_sha256": _canonical_json_sha256(dict(review)),
+    }
+    return {
+        **stable_validation,
+        "validated_at": _utc_now(),
+        "review_validation_sha256": _canonical_json_sha256(stable_validation),
+    }
+
+
+def validate_mapping_review(
+    tasks_path: Path,
+    decisions_path: Path,
+    validated_path: Path,
+    review_path: Path,
+    output_path: Path,
+) -> dict[str, Any]:
+    """Validate an independent semantic mapping review and write its receipt."""
+
+    validation = validate_mapping_review_payloads(
+        _load_json(tasks_path),
+        _load_json(decisions_path),
+        _load_json(validated_path),
+        _load_json(review_path),
+    )
+    validation_output = output_path.expanduser().resolve()
+    _assert_safe_output_dir(validation_output.parent)
+    _write_json(validation_output, validation)
+    return validation

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/attribute-reporting/scripts/attribute_reporting.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`