--- before
+++ after
@@ -0,0 +1,3113 @@
+"""Create and validate stable dataset-contract Reporting Engine semantics.
+
+The semantic layer records reviewed business meaning and analysis validity. The
+deterministic code in this module only scaffolds mechanical observations and
+checks contract consistency, snapshot compatibility, and period-rule
+resolution; it never promotes profiler guesses into semantic facts or chooses
+a chart.
+"""
+
+from __future__ import annotations
+
+# Direct CLI calls must select dependencies before importing workflow modules.
+if __name__ == "__main__":
+    import runpy as _runpy
+    from pathlib import Path as _Path
+
+    for _parent in _Path(__file__).resolve().parents:
+        _launcher = _parent / "scripts" / "self_relaunch.py"
+        if not _launcher.is_file():
+            _launcher = _parent / "clara" / "scripts" / "self_relaunch.py"
+        if _launcher.is_file():
+            _runpy.run_path(str(_launcher))["ensure_running_in_managed_venv"](__file__)
+            break
+    else:
+        # Standalone components retain their host's dependency setup.
+        if any(
+            (_p / "components.json").is_file()
+            for _p in _Path(__file__).resolve().parents
+        ):
+            raise SystemExit(
+                "Managed Python launcher is missing; rebuild the plugin package."
+            )
+
+import argparse
+import calendar
+import hashlib
+import importlib.util
+import json
+import re
+import sys
+from datetime import date, timedelta
+from pathlib import Path
+from typing import Any
+
+from jsonschema import Draft202012Validator
+
+__all__ = [
+    "SEMANTIC_LAYER_SCHEMA_VERSION",
+    "assess_snapshot_compatibility",
+    "build_semantic_acceptance_summary",
+    "build_authoring_context",
+    "build_business_metric_authoring_context",
+    "build_business_metric_mapping_scaffold",
+    "build_semantic_layer_scaffold",
+    "build_snapshot_attachment",
+    "canonical_profile_fingerprint",
+    "canonical_snapshot_fingerprint",
+    "main",
+    "resolve_period_rules",
+    "summarize_business_metric_mappings",
+    "validate_semantic_layer",
+]
+
+SEMANTIC_LAYER_SCHEMA_VERSION = "0.3"
+REPORTING_ENGINE_ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_MANIFEST = REPORTING_ENGINE_ROOT / "catalog" / "selection_manifest.json"
+DEFAULT_SEMANTIC_SCHEMA = (
+    REPORTING_ENGINE_ROOT / "catalog" / "semantic_layer.schema.json"
+)
+
+CONCEPT_STATUSES = {"defined", "conditional", "excluded", "unknown"}
+ANALYSIS_VALIDITIES = {"valid", "conditional", "invalid", "unknown"}
+CONFIDENCE_LEVELS = {"high", "medium", "low", "unknown"}
+COVERAGE_LEVELS = {
+    "unreviewed",
+    "limited",
+    "directional",
+    "strong",
+    "conflicted",
+    "blocked",
+}
+REVIEW_STATUSES = {"draft", "model_reviewed", "human_reviewed"}
+EVIDENCE_STATUSES = {"supported", "inferred", "conflicted", "unverified"}
+SOURCE_AUTHORITIES = {
+    "canonical",
+    "corroborating",
+    "observed",
+    "mechanical",
+    "unverified",
+}
+BINDING_TYPES = {
+    "concept",
+    "concept_list",
+    "literal",
+    "derived",
+    "package",
+    "unresolved",
+}
+PERIOD_RULE_TYPES = {
+    "all_available",
+    "latest_available_period",
+    "trailing_periods",
+    "current_ytd",
+    "current_vs_prior_year",
+    "current_ytd_vs_prior_ytd",
+    "caller_bounded",
+}
+PERIOD_SCOPE_TYPES = {"single", "comparison_pair", "all_available"}
+SNAPSHOT_COMPATIBILITY_STATUSES = {
+    "compatible",
+    "compatible_with_extensions",
+    "partially_compatible",
+    "incompatible",
+}
+BUSINESS_METRIC_ROLES = ("sales", "discount", "cogs")
+BUSINESS_METRIC_MAPPING_STATES = {"mapped", "absent", "ambiguous", "unknown"}
+BUSINESS_METRIC_ROLE_GUIDANCE = {
+    "sales": {
+        "question": (
+            "Which reviewed metric is the dataset's primary reported sales or "
+            "revenue value, if one exists?"
+        ),
+        "distinctions": [
+            "Preserve whether the source defines the value as gross sales, net sales, revenue, or another basis.",
+            "Do not treat a matching header or a generic additive-value profile class as sufficient evidence.",
+        ],
+    },
+    "discount": {
+        "question": (
+            "Which reviewed metric is a separately reported discount, rebate, "
+            "or allowance measure, if one exists?"
+        ),
+        "distinctions": [
+            "Preserve whether the source reports a discount amount, rate, or another basis; do not substitute one for another.",
+            "Do not reconstruct a separate discount from sales that are already reported net.",
+        ],
+    },
+    "cogs": {
+        "question": (
+            "Which reviewed metric is total cost of goods sold or cost of sales, "
+            "if one exists?"
+        ),
+        "distinctions": [
+            "Do not assume that a unit cost is total COGS without a reviewed quantity relationship.",
+            "Do not infer a separately reported COGS amount from a margin rate alone.",
+        ],
+    },
+}
+
+
+def _load_json(path: Path) -> dict[str, Any]:
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError(f"Expected a JSON object in {path}.")
+    return payload
+
+
+def _write_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(payload, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+
+
+def _normalized_profile(profile: dict[str, Any]) -> dict[str, Any]:
+    """Return profile content normalized for a location-independent digest."""
+
+    normalized = json.loads(json.dumps(profile, sort_keys=True, ensure_ascii=False))
+    source = normalized.get("source")
+    if isinstance(source, dict):
+        source.pop("path", None)
+    return normalized
+
+
+def canonical_snapshot_fingerprint(profile: dict[str, Any]) -> str:
+    """Hash one snapshot profile while ignoring its machine-specific path."""
+
+    encoded = json.dumps(
+        _normalized_profile(profile),
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+    ).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def canonical_profile_fingerprint(profile: dict[str, Any]) -> str:
+    """Return the snapshot digest under the original public helper name."""
+
+    return canonical_snapshot_fingerprint(profile)
+
+
+def _sha256_file(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def _portable_component_path(path: Path) -> str:
+    resolved_path = path.resolve()
+    try:
+        return str(resolved_path.relative_to(REPORTING_ENGINE_ROOT))
+    except ValueError:
+        return resolved_path.name
+
+
+def _profile_dataset_for_acceptance(path: Path, dataset_id: str) -> dict[str, Any]:
+    module_path = Path(__file__).resolve().parent / "profile_dataset.py"
+    spec = importlib.util.spec_from_file_location(
+        "reporting_engine_semantic_acceptance_profiler", module_path
+    )
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Could not load dataset profiler from {module_path}.")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module.profile_dataset(path, dataset_id=dataset_id)
+
+
+def _slug(value: str) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "_", value.casefold()).strip("_")
+    return slug or "unnamed"
+
+
+def _unique_id(prefix: str, label: str, used: set[str]) -> str:
+    base = f"{prefix}.{_slug(label)}"
+    candidate = base
+    suffix = 2
+    while candidate in used:
+        candidate = f"{base}_{suffix}"
+        suffix += 1
+    used.add(candidate)
+    return candidate
+
+
+def build_business_metric_mapping_scaffold() -> dict[str, dict[str, Any]]:
+    """Return unresolved canonical business roles without guessing a metric."""
+
+    return {
+        role: {
+            "state": "unknown",
+            "metric_id": None,
+            "candidate_metric_ids": [],
+            "confidence": "unknown",
+            "rationale": "",
+            "evidence_ids": [],
+            "caveats": [],
+        }
+        for role in BUSINESS_METRIC_ROLES
+    }
+
+
+def summarize_business_metric_mappings(
+    layer: dict[str, Any],
+) -> dict[str, Any]:
+    """Summarize reviewed role states without adding semantic judgment."""
+
+    raw_mappings = layer.get("business_metric_mappings")
+    mappings = raw_mappings if isinstance(raw_mappings, dict) else {}
+    roles: dict[str, dict[str, Any]] = {}
+    state_counts = {state: 0 for state in ("mapped", "absent", "ambiguous", "unknown")}
+    for role in BUSINESS_METRIC_ROLES:
+        raw_mapping = mappings.get(role)
+        mapping = raw_mapping if isinstance(raw_mapping, dict) else {}
+        state = str(mapping.get("state") or "unknown")
+        if state not in BUSINESS_METRIC_MAPPING_STATES:
+            state = "unknown"
+        state_counts[state] += 1
+        raw_candidate_ids = mapping.get("candidate_metric_ids")
+        roles[role] = {
+            "state": state,
+            "metric_id": mapping.get("metric_id"),
+            "candidate_metric_ids": (
+                list(raw_candidate_ids) if isinstance(raw_candidate_ids, list) else []
+            ),
+            "confidence": mapping.get("confidence") or "unknown",
+        }
+    unresolved_roles = [
+        role
+        for role, mapping in roles.items()
+        if mapping["state"] in {"ambiguous", "unknown"}
+    ]
+    return {
+        "status": "resolved" if not unresolved_roles else "review_required",
+        "roles": roles,
+        "state_counts": state_counts,
+        "unresolved_roles": unresolved_roles,
+    }
+
+
+def build_business_metric_authoring_context(
+    semantic_layer: dict[str, Any],
+) -> dict[str, Any]:
+    """Expose every metric for model-led Sales, Discount, and COGS review."""
+
+    metrics = [
+        metric
+        for metric in semantic_layer.get("metrics") or []
+        if isinstance(metric, dict)
+    ]
+    metric_candidates = [
+        {
+            "metric_id": metric.get("metric_id"),
+            "label": metric.get("label"),
+            "binding": metric.get("binding"),
+            "definition": metric.get("definition"),
+            "metric_class": metric.get("metric_class"),
+            "status": metric.get("status"),
+            "confidence": metric.get("confidence"),
+            "origin_profile_observation": metric.get("origin_profile_observation")
+            or {},
+        }
+        for metric in metrics
+    ]
+    raw_mappings = semantic_layer.get("business_metric_mappings")
+    current_mappings = (
+        raw_mappings
+        if isinstance(raw_mappings, dict)
+        else build_business_metric_mapping_scaffold()
+    )
+    return {
+        "current_mappings": current_mappings,
+        "role_guidance": BUSINESS_METRIC_ROLE_GUIDANCE,
+        "metric_candidates": metric_candidates,
+        "review_rules": [
+            "Inspect the dataset and non-mechanical source evidence before changing a role from unknown.",
+            "Use mapped only for one reviewed metric id; update that metric's business definition, class, aggregation, status, rationale, and evidence too.",
+            "Use absent only when source-backed review establishes that the dataset has no separate measure for the role.",
+            "Use ambiguous when evidence supports one or more plausible metric ids but does not justify a single mapping.",
+            "Keep unknown when the available evidence supports neither a mapping, absence, nor a bounded ambiguity.",
+            "Do not rank, select, or reject candidates from column names or profiler hints alone.",
+        ],
+    }
+
+
+def _profile_source_locator(profile: dict[str, Any]) -> str:
+    source = profile.get("source") or {}
+    return str(source.get("path") or f"dataset-profile:{profile.get('dataset_id')}")
+
+
+def _metric_scaffold(profile: dict[str, Any]) -> list[dict[str, Any]]:
+    candidates = (
+        (profile.get("selector_profile") or {}).get("metric_candidates")
+    ) or []
+    used_ids: set[str] = set()
+    column_to_metric_id: dict[str, str] = {}
+    for candidate in candidates:
+        column = str(candidate.get("column") or "unnamed")
+        column_to_metric_id[column] = _unique_id("metric", column, used_ids)
+
+    records: list[dict[str, Any]] = []
+    for candidate in candidates:
+        column = str(candidate.get("column") or "unnamed")
+        source_role = str(candidate.get("source_role") or "metric")
+        produced_from = [str(value) for value in candidate.get("produced_from") or []]
+        is_derived = source_role == "derived_metric"
+        binding = {
+            "binding_type": "derived" if is_derived else "column",
+            "column": None if is_derived else column,
+            "expression": (
+                " / ".join(produced_from) if is_derived and produced_from else None
+            ),
+            "input_metric_ids": [
+                column_to_metric_id[source]
+                for source in produced_from
+                if source in column_to_metric_id
+            ],
+        }
+        records.append(
+            {
+                "metric_id": column_to_metric_id[column],
+                "label": column,
+                "binding": binding,
+                "definition": None,
+                "metric_class": None,
+                "aggregation": {
+                    "default": "unknown",
+                    "allowed": [],
+                    "forbidden": [],
+                    "weight_metric_id": None,
+                },
+                "unit": {
+                    "kind": "unknown",
+                    "currency": None,
+                    "symbol": None,
+                },
+                "directionality": "unknown",
+                "valid_period_grains": [],
+                "compatible_dimension_ids": [],
+                "forbidden_dimension_ids": [],
+                "status": "unknown",
+                "confidence": "unknown",
+                "rationale": (
+                    "Generated from a mechanical metric candidate; business meaning "
+                    "and aggregation remain unreviewed."
+                ),
+                "evidence_ids": ["evidence.dataset_profile"],
+                "caveats": [],
+                "origin_profile_observation": {
+                    "source_role": source_role,
+                    "metric_class": candidate.get("metric_class"),
+                    "aggregation": candidate.get("aggregation"),
+                    "confidence": candidate.get("confidence"),
+                    "inference_reasons": candidate.get("inference_reasons") or [],
+                },
+            }
+        )
+    return records
+
+
+def _dimension_scaffold(profile: dict[str, Any]) -> list[dict[str, Any]]:
+    selector = profile.get("selector_profile") or {}
+    candidates = [
+        *(selector.get("dimension_candidates") or []),
+        *(selector.get("identifier_candidates") or []),
+    ]
+    used_ids: set[str] = set()
+    records: list[dict[str, Any]] = []
+    for candidate in candidates:
+        column = str(candidate.get("column") or "unnamed")
+        source_role = str(candidate.get("source_role") or "dimension")
+        records.append(
+            {
+                "dimension_id": _unique_id("dimension", column, used_ids),
+                "label": column,
+                "column": column,
+                "definition": None,
+                "semantic_type": (
+                    "identifier" if source_role == "identifier" else "categorical"
+                ),
+                "valid_uses": [],
+                "hierarchy_parent_id": None,
+                "status": "unknown",
+                "confidence": "unknown",
+                "rationale": (
+                    "Generated from a mechanical dimension candidate; grouping, "
+                    "hierarchy, and business meaning remain unreviewed."
+                ),
+                "evidence_ids": ["evidence.dataset_profile"],
+                "caveats": [],
+                "origin_profile_observation": {
+                    "source_role": source_role,
+                    "confidence": candidate.get("confidence"),
+                    "inference_reasons": candidate.get("inference_reasons") or [],
+                },
+            }
+        )
+    return records
+
+
+def _period_scaffold(profile: dict[str, Any]) -> list[dict[str, Any]]:
+    candidates = (
+        (profile.get("selector_profile") or {}).get("period_candidates")
+    ) or []
+    used_ids: set[str] = set()
+    records: list[dict[str, Any]] = []
+    for candidate in candidates:
+        column = str(candidate.get("column") or "unnamed")
+        records.append(
+            {
+                "period_id": _unique_id("period", column, used_ids),
+                "label": column,
+                "column": column,
+                "definition": None,
+                "grain": candidate.get("grain") or "unknown",
+                "calendar": "unknown",
+                "timezone": None,
+                "status": "unknown",
+                "confidence": "unknown",
+                "rationale": (
+                    "Generated from a mechanically parseable period candidate; "
+                    "calendar and reporting meaning remain unreviewed."
+                ),
+                "evidence_ids": ["evidence.dataset_profile"],
+                "caveats": [],
+                "origin_profile_observation": {
+                    "confidence": candidate.get("confidence"),
+                    "grain": candidate.get("grain"),
+                },
+            }
+        )
+    return records
+
+
+def build_semantic_layer_scaffold(
+    profile: dict[str, Any],
+    *,
+    dataset_contract_id: str | None = None,
+    semantic_layer_id: str | None = None,
+    semantic_version: int = 1,
+    identity_method: str = "caller_assigned",
+    identity_value: str | None = None,
+    profile_locator: str | None = None,
+) -> dict[str, Any]:
+    """Create an unreviewed stable contract without semantic assertions."""
+
+    dataset_id = str(profile.get("dataset_id") or "dataset")
+    contract_id = dataset_contract_id or dataset_id
+    layer_id = semantic_layer_id or f"{_slug(contract_id)}.reporting_semantics"
+    return {
+        "schema_version": SEMANTIC_LAYER_SCHEMA_VERSION,
+        "semantic_layer_id": layer_id,
+        "semantic_version": semantic_version,
+        "dataset_contract": {
+            "dataset_contract_id": contract_id,
+            "contract_version": 1,
+            "identity": {
+                "method": identity_method,
+                "value": identity_value or contract_id,
+            },
+            "origin_snapshot": {
+                "profile_schema_version": str(
+                    profile.get("schema_version") or "unknown"
+                ),
+                "snapshot_fingerprint": canonical_snapshot_fingerprint(profile),
+            },
+            "unknown_column_policy": "allow_as_unclassified_extension",
+        },
+        "scope": {
+            "title": f"{dataset_id} reporting semantics",
+            "business_area": None,
+            "purpose": (
+                "Define source-backed business concepts and analysis validity for "
+                "Reporting Engine chart selection."
+            ),
+            "coverage_level": "unreviewed",
+            "included_subjects": [],
+            "excluded_subjects": [],
+        },
+        "sources": [
+            {
+                "source_id": "source.dataset_profile",
+                "source_type": "dataset_profile",
+                "locator": profile_locator or _profile_source_locator(profile),
+                "authority": "mechanical",
+                "supports": [
+                    "physical columns",
+                    "types and cardinality",
+                    "mechanical metric, dimension, and period candidates",
+                ],
+                "caveats": [
+                    "The profile does not establish business meaning or analysis validity."
+                ],
+                "last_checked": None,
+            }
+        ],
+        "evidence": [
+            {
+                "evidence_id": "evidence.dataset_profile",
+                "source_id": "source.dataset_profile",
+                "locator": "dataset profile root",
+                "claim": (
+                    "The referenced fields and profiler candidates exist mechanically; "
+                    "their business interpretation remains unreviewed."
+                ),
+                "confidence": "high",
+                "status": "supported",
+                "notes": [],
+            }
+        ],
+        "business_metric_mappings": build_business_metric_mapping_scaffold(),
+        "metrics": _metric_scaffold(profile),
+        "dimensions": _dimension_scaffold(profile),
+        "periods": _period_scaffold(profile),
+        "period_rules": [],
+        "analysis_policies": [],
+        "open_questions": [
+            {
+                "question_id": "question.canonical_metrics",
+                "question": (
+                    "Which metric candidates are canonical, and how may each be "
+                    "aggregated?"
+                ),
+                "why_it_matters": (
+                    "Chart metric roles cannot be bound safely until metric meaning "
+                    "and aggregation are reviewed."
+                ),
+                "owner_or_source": None,
+                "status": "open",
+            },
+            {
+                "question_id": "question.dimension_meaning",
+                "question": (
+                    "Which dimensions are valid for grouping, filtering, hierarchy, "
+                    "panels, or entity identity?"
+                ),
+                "why_it_matters": (
+                    "Mechanical cardinality alone cannot establish a meaningful split."
+                ),
+                "owner_or_source": None,
+                "status": "open",
+            },
+            {
+                "question_id": "question.analysis_validity",
+                "question": (
+                    "Which manifest analysis types make business sense for these "
+                    "reviewed concepts and reusable period rules?"
+                ),
+                "why_it_matters": (
+                    "The semantic layer must approve, reject, or condition analyses "
+                    "before a future selector chooses a chart."
+                ),
+                "owner_or_source": None,
+                "status": "open",
+            },
+        ],
+        "review": {
+            "status": "draft",
+            "reviewed_by": None,
+            "reviewed_at": None,
+            "notes": [
+                "Scaffold generated mechanically; no semantic assertion is approved."
+            ],
+        },
+        "boundaries": {
+            "semantic_judgment_owner": "model_or_human_review",
+            "deterministic_validation_scope": (
+                "Schema, identifiers, evidence references, stable dataset identity, "
+                "snapshot compatibility, period-rule resolution, manifest intent "
+                "references, and required role coverage only."
+            ),
+            "chart_selection_included": False,
+            "rendering_included": False,
+        },
+    }
+
+
+def _caller_required_roles(capability: dict[str, Any]) -> list[dict[str, Any]]:
+    contract = capability.get("normalized_invocation_contract") or {}
+    metric_requirements = (
+        ((capability.get("selection_contract") or {}).get("dataset_requirements") or {})
+        .get("metrics", {})
+        .get("source_metric_roles", [])
+    )
+    metric_classes_by_role = {
+        str(requirement.get("role")): list(
+            requirement.get("accepted_metric_classes") or []
+        )
+        for requirement in metric_requirements
+    }
+    roles = []
+    for role in contract.get("required_role_contracts") or []:
+        if role.get("required", True) and role.get("caller_binding_required", True):
+            roles.append(
+                {
+                    "role": str(role.get("role")),
+                    "kind": str(role.get("kind") or "unknown"),
+                    "mapping_kind": role.get("mapping_kind"),
+                    "scope_binding": role.get("scope_binding") or {},
+                    "accepted_metric_classes": metric_classes_by_role.get(
+                        str(role.get("role")), []
+                    ),
+                }
+            )
+    return roles
+
+
+def _analysis_catalog(manifest: dict[str, Any]) -> list[dict[str, Any]]:
+    capabilities = manifest.get("capabilities") or {}
+    records: dict[str, dict[str, Any]] = {}
+    for task_id, task in (manifest.get("analysis_tasks") or {}).items():
+        for emphasis, treatment in (task.get("treatments") or {}).items():
+            record = records.setdefault(
+                emphasis,
+                {
+                    "selection_emphasis": emphasis,
+                    "analysis_task_ids": [],
+                    "capability_ids": [],
+                    "best_when": treatment.get("best_when"),
+                    "avoid_when": treatment.get("avoid_when"),
+                    "required_role_sets": [],
+                },
+            )
+            if task_id not in record["analysis_task_ids"]:
+                record["analysis_task_ids"].append(task_id)
+            for capability_id in treatment.get("capability_ids") or []:
+                if capability_id not in record["capability_ids"]:
+                    record["capability_ids"].append(capability_id)
+                capability = capabilities.get(capability_id) or {}
+                role_set = {
+                    "capability_id": capability_id,
+                    "roles": _caller_required_roles(capability),
+                    "period_scope_contract": capability.get("period_scope_contract")
+                    or {},
+                }
+                if role_set not in record["required_role_sets"]:
+                    record["required_role_sets"].append(role_set)
+    for record in records.values():
+        record["analysis_task_ids"].sort()
+        record["capability_ids"].sort()
+        record["required_role_sets"].sort(key=lambda item: item["capability_id"])
+    return [records[key] for key in sorted(records)]
+
+
+def build_authoring_context(
+    profile: dict[str, Any],
+    manifest: dict[str, Any],
+    *,
+    semantic_layer: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Package mechanical evidence and manifest intents for semantic review."""
+
+    scaffold = semantic_layer or build_semantic_layer_scaffold(profile)
+    return {
+        "schema_version": SEMANTIC_LAYER_SCHEMA_VERSION,
+        "purpose": (
+            "Model-facing context for authoring or reviewing one dataset-specific "
+            "Reporting Engine semantic layer."
+        ),
+        "snapshot_fingerprint": canonical_snapshot_fingerprint(profile),
+        "snapshot_profile": profile,
+        "semantic_layer_draft": scaffold,
+        "business_metric_mapping_review": (
+            build_business_metric_authoring_context(scaffold)
+        ),
+        "analysis_catalog": _analysis_catalog(manifest),
+        "authoring_rules": [
+            "Inspect source data and business evidence; profiler labels are candidates, not semantic facts.",
+            "Keep metric definitions, aggregation, units, dimensions, calendars, and reusable period rules explicit.",
+            "Do not copy row counts, values, members, available date bounds, or concrete run windows into stable semantics.",
+            "Bind the layer to a caller-, connector-, or project-assigned dataset contract id; never infer logical identity from schema alone.",
+            "Every valid, conditional, or invalid semantic assertion needs rationale and source-backed evidence.",
+            "Review Sales, Discount, and COGS explicitly; matching headers and profiler hints are not semantic evidence.",
+            "Preserve conflicts and unknowns instead of guessing.",
+            "Add analysis policies only for meaningful reusable analysis families; do not manufacture one policy per chart.",
+            "Treat every manifest selection emphasis without a reviewed policy as unknown, not valid or invalid by default.",
+            "Use manifest analysis_task_ids and selection_emphases as join keys, then bind their canonical roles to reviewed concepts.",
+            "Do not choose a chart in the semantic layer. The manifest remains the plot-side contract.",
+        ],
+        "boundary": (
+            "This context supports model-led semantic authoring. It is not a "
+            "classifier, selector, orchestrator, or rendering request."
+        ),
+    }
+
+
+def _issue(target: list[dict[str, Any]], code: str, path: str, message: str) -> None:
+    target.append({"code": code, "path": path, "message": message})
+
+
+def _schema_error_path(parts: Any) -> str:
+    """Return a stable JSONPath-like location for one schema error."""
+
+    path = "$"
+    for part in parts:
+        path += f"[{part}]" if isinstance(part, int) else f".{part}"
+    return path
+
+
+def _check_json_schema(
+    layer: dict[str, Any],
+    schema: dict[str, Any],
+    errors: list[dict[str, Any]],
+) -> None:
+    """Apply the packaged schema because structure is mechanically verifiable."""
+
+    validator = Draft202012Validator(schema)
+    validation_errors = sorted(
+        validator.iter_errors(layer),
+        key=lambda error: (
+            tuple(str(part) for part in error.absolute_path),
+            error.message,
+        ),
+    )
+    for validation_error in validation_errors:
+        _issue(
+            errors,
+            "schema_validation_error",
+            _schema_error_path(validation_error.absolute_path),
+            validation_error.message,
+        )
+
+
+def _records(
+    layer: dict[str, Any],
+    key: str,
+    id_key: str,
+    errors: list[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], dict[str, dict[str, Any]]]:
+    raw = layer.get(key)
+    if not isinstance(raw, list):
+        _issue(errors, "invalid_type", key, "Expected a list.")
+        return [], {}
+    index: dict[str, dict[str, Any]] = {}
+    records: list[dict[str, Any]] = []
+    for position, value in enumerate(raw):
+        path = f"{key}[{position}]"
+        if not isinstance(value, dict):
+            _issue(errors, "invalid_type", path, "Expected an object.")
+            continue
+        record_id = value.get(id_key)
+        if not isinstance(record_id, str) or not record_id.strip():
+            _issue(
+                errors, "missing_id", f"{path}.{id_key}", "A non-empty id is required."
+            )
+            continue
+        if record_id in index:
+            _issue(
+                errors, "duplicate_id", f"{path}.{id_key}", f"Duplicate id: {record_id}"
+            )
+            continue
+        index[record_id] = value
+        records.append(value)
+    return records, index
+
+
+def _check_enum(
+    value: Any,
+    allowed: set[str],
+    path: str,
+    errors: list[dict[str, Any]],
+) -> None:
+    if value not in allowed:
+        _issue(
+            errors,
+            "invalid_enum",
+            path,
+            f"Expected one of {sorted(allowed)}; got {value!r}.",
+        )
+
+
+def _check_assertion_evidence(
+    record: dict[str, Any],
+    *,
+    status_key: str,
+    unknown_value: str,
+    path: str,
+    evidence_index: dict[str, dict[str, Any]],
+    source_index: dict[str, dict[str, Any]],
+    errors: list[dict[str, Any]],
+    warnings: list[dict[str, Any]],
+) -> None:
+    if record.get(status_key) == unknown_value:
+        return
+    rationale = record.get("rationale")
+    if not isinstance(rationale, str) or not rationale.strip():
+        _issue(
+            errors,
+            "missing_rationale",
+            f"{path}.rationale",
+            "Reviewed semantic assertions require a rationale.",
+        )
+    evidence_ids = record.get("evidence_ids")
+    if not isinstance(evidence_ids, list) or not evidence_ids:
+        _issue(
+            errors,
+            "missing_evidence",
+            f"{path}.evidence_ids",
+            "Reviewed semantic assertions require at least one evidence reference.",
+        )
+        return
+    resolved_evidence: list[dict[str, Any]] = []
+    for evidence_id in evidence_ids:
+        evidence = evidence_index.get(str(evidence_id))
+        if evidence is None:
+            _issue(
+                errors,
+                "unknown_evidence",
+                f"{path}.evidence_ids",
+                f"Unknown evidence id: {evidence_id}",
+            )
+            continue
+        resolved_evidence.append(evidence)
+    if resolved_evidence and not any(
+        (source_index.get(str(evidence.get("source_id"))) or {}).get("authority")
+        in {"canonical", "corroborating", "observed"}
+        for evidence in resolved_evidence
+    ):
+        _issue(
+            errors,
+            "semantic_assertion_only_mechanical_evidence",
+            f"{path}.evidence_ids",
+            "A reviewed semantic assertion needs at least one non-mechanical source.",
+        )
+    if any(evidence.get("status") == "conflicted" for evidence in resolved_evidence):
+        _issue(
+            warnings,
+            "conflicted_evidence_cited",
+            f"{path}.evidence_ids",
+            "The assertion cites conflicted evidence; preserve the conflict in status, rationale, or caveats.",
+        )
+
+
+def _validate_business_metric_mappings(
+    layer: dict[str, Any],
+    *,
+    metric_index: dict[str, dict[str, Any]],
+    evidence_index: dict[str, dict[str, Any]],
+    source_index: dict[str, dict[str, Any]],
+    errors: list[dict[str, Any]],
+    warnings: list[dict[str, Any]],
+) -> dict[str, Any]:
+    """Validate role references and reviewed evidence without choosing a metric."""
+
+    raw_mappings = layer.get("business_metric_mappings")
+    if not isinstance(raw_mappings, dict):
+        _issue(
+            errors,
+            "invalid_type",
+            "business_metric_mappings",
+            "Expected an object.",
+        )
+        return summarize_business_metric_mappings(layer)
+
+    mapped_metric_roles: dict[str, str] = {}
+    for role in BUSINESS_METRIC_ROLES:
+        path = f"$.business_metric_mappings.{role}"
+        raw_mapping = raw_mappings.get(role)
+        if not isinstance(raw_mapping, dict):
+            _issue(
+                errors,
+                "missing_business_metric_mapping",
+                path,
+                f"A mapping record is required for {role}.",
+            )
+            continue
+        mapping = raw_mapping
+        state = mapping.get("state")
+        _check_enum(
+            state,
+            BUSINESS_METRIC_MAPPING_STATES,
+            f"{path}.state",
+            errors,
+        )
+        _check_enum(
+            mapping.get("confidence"),
+            CONFIDENCE_LEVELS,
+            f"{path}.confidence",
+            errors,
+        )
+        _check_assertion_evidence(
+            mapping,
+            status_key="state",
+            unknown_value="unknown",
+            path=path,
+            evidence_index=evidence_index,
+            source_index=source_index,
+            errors=errors,
+            warnings=warnings,
+        )
+
+        metric_id = mapping.get("metric_id")
+        raw_candidate_ids = mapping.get("candidate_metric_ids")
+        candidate_ids = raw_candidate_ids if isinstance(raw_candidate_ids, list) else []
+        if state == "mapped":
+            if not isinstance(metric_id, str) or metric_id not in metric_index:
+                _issue(
+                    errors,
+                    "unknown_business_metric",
+                    f"{path}.metric_id",
+                    f"Unknown mapped metric: {metric_id}",
+                )
+            else:
+                metric_status = metric_index[metric_id].get("status")
+                if metric_status not in {"defined", "conditional"}:
+                    _issue(
+                        errors,
+                        "business_metric_not_reviewed",
+                        f"{path}.metric_id",
+                        (
+                            f"Mapped metric {metric_id} must be defined or "
+                            "conditional, not "
+                            f"{metric_status!r}."
+                        ),
+                    )
+                previous_role = mapped_metric_roles.get(metric_id)
+                if previous_role is not None:
+                    _issue(
+                        errors,
+                        "duplicate_business_metric_mapping",
+                        f"{path}.metric_id",
+                        (
+                            f"Metric {metric_id} is already mapped to "
+                            f"{previous_role}; canonical roles require distinct "
+                            "reviewed mappings."
+                        ),
+                    )
+                else:
+                    mapped_metric_roles[metric_id] = role
+            if candidate_ids:
+                _issue(
+                    errors,
+                    "mapped_role_has_candidates",
+                    f"{path}.candidate_metric_ids",
+                    "A mapped role must not retain ambiguous candidates.",
+                )
+        elif state == "absent":
+            if metric_id is not None or candidate_ids:
+                _issue(
+                    errors,
+                    "absent_role_has_metric",
+                    path,
+                    "An absent role cannot reference a metric or candidates.",
+                )
+        elif state == "ambiguous":
+            if metric_id is not None:
+                _issue(
+                    errors,
+                    "ambiguous_role_has_mapping",
+                    f"{path}.metric_id",
+                    "An ambiguous role cannot choose one metric.",
+                )
+            if not candidate_ids:
+                _issue(
+                    errors,
+                    "ambiguous_role_without_candidates",
+                    f"{path}.candidate_metric_ids",
+                    "An ambiguous role needs at least one reviewed candidate.",
+                )
+            for candidate_id in candidate_ids:
+                if not isinstance(candidate_id, str):
+                    _issue(
+                        errors,
+                        "invalid_business_metric_candidate",
+                        f"{path}.candidate_metric_ids",
+                        "Metric candidate ids must be strings.",
+                    )
+                    continue
+                if candidate_id not in metric_index:
+                    _issue(
+                        errors,
+                        "unknown_business_metric_candidate",
+                        f"{path}.candidate_metric_ids",
+                        f"Unknown metric candidate: {candidate_id}",
+                    )
+        elif state == "unknown":
+            if metric_id is not None or candidate_ids:
+                _issue(
+                    errors,
+                    "unknown_role_has_assignment",
+                    path,
+                    "An unknown role cannot retain a mapping or candidates.",
+                )
+
+    return summarize_business_metric_mappings(layer)
+
+
+def _check_iso_date(value: Any, path: str, errors: list[dict[str, Any]]) -> None:
+    if value is None:
+        return
+    if not isinstance(value, str):
+        _issue(errors, "invalid_date", path, "Expected an ISO date string or null.")
+        return
+    try:
+        date.fromisoformat(value)
+    except ValueError:
+        _issue(errors, "invalid_date", path, f"Invalid ISO date: {value}")
+
+
+def _analysis_catalog_index(manifest: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    return {
+        record["selection_emphasis"]: record for record in _analysis_catalog(manifest)
+    }
+
+
+def _binding_is_resolved(binding: dict[str, Any]) -> bool:
+    return binding.get("binding_type") != "unresolved"
+
+
+def _binding_concept_ids(binding: Any) -> list[str]:
+    if not isinstance(binding, dict):
+        return []
+    if binding.get("binding_type") == "concept" and binding.get("concept_id"):
+        return [str(binding["concept_id"])]
+    if binding.get("binding_type") == "concept_list":
+        return [str(value) for value in binding.get("concept_ids") or []]
+    return []
+
+
+def _policy_semantic_mismatches(
+    *,
+    validity: Any,
+    role_bindings: dict[str, Any],
+    period_rule_id: Any,
+    concept_index: dict[str, tuple[str, dict[str, Any]]],
+    period_rule_index: dict[str, dict[str, Any]],
+) -> list[dict[str, Any]]:
+    if validity not in {"valid", "conditional"}:
+        return []
+    allowed_statuses = (
+        {"defined"} if validity == "valid" else {"defined", "conditional"}
+    )
+    bound_concepts = [
+        (role, concept_id, concept_index.get(concept_id))
+        for role, binding in role_bindings.items()
+        for concept_id in _binding_concept_ids(binding)
+    ]
+    mismatches: list[dict[str, Any]] = []
+    for role, concept_id, concept in bound_concepts:
+        if concept is None:
+            continue
+        if concept[1].get("status") not in allowed_statuses:
+            mismatches.append(
+                {
+                    "code": "concept_not_ready",
+                    "role": role,
+                    "concept_id": concept_id,
+                    "message": (
+                        f"{validity} policy cannot use concept status "
+                        f"{concept[1].get('status')!r}."
+                    ),
+                }
+            )
+    if period_rule_id in period_rule_index:
+        rule_status = period_rule_index[period_rule_id].get("status")
+        if rule_status not in allowed_statuses:
+            mismatches.append(
+                {
+                    "code": "period_rule_not_ready",
+                    "period_rule_id": period_rule_id,
+                    "message": (
+                        f"{validity} policy cannot use period rule status "
+                        f"{rule_status!r}."
+                    ),
+                }
+            )
+
+    metrics = [
+        (concept_id, concept[1])
+        for _, concept_id, concept in bound_concepts
+        if concept is not None and concept[0] == "metric"
+    ]
+    dimensions = [
+        (concept_id, concept[1])
+        for _, concept_id, concept in bound_concepts
+        if concept is not None and concept[0] == "dimension"
+    ]
+    periods = [
+        (concept_id, concept[1])
+        for _, concept_id, concept in bound_concepts
+        if concept is not None and concept[0] == "period"
+    ]
+    if period_rule_id in period_rule_index:
+        rule_period_id = period_rule_index[period_rule_id].get("period_id")
+        rule_period = concept_index.get(str(rule_period_id))
+        if rule_period is not None and rule_period[0] == "period":
+            periods.append((str(rule_period_id), rule_period[1]))
+    dimensions = list(dict(dimensions).items())
+    periods = list(dict(periods).items())
+    for metric_id, metric in metrics:
+        compatible_dimensions = set(metric.get("compatible_dimension_ids") or [])
+        forbidden_dimensions = set(metric.get("forbidden_dimension_ids") or [])
+        for dimension_id, _ in dimensions:
+            if dimension_id in forbidden_dimensions:
+                mismatches.append(
+                    {
+                        "code": "forbidden_metric_dimension",
+                        "metric_id": metric_id,
+                        "dimension_id": dimension_id,
+                        "message": f"{metric_id} forbids analysis by {dimension_id}.",
+                    }
+                )
+            elif compatible_dimensions and dimension_id not in compatible_dimensions:
+                mismatches.append(
+                    {
+                        "code": "unapproved_metric_dimension",
+                        "metric_id": metric_id,
+                        "dimension_id": dimension_id,
+                        "message": (
+                            f"{dimension_id} is not in the reviewed compatible "
+                            f"dimensions for {metric_id}."
+                        ),
+                    }
+                )
+        valid_grains = set(metric.get("valid_period_grains") or [])
+        for period_id, period in periods:
+            grain = period.get("grain")
+            if valid_grains and grain not in valid_grains:
+                mismatches.append(
+                    {
+                        "code": "unapproved_metric_period_grain",
+                        "metric_id": metric_id,
+                        "period_id": period_id,
+                        "grain": grain,
+                        "message": (
+                            f"Period grain {grain!r} is not approved for {metric_id}."
+                        ),
+                    }
+                )
+    return mismatches
+
+
+def _check_role_binding(
+    *,
+    role: str,
+    binding: Any,
+    path: str,
+    concept_index: dict[str, tuple[str, dict[str, Any]]],
+    role_registry: dict[str, Any],
+    source_index: dict[str, dict[str, Any]],
+    errors: list[dict[str, Any]],
+    warnings: list[dict[str, Any]],
+) -> None:
+    if not isinstance(binding, dict):
+        _issue(errors, "invalid_role_binding", path, "Expected a role-binding object.")
+        return
+    binding_type = binding.get("binding_type")
+    _check_enum(binding_type, BINDING_TYPES, f"{path}.binding_type", errors)
+    role_contract = (role_registry.get("chart_roles") or {}).get(role)
+    if role_contract is None:
+        _issue(errors, "unknown_chart_role", path, f"Unknown manifest role: {role}")
+    expected_kinds = set((role_contract or {}).get("kinds") or []) - {"variant"}
+    if binding_type == "concept":
+        concept_id = binding.get("concept_id")
+        concept = concept_index.get(str(concept_id))
+        if concept is None:
+            _issue(
+                errors,
+                "unknown_concept",
+                f"{path}.concept_id",
+                f"Unknown concept: {concept_id}",
+            )
+        elif expected_kinds and concept[0] not in expected_kinds:
+            _issue(
+                errors,
+                "role_concept_kind_mismatch",
+                f"{path}.concept_id",
+                f"Role {role} expects {sorted(expected_kinds)}, not {concept[0]}.",
+            )
+    elif binding_type == "concept_list":
+        concept_ids = binding.get("concept_ids")
+        if not isinstance(concept_ids, list) or not concept_ids:
+            _issue(
+                errors,
+                "missing_concepts",
+                f"{path}.concept_ids",
+                "A non-empty concept list is required.",
+            )
+        else:
+            for concept_id in concept_ids:
+                concept = concept_index.get(str(concept_id))
+                if concept is None:
+                    _issue(
+                        errors,
+                        "unknown_concept",
+                        f"{path}.concept_ids",
+                        f"Unknown concept: {concept_id}",
+                    )
+                elif expected_kinds and concept[0] not in expected_kinds:
+                    _issue(
+                        errors,
+                        "role_concept_kind_mismatch",
+                        f"{path}.concept_ids",
+                        f"Role {role} expects {sorted(expected_kinds)}, not {concept[0]}.",
+                    )
+    elif binding_type == "derived":
+        if not binding.get("expression"):
+            _issue(
+                errors,
+                "missing_expression",
+                f"{path}.expression",
+                "A derived binding needs an expression.",
+            )
+    elif binding_type == "package":
+        source_id = binding.get("source_id")
+        if source_id not in source_index:
+            _issue(
+                errors,
+                "unknown_source",
+                f"{path}.source_id",
+                f"Unknown package source: {source_id}",
+            )
+    elif binding_type == "unresolved" and not binding.get("reason"):
+        _issue(
+            errors,
+            "missing_reason",
+            f"{path}.reason",
+            "An unresolved binding needs a reason.",
+        )
+    elif binding_type == "literal" and "value" not in binding:
+        _issue(
+            errors,
+            "missing_literal",
+            f"{path}.value",
+            "A literal binding needs a value.",
+        )
+
+    if binding_type in {"literal", "derived", "package"} and expected_kinds:
+        _issue(
+            warnings,
+            "non_concept_role_binding",
+            path,
+            f"Role {role} is bound through {binding_type}; deterministic kind checking is limited.",
+        )
+
+
+def _parse_profile_date(value: Any) -> date | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    try:
+        return date.fromisoformat(value.strip()[:10])
+    except ValueError:
+        return None
+
+
+def _shift_months(value: date, months: int) -> date:
+    absolute_month = value.year * 12 + value.month - 1 + months
+    year, zero_based_month = divmod(absolute_month, 12)
+    month = zero_based_month + 1
+    day = min(value.day, calendar.monthrange(year, month)[1])
+    return date(year, month, day)
+
+
+def _shift_years(value: date, years: int) -> date:
+    year = value.year + years
+    day = min(value.day, calendar.monthrange(year, value.month)[1])
+    return date(year, value.month, day)
+
+
+def _period_start(value: date, grain: str) -> date:
+    if grain == "week":
+        return value - timedelta(days=value.weekday())
+    if grain == "month":
+        return date(value.year, value.month, 1)
+    if grain == "quarter":
+        return date(value.year, 1 + 3 * ((value.month - 1) // 3), 1)
+    if grain == "year":
+        return date(value.year, 1, 1)
+    return value
+
+
+def _period_end(value: date, grain: str) -> date:
+    start = _period_start(value, grain)
+    if grain == "week":
+        return start + timedelta(days=6)
+    if grain == "month":
+        return date(
+            start.year, start.month, calendar.monthrange(start.year, start.month)[1]
+        )
+    if grain == "quarter":
+        next_quarter = _shift_months(start, 3)
+        return next_quarter - timedelta(days=1)
+    if grain == "year":
+        return date(start.year, 12, 31)
+    return start
+
+
+def _shift_period(value: date, grain: str, periods: int) -> date:
+    if grain == "day":
+        return value + timedelta(days=periods)
+    if grain == "week":
+        return value + timedelta(days=periods * 7)
+    if grain == "month":
+        return _shift_months(value, periods)
+    if grain == "quarter":
+        return _shift_months(value, periods * 3)
+    if grain == "year":
+        return _shift_years(value, periods)
+    return value
+
+
+def _window(role: str, start: date, end: date) -> dict[str, Any]:
+    return {
+        "role": role,
+        "label": f"{start.isoformat()} to {end.isoformat()}",
+        "start": start.isoformat(),
+        "end": end.isoformat(),
+    }
+
+
+def _expected_period_starts(start: date, end: date, grain: str) -> list[date]:
+    values: list[date] = []
+    current = _period_start(start, grain)
+    final = _period_start(end, grain)
+    for _ in range(5000):
+        if current > final:
+            break
+        values.append(current)
+        next_value = _shift_period(current, grain, 1)
+        if next_value <= current:
+            break
+        current = next_value
+    return values
+
+
+def _available_period_starts(
+    profile: dict[str, Any], column: str | None, grain: str
+) -> tuple[set[date], bool]:
+    column_profile = (profile.get("columns") or {}).get(column) or {}
+    if column_profile.get("ordered_values_complete") is not True:
+        return set(), False
+    values = {
+        _period_start(parsed, grain)
+        for raw_value in column_profile.get("ordered_values") or []
+        if (parsed := _parse_profile_date(str(raw_value))) is not None
+    }
+    return values, True
+
+
+def _period_bounds(
+    period: dict[str, Any], profile: dict[str, Any]
+) -> tuple[date | None, date | None, str | None, str | None]:
+    column = period.get("column")
+    column_profile = (profile.get("columns") or {}).get(column) or {}
+    parseability = column_profile.get("period_parseability") or {}
+    minimum = _parse_profile_date(parseability.get("parsed_min"))
+    maximum = _parse_profile_date(parseability.get("parsed_max"))
+    profile_grain = column_profile.get("period_grain") or parseability.get(
+        "inferred_grain"
+    )
+    return (
+        minimum,
+        maximum,
+        str(column) if column else None,
+        (str(profile_grain) if profile_grain else None),
+    )
+
+
+def _resolve_period_rule(
+    rule: dict[str, Any],
+    period_index: dict[str, dict[str, Any]],
+    profile: dict[str, Any],
+) -> dict[str, Any]:
+    rule_id = rule.get("period_rule_id")
+    period = period_index.get(str(rule.get("period_id")))
+    base = {
+        "period_rule_id": rule_id,
+        "rule_type": rule.get("rule_type"),
+        "scope_type": rule.get("scope_type"),
+        "resolution_status": "unavailable",
+        "reason": None,
+        "period_column": None,
+        "grain": None,
+        "snapshot_bounds": None,
+        "coverage_check": {
+            "status": "not_checked",
+            "missing_period_starts": [],
+        },
+        "resolved_scope": None,
+    }
+    if rule.get("status") not in {"defined", "conditional"}:
+        base["reason"] = "period_rule_not_reviewed"
+        return base
+    # An explicitly reviewed whole-population scope needs no invented date.
+    if (
+        rule.get("period_id") is None
+        and rule.get("rule_type") == "all_available"
+        and rule.get("scope_type") == "all_available"
+    ):
+        base["resolution_status"] = "resolved"
+        base["coverage_check"]["status"] = "not_applicable"
+        base["resolved_scope"] = {
+            "scope_type": "all_available",
+            "period_column": None,
+            "windows": [],
+        }
+        return base
+    if period is None or period.get("status") not in {"defined", "conditional"}:
+        base["reason"] = "period_concept_not_available"
+        return base
+    minimum, maximum, column, profile_grain = _period_bounds(period, profile)
+    grain = str(period.get("grain") or "unknown")
+    base["period_column"] = column
+    base["grain"] = grain
+    if profile_grain not in {None, "unknown", grain}:
+        base["reason"] = "snapshot_period_grain_mismatch"
+        return base
+    if minimum is None or maximum is None:
+        base["reason"] = "snapshot_period_bounds_unavailable"
+        return base
+    base["snapshot_bounds"] = {
+        "minimum": minimum.isoformat(),
+        "maximum": maximum.isoformat(),
+    }
+    rule_type = rule.get("rule_type")
+    parameters = rule.get("parameters") or {}
+    if rule_type == "caller_bounded":
+        base["resolution_status"] = "requires_runtime_input"
+        base["reason"] = "caller_must_supply_concrete_period_bounds"
+        return base
+
+    latest_start = _period_start(maximum, grain)
+    latest_end = _period_end(maximum, grain)
+    windows: list[dict[str, Any]]
+    if rule_type == "all_available":
+        windows = [_window("current", _period_start(minimum, grain), latest_end)]
+    elif rule_type == "latest_available_period":
+        windows = [_window("current", latest_start, latest_end)]
+    elif rule_type == "trailing_periods":
+        window_length = int(parameters.get("window_length") or 0)
+        if window_length < 1:
+            base["reason"] = "invalid_window_length"
+            return base
+        windows = [
+            _window(
+                "current",
+                _shift_period(latest_start, grain, -(window_length - 1)),
+                latest_end,
+            )
+        ]
+    elif rule_type == "current_ytd":
+        fiscal_month = int(parameters.get("fiscal_year_start_month") or 1)
+        fiscal_year = (
+            maximum.year if maximum.month >= fiscal_month else maximum.year - 1
+        )
+        windows = [_window("current", date(fiscal_year, fiscal_month, 1), latest_end)]
+    elif rule_type == "current_vs_prior_year":
+        window_length = int(parameters.get("window_length") or 0)
+        if window_length < 1:
+            base["reason"] = "invalid_window_length"
+            return base
+        offset = int(parameters.get("comparison_offset_years") or 1)
+        current_start = _shift_period(latest_start, grain, -(window_length - 1))
+        baseline_start = _shift_years(current_start, -offset)
+        baseline_end = _shift_years(latest_end, -offset)
+        windows = [
+            _window("current", current_start, latest_end),
+            _window("baseline", baseline_start, baseline_end),
+        ]
+    elif rule_type == "current_ytd_vs_prior_ytd":
+        fiscal_month = int(parameters.get("fiscal_year_start_month") or 1)
+        fiscal_year = (
+            maximum.year if maximum.month >= fiscal_month else maximum.year - 1
+        )
+        current_start = date(fiscal_year, fiscal_month, 1)
+        offset = int(parameters.get("comparison_offset_years") or 1)
+        baseline_start = _shift_years(current_start, -offset)
+        baseline_end = _shift_years(latest_end, -offset)
+        windows = [
+            _window("current", current_start, latest_end),
+            _window("baseline", baseline_start, baseline_end),
+        ]
+    else:
+        base["reason"] = "unsupported_period_rule"
+        return base
+
+    available_periods, available_periods_complete = _available_period_starts(
+        profile, column, grain
+    )
+    if rule_type != "all_available" and available_periods_complete:
+        expected_periods = {
+            period_start
+            for window in windows
+            for period_start in _expected_period_starts(
+                _parse_profile_date(window["start"]),
+                _parse_profile_date(window["end"]),
+                grain,
+            )
+        }
+        missing_periods = sorted(expected_periods - available_periods)
+        base["coverage_check"] = {
+            "status": "complete" if not missing_periods else "missing_periods",
+            "missing_period_starts": [value.isoformat() for value in missing_periods],
+        }
+        if missing_periods:
+            base["reason"] = "snapshot_lacks_required_period_values"
+            return base
+    elif rule_type != "all_available":
+        base["coverage_check"] = {
+            "status": "not_proven_from_truncated_period_values",
+            "missing_period_starts": [],
+        }
+
+    baseline_windows = [window for window in windows if window["role"] == "baseline"]
+    if baseline_windows and any(
+        _parse_profile_date(window["start"]) < minimum
+        or _parse_profile_date(window["end"]) > _period_end(maximum, grain)
+        for window in baseline_windows
+    ):
+        base["reason"] = "snapshot_lacks_required_baseline_history"
+        return base
+    base["resolution_status"] = "resolved"
+    base["resolved_scope"] = {
+        "source_period_rule_id": rule_id,
+        "scope_type": rule.get("scope_type"),
+        "period_column": column,
+        "windows": windows,
+    }
+    return base
+
+
+def resolve_period_rules(
+    layer: dict[str, Any], profile: dict[str, Any]
+) -> dict[str, Any]:
+    """Resolve stable period rules from mechanically observed snapshot bounds."""
+
+    period_index = {
+        str(period.get("period_id")): period
+        for period in layer.get("periods") or []
+        if isinstance(period, dict) and period.get("period_id")
+    }
+    results = [
+        _resolve_period_rule(rule, period_index, profile)
+        for rule in layer.get("period_rules") or []
+        if isinstance(rule, dict)
+    ]
+    counts = {
+        status: sum(1 for result in results if result["resolution_status"] == status)
+        for status in ("resolved", "requires_runtime_input", "unavailable")
+    }
+    return {
+        "snapshot_fingerprint": canonical_snapshot_fingerprint(profile),
+        "results": results,
+        "counts": counts,
+        "boundary": (
+            "Resolution converts reviewed period rules into snapshot-specific bounds. "
+            "It does not establish business meaning or period completeness."
+        ),
+    }
+
+
+def _concept_snapshot_results(
+    layer: dict[str, Any], profile: dict[str, Any]
+) -> tuple[list[dict[str, Any]], set[str]]:
+    profile_columns = profile.get("columns") or {}
+    results: list[dict[str, Any]] = []
+    known_columns: set[str] = set()
+    direct_metric_status: dict[str, str] = {}
+    metrics = [
+        metric for metric in layer.get("metrics") or [] if isinstance(metric, dict)
+    ]
+    for metric in metrics:
+        metric_id = str(metric.get("metric_id"))
+        binding = metric.get("binding") or {}
+        column = binding.get("column")
+        if binding.get("binding_type") == "column" and column:
+            known_columns.add(str(column))
+            observed_role = (profile_columns.get(column) or {}).get("role")
+            if column not in profile_columns:
+                status, reason = "missing", "bound_metric_column_missing"
+            elif observed_role != "metric":
+                status, reason = "incompatible", "bound_metric_column_role_changed"
+            else:
+                status, reason = "compatible", None
+            direct_metric_status[metric_id] = status
+            results.append(
+                {
+                    "concept_id": metric_id,
+                    "kind": "metric",
+                    "semantic_status": metric.get("status"),
+                    "column": column,
+                    "status": status,
+                    "reason": reason,
+                    "observed_role": observed_role,
+                }
+            )
+    for metric in metrics:
+        binding = metric.get("binding") or {}
+        if binding.get("binding_type") != "derived":
+            continue
+        metric_id = str(metric.get("metric_id"))
+        input_ids = [str(value) for value in binding.get("input_metric_ids") or []]
+        incompatible_inputs = [
+            value
+            for value in input_ids
+            if direct_metric_status.get(value) != "compatible"
+        ]
+        status = "compatible" if not incompatible_inputs else "incompatible"
+        results.append(
+            {
+                "concept_id": metric_id,
+                "kind": "metric",
+                "semantic_status": metric.get("status"),
+                "column": None,
+                "status": status,
+                "reason": (
+                    None
+                    if status == "compatible"
+                    else "derived_metric_input_unavailable"
+                ),
+                "incompatible_input_metric_ids": incompatible_inputs,
+            }
+        )
+    for dimension in layer.get("dimensions") or []:
+        if not isinstance(dimension, dict):
+            continue
+        column = dimension.get("column")
+        if column:
+            known_columns.add(str(column))
+        observed_role = (profile_columns.get(column) or {}).get("role")
+        if column not in profile_columns:
+            status, reason = "missing", "bound_dimension_column_missing"
+        elif observed_role not in {"dimension", "identifier"}:
+            status, reason = "incompatible", "bound_dimension_column_role_changed"
+        else:
+            status, reason = "compatible", None
+        results.append(
+            {
+                "concept_id": dimension.get("dimension_id"),
+                "kind": "dimension",
+                "semantic_status": dimension.get("status"),
+                "column": column,
+                "status": status,
+                "reason": reason,
+                "observed_role": observed_role,
+            }
+        )
+    for period in layer.get("periods") or []:
+        if not isinstance(period, dict):
+            continue
+        column = period.get("column")
+        if column:
+            known_columns.add(str(column))
+        column_profile = profile_columns.get(column) or {}
+        observed_role = column_profile.get("role")
+        observed_grain = column_profile.get("period_grain") or (
+            column_profile.get("period_parseability") or {}
+        ).get("inferred_grain")
+        expected_grain = period.get("grain")
+        if column not in profile_columns:
+            status, reason = "missing", "bound_period_column_missing"
+        elif observed_role != "period":
+            status, reason = "incompatible", "bound_period_column_role_changed"
+        elif observed_grain not in {None, "unknown", expected_grain}:
+            status, reason = "incompatible", "bound_period_grain_changed"
+        else:
+            status, reason = "compatible", None
+        results.append(
+            {
+                "concept_id": period.get("period_id"),
+                "kind": "period",
+                "semantic_status": period.get("status"),
+                "column": column,
+                "status": status,
+                "reason": reason,
+                "observed_role": observed_role,
+                "expected_grain": expected_grain,
+                "observed_grain": observed_grain,
+            }
+        )
+    return results, known_columns
+
+
+def assess_snapshot_compatibility(
+    layer: dict[str, Any], profile: dict[str, Any]
+) -> dict[str, Any]:
+    """Check explicit identity and mechanical concept availability for one snapshot."""
+
+    raw_dataset_contract = layer.get("dataset_contract")
+    dataset_contract = (
+        raw_dataset_contract if isinstance(raw_dataset_contract, dict) else {}
+    )
+    contract_id = dataset_contract.get("dataset_contract_id")
+    snapshot_dataset_id = profile.get("dataset_id")
+    identity_matches = contract_id == snapshot_dataset_id
+    concept_results, known_columns = _concept_snapshot_results(layer, profile)
+    relevant_concepts = {
+        str(result["concept_id"]): result
+        for result in concept_results
+        if result.get("semantic_status") in {"defined", "conditional"}
+    }
+    period_resolution = resolve_period_rules(layer, profile)
+    period_results = {
+        str(result.get("period_rule_id")): result
+        for result in period_resolution["results"]
+    }
+    policy_results = []
+    for policy in layer.get("analysis_policies") or []:
+        if not isinstance(policy, dict):
+            continue
+        validity = policy.get("validity")
+        raw_role_bindings = policy.get("role_bindings")
+        role_bindings = raw_role_bindings if isinstance(raw_role_bindings, dict) else {}
+        bound_ids = sorted(
+            {
+                concept_id
+                for binding in role_bindings.values()
+                for concept_id in _binding_concept_ids(binding)
+            }
+        )
+        unavailable_concepts = [
+            concept_id
+            for concept_id in bound_ids
+            if (relevant_concepts.get(concept_id) or {}).get("status") != "compatible"
+        ]
+        period_rule_id = policy.get("period_rule_id")
+        period_result = (
+            period_results.get(str(period_rule_id)) if period_rule_id else None
+        )
+        if validity not in {"valid", "conditional"}:
+            availability = "not_applicable"
+        elif not identity_matches or unavailable_concepts:
+            availability = "unavailable"
+        elif period_result and period_result["resolution_status"] == "unavailable":
+            availability = "unavailable"
+        elif (
+            period_result
+            and period_result["resolution_status"] == "requires_runtime_input"
+        ):
+            availability = "available_with_runtime_input"
+        else:
+            availability = "available"
+        policy_results.append(
+            {
+                "analysis_id": policy.get("analysis_id"),
+                "validity": validity,
+                "availability": availability,
+                "unavailable_concept_ids": unavailable_concepts,
+                "period_rule_id": period_rule_id,
+                "period_resolution_status": (
+                    period_result.get("resolution_status") if period_result else None
+                ),
+            }
+        )
+
+    semantic_issues = [
+        result
+        for result in relevant_concepts.values()
+        if result.get("status") != "compatible"
+    ]
+    profile_columns = set((profile.get("columns") or {}).keys())
+    extension_columns = sorted(profile_columns - known_columns)
+    available_policy_count = sum(
+        result["availability"] in {"available", "available_with_runtime_input"}
+        for result in policy_results
+    )
+    reviewed_policy_count = sum(
+        result["validity"] in {"valid", "conditional"} for result in policy_results
+    )
+    if not identity_matches:
+        status = "incompatible"
+    elif semantic_issues and available_policy_count:
+        status = "partially_compatible"
+    elif semantic_issues:
+        status = "incompatible"
+    elif extension_columns:
+        status = "compatible_with_extensions"
+    else:
+        status = "compatible"
+    if status not in SNAPSHOT_COMPATIBILITY_STATUSES:
+        raise ValueError(f"Unexpected snapshot compatibility status: {status}")
+    return {
+        "status": status,
+        "semantic_layer_reusable": status != "incompatible",
+        "dataset_contract_id": contract_id,
+        "snapshot_dataset_id": snapshot_dataset_id,
+        "identity_matches": identity_matches,
+        "snapshot_fingerprint": canonical_snapshot_fingerprint(profile),
+        "origin_snapshot_matches": (
+            (
+                (dataset_contract.get("origin_snapshot") or {}).get(
+                    "snapshot_fingerprint"
+                )
+            )
+            == canonical_snapshot_fingerprint(profile)
+        ),
+        "extension_columns": extension_columns,
+        "concept_results": concept_results,
+        "semantic_issue_count": len(semantic_issues),
+        "policy_results": policy_results,
+        "reviewed_policy_count": reviewed_policy_count,
+        "available_policy_count": available_policy_count,
+        "period_resolution": period_resolution,
+        "boundary": (
+            "Compatibility checks explicit dataset identity and mechanically verifiable "
+            "bindings only. Equal schemas do not establish logical dataset identity, "
+            "and value changes do not change semantic meaning."
+        ),
+    }
+
+
+def build_snapshot_attachment(
+    layer: dict[str, Any], profile: dict[str, Any]
+) -> dict[str, Any]:
+    """Bind one uploaded snapshot to a reusable semantic version when compatible."""
+
+    compatibility = assess_snapshot_compatibility(layer, profile)
+    fingerprint = compatibility["snapshot_fingerprint"]
+    return {
+        "schema_version": "0.1",
+        "attachment_status": (
+            "attached" if compatibility["semantic_layer_reusable"] else "rejected"
+        ),
+        "dataset_contract_id": compatibility["dataset_contract_id"],
+        "semantic_layer_id": layer.get("semantic_layer_id"),
+        "semantic_version": layer.get("semantic_version"),
+        "business_metric_mappings": summarize_business_metric_mappings(layer),
+        "snapshot": {
+            "snapshot_id": f"snapshot.{fingerprint[:16]}",
+            "snapshot_fingerprint": fingerprint,
+            "profile_schema_version": profile.get("schema_version"),
+            "source": profile.get("source") or {},
+        },
+        "compatibility": compatibility,
+        "boundary": (
+            "An attachment reuses reviewed semantics for one compatible snapshot. "
+            "It does not regenerate semantic definitions or choose an analysis."
+        ),
+    }
+
+
+def validate_semantic_layer(
+    layer: dict[str, Any],
+    profile: dict[str, Any],
+    manifest: dict[str, Any],
+    *,
+    semantic_schema: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Validate wiring and provenance without judging semantic truth."""
+
+    errors: list[dict[str, Any]] = []
+    warnings: list[dict[str, Any]] = []
+    _check_json_schema(
+        layer,
+        semantic_schema or _load_json(DEFAULT_SEMANTIC_SCHEMA),
+        errors,
+    )
+    if layer.get("schema_version") != SEMANTIC_LAYER_SCHEMA_VERSION:
+        _issue(
+            errors,
+            "unsupported_schema_version",
+            "schema_version",
+            f"Expected {SEMANTIC_LAYER_SCHEMA_VERSION}.",
+        )
+    if not isinstance(layer.get("semantic_layer_id"), str) or not layer.get(
+        "semantic_layer_id"
+    ):
+        _issue(
+            errors,
+            "missing_id",
+            "semantic_layer_id",
+            "A semantic layer id is required.",
+        )
+
+    if (
+        not isinstance(layer.get("semantic_version"), int)
+        or layer.get("semantic_version", 0) < 1
+    ):
+        _issue(
+            errors,
+            "invalid_semantic_version",
+            "semantic_version",
+            "A positive semantic version is required.",
+        )
+
+    snapshot_fingerprint = canonical_snapshot_fingerprint(profile)
+    dataset_contract = layer.get("dataset_contract")
+    if not isinstance(dataset_contract, dict):
+        _issue(errors, "invalid_type", "dataset_contract", "Expected an object.")
+        dataset_contract = {}
+    contract_id = dataset_contract.get("dataset_contract_id")
+    origin_snapshot = dataset_contract.get("origin_snapshot")
+    if not isinstance(origin_snapshot, dict):
+        origin_snapshot = {}
+    origin_snapshot_fingerprint = origin_snapshot.get("snapshot_fingerprint")
+    origin_snapshot_matches = origin_snapshot_fingerprint == snapshot_fingerprint
+
+    scope = layer.get("scope")
+    if not isinstance(scope, dict):
+        _issue(errors, "invalid_type", "scope", "Expected an object.")
+        scope = {}
+    _check_enum(
+        scope.get("coverage_level"), COVERAGE_LEVELS, "scope.coverage_level", errors
+    )
+
+    sources, source_index = _records(layer, "sources", "source_id", errors)
+    evidence, evidence_index = _records(layer, "evidence", "evidence_id", errors)
+    for position, record in enumerate(sources):
+        path = f"sources[{position}]"
+        _check_enum(
+            record.get("authority"), SOURCE_AUTHORITIES, f"{path}.authority", errors
+        )
+        for field in ("source_type", "locator"):
+            if not isinstance(record.get(field), str) or not record.get(field).strip():
+                _issue(
+                    errors,
+                    "missing_source_field",
+                    f"{path}.{field}",
+                    "A non-empty source field is required.",
+                )
+    for position, record in enumerate(evidence):
+        path = f"evidence[{position}]"
+        if record.get("source_id") not in source_index:
+            _issue(
+                errors,
+                "unknown_source",
+                f"{path}.source_id",
+                f"Unknown source: {record.get('source_id')}",
+            )
+        _check_enum(
+            record.get("confidence"), CONFIDENCE_LEVELS, f"{path}.confidence", errors
+        )
+        _check_enum(record.get("status"), EVIDENCE_STATUSES, f"{path}.status", errors)
+        for field in ("locator", "claim"):
+            if not isinstance(record.get(field), str) or not record.get(field).strip():
+                _issue(
+                    errors,
+                    "missing_evidence_field",
+                    f"{path}.{field}",
+                    "A non-empty evidence field is required.",
+                )
+
+    metrics, metric_index = _records(layer, "metrics", "metric_id", errors)
+    dimensions, dimension_index = _records(layer, "dimensions", "dimension_id", errors)
+    periods, period_index = _records(layer, "periods", "period_id", errors)
+    concept_index: dict[str, tuple[str, dict[str, Any]]] = {}
+    for kind, records_by_id in (
+        ("metric", metric_index),
+        ("dimension", dimension_index),
+        ("period", period_index),
+    ):
+        for concept_id, record in records_by_id.items():
+            if concept_id in concept_index:
+                _issue(
+                    errors,
+                    "duplicate_concept_id",
+                    concept_id,
+                    "Concept ids must be unique across all concept types.",
+                )
+            concept_index[concept_id] = (kind, record)
+
+    profile_columns = profile.get("columns") or {}
+    derived_profile_metrics = profile.get("derived_metrics") or {}
+    for position, metric in enumerate(metrics):
+        path = f"metrics[{position}]"
+        _check_enum(metric.get("status"), CONCEPT_STATUSES, f"{path}.status", errors)
+        _check_enum(
+            metric.get("confidence"), CONFIDENCE_LEVELS, f"{path}.confidence", errors
+        )
+        _check_assertion_evidence(
+            metric,
+            status_key="status",
+            unknown_value="unknown",
+            path=path,
+            evidence_index=evidence_index,
+            source_index=source_index,
+            errors=errors,
+            warnings=warnings,
+        )
+        if metric.get("status") in {"defined", "conditional"}:
+            if (
+                not isinstance(metric.get("definition"), str)
+                or not metric.get("definition").strip()
+            ):
+                _issue(
+                    errors,
+                    "missing_semantic_definition",
+                    f"{path}.definition",
+                    "A defined or conditional metric needs a business definition.",
+                )
+            if (
+                not isinstance(metric.get("metric_class"), str)
+                or not metric.get("metric_class").strip()
+            ):
+                _issue(
+                    errors,
+                    "missing_metric_class",
+                    f"{path}.metric_class",
+                    "A defined or conditional metric needs a reviewed metric class.",
+                )
+            raw_aggregation = metric.get("aggregation")
+            aggregation = raw_aggregation if isinstance(raw_aggregation, dict) else {}
+            if aggregation.get("default") in {None, "", "unknown"}:
+                _issue(
+                    errors,
+                    "missing_aggregation",
+                    f"{path}.aggregation.default",
+                    "A defined or conditional metric needs a reviewed aggregation.",
+                )
+        binding = metric.get("binding")
+        if not isinstance(binding, dict):
+            _issue(
+                errors,
+                "invalid_metric_binding",
+                f"{path}.binding",
+                "Expected an object.",
+            )
+            continue
+        binding_type = binding.get("binding_type")
+        if binding_type == "column":
+            column = binding.get("column")
+            if origin_snapshot_matches and column not in profile_columns:
+                _issue(
+                    errors,
+                    "unknown_column",
+                    f"{path}.binding.column",
+                    f"Unknown profile column: {column}",
+                )
+            elif (
+                origin_snapshot_matches
+                and (profile_columns.get(column) or {}).get("role") != "metric"
+            ):
+                _issue(
+                    warnings,
+                    "profile_role_override",
+                    f"{path}.binding.column",
+                    f"Column {column} is not mechanically classified as a metric.",
+                )
+        elif binding_type == "derived":
+            input_ids = binding.get("input_metric_ids")
+            if not isinstance(input_ids, list) or not input_ids:
+                _issue(
+                    errors,
+                    "missing_inputs",
+                    f"{path}.binding.input_metric_ids",
+                    "A derived metric needs input metric ids.",
+                )
+            else:
+                for metric_id in input_ids:
+                    if metric_id not in metric_index:
+                        _issue(
+                            errors,
+                            "unknown_metric",
+                            f"{path}.binding.input_metric_ids",
+                            f"Unknown metric: {metric_id}",
+                        )
+            if not binding.get("expression"):
+                _issue(
+                    errors,
+                    "missing_expression",
+                    f"{path}.binding.expression",
+                    "A derived metric needs an expression.",
+                )
+            label = metric.get("label")
+            if origin_snapshot_matches and label not in derived_profile_metrics:
+                _issue(
+                    warnings,
+                    "unprofiled_derived_metric",
+                    f"{path}.label",
+                    "The derived metric is semantic-only and will require data preparation before rendering.",
+                )
+        else:
+            _issue(
+                errors,
+                "invalid_metric_binding",
+                f"{path}.binding.binding_type",
+                "Expected column or derived.",
+            )
+        raw_aggregation = metric.get("aggregation")
+        aggregation = raw_aggregation if isinstance(raw_aggregation, dict) else {}
+        weight_metric_id = aggregation.get("weight_metric_id")
+        if weight_metric_id is not None and weight_metric_id not in metric_index:
+            _issue(
+                errors,
+                "unknown_metric",
+                f"{path}.aggregation.weight_metric_id",
+                f"Unknown metric: {weight_metric_id}",
+            )
+        for key in ("compatible_dimension_ids", "forbidden_dimension_ids"):
+            for dimension_id in metric.get(key) or []:
+                if dimension_id not in dimension_index:
+                    _issue(
+                        errors,
+                        "unknown_dimension",
+                        f"{path}.{key}",
+                        f"Unknown dimension: {dimension_id}",
+                    )
+
+    business_metric_mapping_summary = _validate_business_metric_mappings(
+        layer,
+        metric_index=metric_index,
+        evidence_index=evidence_index,
+        source_index=source_index,
+        errors=errors,
+        warnings=warnings,
+    )
+
+    for position, dimension in enumerate(dimensions):
+        path = f"dimensions[{position}]"
+        _check_enum(dimension.get("status"), CONCEPT_STATUSES, f"{path}.status", errors)
+        _check_enum(
+            dimension.get("confidence"), CONFIDENCE_LEVELS, f"{path}.confidence", errors
+        )
+        _check_assertion_evidence(
+            dimension,
+            status_key="status",
+            unknown_value="unknown",
+            path=path,
+            evidence_index=evidence_index,
+            source_index=source_index,
+            errors=errors,
+            warnings=warnings,
+        )
+        if dimension.get("status") in {"defined", "conditional"}:
+            if (
+                not isinstance(dimension.get("definition"), str)
+                or not dimension.get("definition").strip()
+            ):
+                _issue(
+                    errors,
+                    "missing_semantic_definition",
+                    f"{path}.definition",
+                    "A defined or conditional dimension needs a business definition.",
+                )
+            if not dimension.get("valid_uses"):
+                _issue(
+                    errors,
+                    "missing_dimension_uses",
+                    f"{path}.valid_uses",
+                    "A defined or conditional dimension needs at least one valid use.",
+                )
+        column = dimension.get("column")
+        if origin_snapshot_matches and column not in profile_columns:
+            _issue(
+                errors,
+                "unknown_column",
+                f"{path}.column",
+                f"Unknown profile column: {column}",
+            )
+        elif origin_snapshot_matches and (profile_columns.get(column) or {}).get(
+            "role"
+        ) not in {
+            "dimension",
+            "identifier",
+        }:
+            _issue(
+                warnings,
+                "profile_role_override",
+                f"{path}.column",
+                f"Column {column} is not mechanically classified as a dimension or identifier.",
+            )
+        parent_id = dimension.get("hierarchy_parent_id")
+        if parent_id is not None and parent_id not in dimension_index:
+            _issue(
+                errors,
+                "unknown_dimension",
+                f"{path}.hierarchy_parent_id",
+                f"Unknown dimension: {parent_id}",
+            )
+
+    for position, period in enumerate(periods):
+        path = f"periods[{position}]"
+        _check_enum(period.get("status"), CONCEPT_STATUSES, f"{path}.status", errors)
+        _check_enum(
+            period.get("confidence"), CONFIDENCE_LEVELS, f"{path}.confidence", errors
+        )
+        _check_assertion_evidence(
+            period,
+            status_key="status",
+            unknown_value="unknown",
+            path=path,
+            evidence_index=evidence_index,
+            source_index=source_index,
+            errors=errors,
+            warnings=warnings,
+        )
+        if period.get("status") in {"defined", "conditional"}:
+            if (
+                not isinstance(period.get("definition"), str)
+                or not period.get("definition").strip()
+            ):
+                _issue(
+                    errors,
+                    "missing_semantic_definition",
+                    f"{path}.definition",
+                    "A defined or conditional period needs a business definition.",
+                )
+            if period.get("grain") in {None, "", "unknown"}:
+                _issue(
+                    errors,
+                    "missing_period_grain",
+                    f"{path}.grain",
+                    "A defined or conditional period needs a reviewed grain.",
+                )
+            if period.get("calendar") in {None, "", "unknown"}:
+                _issue(
+                    errors,
+                    "missing_period_calendar",
+                    f"{path}.calendar",
+                    "A defined or conditional period needs a reviewed calendar.",
+                )
+        column = period.get("column")
+        if origin_snapshot_matches and column not in profile_columns:
+            _issue(
+                errors,
+                "unknown_column",
+                f"{path}.column",
+                f"Unknown profile column: {column}",
+            )
+        elif (
+            origin_snapshot_matches
+            and (profile_columns.get(column) or {}).get("role") != "period"
+        ):
+            _issue(
+                warnings,
+                "profile_role_override",
+                f"{path}.column",
+                f"Column {column} is not mechanically classified as a period.",
+            )
+
+    period_rules, period_rule_index = _records(
+        layer, "period_rules", "period_rule_id", errors
+    )
+    expected_scope_by_rule = {
+        "all_available": "all_available",
+        "latest_available_period": "single",
+        "trailing_periods": "single",
+        "current_ytd": "single",
+        "current_vs_prior_year": "comparison_pair",
+        "current_ytd_vs_prior_ytd": "comparison_pair",
+        "caller_bounded": "single",
+    }
+    for position, period_rule in enumerate(period_rules):
+        path = f"period_rules[{position}]"
+        rule_type = period_rule.get("rule_type")
+        scope_type = period_rule.get("scope_type")
+        _check_enum(rule_type, PERIOD_RULE_TYPES, f"{path}.rule_type", errors)
+        _check_enum(scope_type, PERIOD_SCOPE_TYPES, f"{path}.scope_type", errors)
+        _check_enum(
+            period_rule.get("status"), CONCEPT_STATUSES, f"{path}.status", errors
+        )
+        _check_enum(
+            period_rule.get("confidence"),
+            CONFIDENCE_LEVELS,
+            f"{path}.confidence",
+            errors,
+        )
+        _check_assertion_evidence(
+            period_rule,
+            status_key="status",
+            unknown_value="unknown",
+            path=path,
+            evidence_index=evidence_index,
+            source_index=source_index,
+            errors=errors,
+            warnings=warnings,
+        )
+        period_free_all_data = (
+            period_rule.get("period_id") is None
+            and rule_type == "all_available"
+            and scope_type == "all_available"
+        )
+        if (
+            period_rule.get("period_id") not in period_index
+            and not period_free_all_data
+        ):
+            _issue(
+                errors,
+                "unknown_period",
+                f"{path}.period_id",
+                f"Unknown period: {period_rule.get('period_id')}",
+            )
+        expected_scope = expected_scope_by_rule.get(str(rule_type))
+        if expected_scope is not None and scope_type != expected_scope:
+            _issue(
+                errors,
+                "period_rule_scope_mismatch",
+                f"{path}.scope_type",
+                f"Rule {rule_type} requires scope type {expected_scope}.",
+            )
+        parameters = period_rule.get("parameters")
+        if not isinstance(parameters, dict):
+            _issue(errors, "invalid_type", f"{path}.parameters", "Expected an object.")
+            parameters = {}
+        if rule_type in {
+            "trailing_periods",
+            "current_vs_prior_year",
+        } and not isinstance(parameters.get("window_length"), int):
+            _issue(
+                errors,
+                "missing_period_rule_window_length",
+                f"{path}.parameters.window_length",
+                f"Rule {rule_type} requires a positive window length.",
+            )
+        requires_runtime_bounds = parameters.get("requires_runtime_bounds")
+        if rule_type == "caller_bounded" and requires_runtime_bounds is not True:
+            _issue(
+                errors,
+                "caller_bounded_rule_requires_runtime_bounds",
+                f"{path}.parameters.requires_runtime_bounds",
+                "A caller-bounded rule must require runtime bounds.",
+            )
+        elif (
+            rule_type != "caller_bounded"
+            and not period_free_all_data
+            and requires_runtime_bounds is not False
+        ):
+            _issue(
+                errors,
+                "unexpected_runtime_bounds_requirement",
+                f"{path}.parameters.requires_runtime_bounds",
+                f"Rule {rule_type} resolves from snapshot data and must not require caller bounds.",
+            )
+
+    analysis_tasks = manifest.get("analysis_tasks") or {}
+    catalog_index = _analysis_catalog_index(manifest)
+    role_registry = manifest.get("role_registry") or {}
+    policies, _ = _records(layer, "analysis_policies", "analysis_id", errors)
+    policy_results: list[dict[str, Any]] = []
+    for position, policy in enumerate(policies):
+        path = f"analysis_policies[{position}]"
+        validity = policy.get("validity")
+        _check_enum(validity, ANALYSIS_VALIDITIES, f"{path}.validity", errors)
+        _check_enum(
+            policy.get("confidence"), CONFIDENCE_LEVELS, f"{path}.confidence", errors
+        )
+        _check_assertion_evidence(
+            policy,
+            status_key="validity",
+            unknown_value="unknown",
+            path=path,
+            evidence_index=evidence_index,
+            source_index=source_index,
+            errors=errors,
+            warnings=warnings,
+        )
+        if validity != "unknown":
+            for field in ("question_family", "business_purpose"):
+                if (
+                    not isinstance(policy.get(field), str)
+                    or not policy.get(field).strip()
+                ):
+                    _issue(
+                        errors,
+                        "missing_analysis_field",
+                        f"{path}.{field}",
+                        "A reviewed analysis policy needs a non-empty field.",
+                    )
+        task_ids = policy.get("analysis_task_ids") or []
+        emphases = policy.get("selection_emphases") or []
+        for task_id in task_ids:
+            if task_id not in analysis_tasks:
+                _issue(
+                    errors,
+                    "unknown_analysis_task",
+                    f"{path}.analysis_task_ids",
+                    f"Unknown analysis task: {task_id}",
+                )
+        catalog_records = []
+        for emphasis in emphases:
+            record = catalog_index.get(str(emphasis))
+            if record is None:
+                _issue(
+                    errors,
+                    "unknown_selection_emphasis",
+                    f"{path}.selection_emphases",
+                    f"Unknown selection emphasis: {emphasis}",
+                )
+                continue
+            catalog_records.append(record)
+            if task_ids and not set(task_ids) & set(record["analysis_task_ids"]):
+                _issue(
+                    errors,
+                    "task_emphasis_mismatch",
+                    f"{path}.selection_emphases",
+                    f"Selection emphasis {emphasis} is not registered under {task_ids}.",
+                )
+        if validity in {"valid", "conditional"} and not catalog_records:
+            _issue(
+                errors,
+                "missing_manifest_join",
+                f"{path}.selection_emphases",
+                "A valid or conditional policy must join to a manifest selection emphasis.",
+            )
+
+        role_bindings = policy.get("role_bindings")
+        if not isinstance(role_bindings, dict):
+            _issue(
+                errors, "invalid_type", f"{path}.role_bindings", "Expected an object."
+            )
+            role_bindings = {}
+        for role, binding in role_bindings.items():
+            _check_role_binding(
+                role=str(role),
+                binding=binding,
+                path=f"{path}.role_bindings.{role}",
+                concept_index=concept_index,
+                role_registry=role_registry,
+                source_index=source_index,
+                errors=errors,
+                warnings=warnings,
+            )
+
+        period_rule_id = policy.get("period_rule_id")
+        if period_rule_id is not None and period_rule_id not in period_rule_index:
+            _issue(
+                errors,
+                "unknown_period_rule",
+                f"{path}.period_rule_id",
+                f"Unknown period rule: {period_rule_id}",
+            )
+
+        policy_semantic_mismatches = _policy_semantic_mismatches(
+            validity=validity,
+            role_bindings=role_bindings,
+            period_rule_id=period_rule_id,
+            concept_index=concept_index,
+            period_rule_index=period_rule_index,
+        )
+        data_preparation_requirements = []
+        for role, binding in role_bindings.items():
+            for concept_id in _binding_concept_ids(binding):
+                concept = concept_index.get(concept_id)
+                metric_binding = (
+                    concept[1].get("binding")
+                    if concept is not None and concept[0] == "metric"
+                    else None
+                )
+                if (
+                    isinstance(metric_binding, dict)
+                    and metric_binding.get("binding_type") == "derived"
+                ):
+                    data_preparation_requirements.append(
+                        {
+                            "role": role,
+                            "metric_id": concept_id,
+                            "requirement": "materialize_reviewed_derived_metric",
+                            "expression": metric_binding.get("expression"),
+                        }
+                    )
+
+        role_sets = [
+            role_set
+            for record in catalog_records
+            for role_set in record.get("required_role_sets") or []
+        ]
+        role_set_results = []
+        for role_set in role_sets:
+            required_role_contracts = role_set.get("roles") or []
+            required_roles = [item["role"] for item in required_role_contracts]
+            missing_roles = [
+                role for role in required_roles if role not in role_bindings
+            ]
+            unresolved_roles = [
+                role
+                for role in required_roles
+                if role in role_bindings
+                and isinstance(role_bindings[role], dict)
+                and not _binding_is_resolved(role_bindings[role])
+            ]
+            scope_contract = role_set.get("period_scope_contract") or {}
+            comparison_scope_required = bool(
+                scope_contract.get("comparison_pair_required_for_render", False)
+            )
+            explicit_scope_required = bool(
+                scope_contract.get("scope_required_for_render", False)
+            )
+            scope_missing = (
+                comparison_scope_required or explicit_scope_required
+            ) and period_rule_id is None
+            wrong_scope_type = False
+            if comparison_scope_required and period_rule_id in period_rule_index:
+                wrong_scope_type = (
+                    period_rule_index[period_rule_id].get("scope_type")
+                    != "comparison_pair"
+                )
+            if (
+                period_rule_id in period_rule_index
+                and period_rule_index[period_rule_id].get("period_id") is None
+            ):
+                wrong_scope_type = wrong_scope_type or bool(
+                    scope_contract.get("period_column_required")
+                    or not scope_contract.get("explicit_all_data_allowed")
+                )
+            semantic_mismatches = list(policy_semantic_mismatches)
+            for role_contract in required_role_contracts:
+                role = role_contract["role"]
+                accepted_metric_classes = set(
+                    role_contract.get("accepted_metric_classes") or []
+                )
+                if not accepted_metric_classes:
+                    continue
+                binding = role_bindings.get(role)
+                for concept_id in _binding_concept_ids(binding):
+                    concept = concept_index.get(concept_id)
+                    if concept is None or concept[0] != "metric":
+                        continue
+                    metric_class = concept[1].get("metric_class")
+                    if metric_class not in accepted_metric_classes:
+                        semantic_mismatches.append(
+                            {
+                                "code": "metric_class_not_accepted",
+                                "role": role,
+                                "metric_id": concept_id,
+                                "metric_class": metric_class,
+                                "accepted_metric_classes": sorted(
+                                    accepted_metric_classes
+                                ),
+                                "message": (
+                                    f"Role {role} does not accept metric class "
+                                    f"{metric_class!r}."
+                                ),
+                            }
+                        )
+            complete = (
+                not missing_roles
+                and not unresolved_roles
+                and not scope_missing
+                and not wrong_scope_type
+                and not semantic_mismatches
+            )
+            role_set_results.append(
+                {
+                    "capability_id": role_set.get("capability_id"),
+                    "required_roles": required_roles,
+                    "missing_roles": missing_roles,
+                    "unresolved_roles": unresolved_roles,
+                    "period_rule_required": explicit_scope_required,
+                    "comparison_scope_required": comparison_scope_required,
+                    "scope_missing": scope_missing,
+                    "wrong_scope_type": wrong_scope_type,
+                    "semantic_mismatches": semantic_mismatches,
+                    "complete": complete,
+                }
+            )
+        has_complete_role_set = any(result["complete"] for result in role_set_results)
+        conditions = policy.get("conditions")
+        conditional_conditions_complete = validity != "conditional" or (
+            isinstance(conditions, list)
+            and any(
+                isinstance(condition, str) and condition.strip()
+                for condition in conditions
+            )
+        )
+        if validity == "valid" and role_sets and not has_complete_role_set:
+            _issue(
+                errors,
+                "incomplete_manifest_role_binding",
+                f"{path}.role_bindings",
+                "A valid policy must completely bind at least one joined manifest capability.",
+            )
+        elif validity == "conditional" and role_sets and not has_complete_role_set:
+            _issue(
+                warnings,
+                "conditional_role_binding_incomplete",
+                f"{path}.role_bindings",
+                "No joined capability is fully bound; the policy conditions must resolve this before use.",
+            )
+        if validity == "conditional" and not conditional_conditions_complete:
+            _issue(
+                warnings,
+                "conditional_conditions_incomplete",
+                f"{path}.conditions",
+                "A conditional policy needs at least one explicit, non-empty condition before use.",
+            )
+        policy_results.append(
+            {
+                "analysis_id": policy.get("analysis_id"),
+                "validity": validity,
+                "selection_emphases": emphases,
+                "candidate_capability_ids": sorted(
+                    {
+                        capability_id
+                        for record in catalog_records
+                        for capability_id in record.get("capability_ids") or []
+                    }
+                ),
+                "role_set_results": role_set_results,
+                "has_complete_manifest_role_set": has_complete_role_set,
+                "conditional_conditions_complete": conditional_conditions_complete,
+                "usable_as_semantic_input": (
+                    validity in {"valid", "conditional"}
+                    and has_complete_role_set
+                    and conditional_conditions_complete
+                ),
+                "data_preparation_requirements": data_preparation_requirements,
+            }
+        )
+
+    open_questions, _ = _records(layer, "open_questions", "question_id", errors)
+    review = layer.get("review")
+    if not isinstance(review, dict):
+        _issue(errors, "invalid_type", "review", "Expected an object.")
+        review = {}
+    _check_enum(review.get("status"), REVIEW_STATUSES, "review.status", errors)
+    if review.get("status") == "human_reviewed":
+        if not review.get("reviewed_by"):
+            _issue(
+                errors,
+                "missing_reviewer",
+                "review.reviewed_by",
+                "Human-reviewed layers need a reviewer.",
+            )
+        _check_iso_date(review.get("reviewed_at"), "review.reviewed_at", errors)
+        if not review.get("reviewed_at"):
+            _issue(
+                errors,
+                "missing_review_date",
+                "review.reviewed_at",
+                "Human-reviewed layers need a review date.",
+            )
+    if review.get("status") != "draft" and not policies:
+        _issue(
+            warnings,
+            "reviewed_without_policies",
+            "analysis_policies",
+            "The layer is marked reviewed but contains no analysis policy.",
+        )
+    if review.get("status") != "draft" and scope.get("coverage_level") == "unreviewed":
+        _issue(
+            errors,
+            "reviewed_layer_has_unreviewed_coverage",
+            "scope.coverage_level",
+            "A reviewed layer must state a reviewed source-coverage level.",
+        )
+
+    boundaries = layer.get("boundaries")
+    if not isinstance(boundaries, dict):
+        _issue(errors, "invalid_type", "boundaries", "Expected an object.")
+    else:
+        if boundaries.get("chart_selection_included") is not False:
+            _issue(
+                errors,
+                "semantic_boundary_violation",
+                "boundaries.chart_selection_included",
+                "The semantic layer must not claim to select a chart.",
+            )
+        if boundaries.get("rendering_included") is not False:
+            _issue(
+                errors,
+                "semantic_boundary_violation",
+                "boundaries.rendering_included",
+                "The semantic layer must not claim to render charts.",
+            )
+
+    unknown_concepts = sum(
+        1
+        for record in [*metrics, *dimensions, *periods]
+        if record.get("status") == "unknown"
+    )
+    validity_counts = {
+        value: sum(1 for policy in policies if policy.get("validity") == value)
+        for value in sorted(ANALYSIS_VALIDITIES)
+    }
+    review_status = review.get("status")
+    usable_policy_count = sum(
+        1 for result in policy_results if result["usable_as_semantic_input"]
+    )
+    if errors:
+        semantic_readiness = "contract_invalid"
+    elif review_status == "draft":
+        semantic_readiness = "draft_unreviewed"
+    elif business_metric_mapping_summary["status"] != "resolved":
+        semantic_readiness = "reviewed_with_unresolved_business_metric_mappings"
+    elif usable_policy_count == 0:
+        semantic_readiness = "reviewed_no_usable_analysis_policies"
+    elif unknown_concepts:
+        semantic_readiness = "reviewed_with_unresolved_concepts"
+    else:
+        semantic_readiness = "ready_as_scoped_semantic_input"
+    assessed_selection_emphases = sorted(
+        {
+            str(emphasis)
+            for policy in policies
+            for emphasis in policy.get("selection_emphases") or []
+            if str(emphasis) in catalog_index
+        }
+    )
+    unassessed_selection_emphases = sorted(
+        set(catalog_index) - set(assessed_selection_emphases)
+    )
+    snapshot_compatibility = assess_snapshot_compatibility(layer, profile)
+    return {
+        "schema_version": SEMANTIC_LAYER_SCHEMA_VERSION,
+        "semantic_layer_id": layer.get("semantic_layer_id"),
+        "semantic_version": layer.get("semantic_version"),
+        "status": "contract_valid" if not errors else "contract_invalid",
+        "semantic_readiness": semantic_readiness,
+        "dataset_contract": {
+            "dataset_contract_id": contract_id,
+            "contract_version": dataset_contract.get("contract_version"),
+        },
+        "business_metric_mappings": business_metric_mapping_summary["roles"],
+        "business_metric_mapping_status": business_metric_mapping_summary["status"],
+        "snapshot": {
+            "dataset_id": profile.get("dataset_id"),
+            "snapshot_fingerprint": snapshot_fingerprint,
+            "is_origin_snapshot": origin_snapshot_matches,
+            "compatibility": snapshot_compatibility,
+        },
+        "counts": {
+            "sources": len(sources),
+            "evidence": len(evidence),
+            "metrics": len(metrics),
+            "dimensions": len(dimensions),
+            "periods": len(periods),
+            "period_rules": len(period_rules),
+            "analysis_policies": len(policies),
+            "assessed_selection_emphases": len(assessed_selection_emphases),
+            "unassessed_selection_emphases": len(unassessed_selection_emphases),
+            "open_questions": len(open_questions),
+            "unknown_concepts": unknown_concepts,
+            "business_metric_mapping_states": business_metric_mapping_summary[
+                "state_counts"
+            ],
+            "analysis_validities": validity_counts,
+            "errors": len(errors),
+            "warnings": len(warnings),
+        },
+        "policy_results": policy_results,
+        "analysis_coverage": {
+            "manifest_selection_emphasis_count": len(catalog_index),
+            "assessed_selection_emphases": assessed_selection_emphases,
+            "unassessed_selection_emphases": unassessed_selection_emphases,
+            "unlisted_policy_default": "unknown",
+        },
+        "errors": errors,
+        "warnings": warnings,
+        "boundary": (
+            "Pass means the stable semantic document is internally coherent and "
+            "wired to the manifest. Snapshot compatibility is reported separately; "
+            "neither result proves that business judgments are true."
+        ),
+    }
+
+
+def build_semantic_acceptance_summary(
+    profile: dict[str, Any],
+    layer: dict[str, Any],
+    manifest: dict[str, Any],
+    *,
+    dataset_path: Path,
+    layer_path: Path,
+    manifest_path: Path,
+    schema_path: Path,
+    source_paths: list[Path],
+    snapshot_cases: list[tuple[str, str, Path, dict[str, Any]]] | None = None,
+    snapshot_suite_path: Path | None = None,
+) -> dict[str, Any]:
+    """Bind reviewed semantics and recurring-snapshot proofs to exact digests."""
+
+    validation = validate_semantic_layer(
+        layer,
+        profile,
+        manifest,
+        semantic_schema=_load_json(schema_path),
+    )
+    origin_attachment = build_snapshot_attachment(layer, profile)
+    compatibility_cases = [
+        {
+            "case_id": "origin_snapshot",
+            "expected_status": "compatible",
+            "dataset_path": dataset_path,
+            "attachment": origin_attachment,
+        },
+        *[
+            {
+                "case_id": case_id,
+                "expected_status": expected_status,
+                "dataset_path": case_path,
+                "attachment": build_snapshot_attachment(layer, case_profile),
+            }
+            for case_id, expected_status, case_path, case_profile in (
+                snapshot_cases or []
+            )
+        ],
+    ]
+    compatibility_passed = all(
+        case["attachment"]["compatibility"]["status"] == case["expected_status"]
+        for case in compatibility_cases
+    )
+    acceptance_passed = (
+        validation["status"] == "contract_valid"
+        and validation["semantic_readiness"] == "ready_as_scoped_semantic_input"
+        and compatibility_passed
+    )
+    return {
+        "schema_version": "0.2",
+        "result": "pass" if acceptance_passed else "fail",
+        "semantic_layer_id": layer.get("semantic_layer_id"),
+        "semantic_version": layer.get("semantic_version"),
+        "inputs": {
+            "manifest": {
+                "path": _portable_component_path(manifest_path),
+                "sha256": _sha256_file(manifest_path),
+            },
+            "semantic_schema": {
+                "path": _portable_component_path(schema_path),
+                "sha256": _sha256_file(schema_path),
+            },
+            "dataset": {
+                "path": _portable_component_path(dataset_path),
+                "sha256": _sha256_file(dataset_path),
+            },
+            "semantic_layer": {
+                "path": _portable_component_path(layer_path),
+                "sha256": _sha256_file(layer_path),
+            },
+            "semantic_sources": [
+                {
+                    "path": _portable_component_path(source_path),
+                    "sha256": _sha256_file(source_path),
+                }
+                for source_path in source_paths
+            ],
+            "snapshot_suite": (
+                {
+                    "path": _portable_component_path(snapshot_suite_path),
+                    "sha256": _sha256_file(snapshot_suite_path),
+                }
+                if snapshot_suite_path is not None
+                else None
+            ),
+            "snapshot_cases": [
+                {
+                    "case_id": case["case_id"],
+                    "path": _portable_component_path(case["dataset_path"]),
+                    "sha256": _sha256_file(case["dataset_path"]),
+                }
+                for case in compatibility_cases
+            ],
+        },
+        "dataset_contract": {
+            "dataset_contract_id": (
+                (layer.get("dataset_contract") or {}).get("dataset_contract_id")
+            ),
+            "contract_version": (
+                (layer.get("dataset_contract") or {}).get("contract_version")
+            ),
+        },
+        "validation": {
+            "status": validation["status"],
+            "semantic_readiness": validation["semantic_readiness"],
+            "counts": validation["counts"],
+            "analysis_coverage": validation["analysis_coverage"],
+            "errors": validation["errors"],
+            "warnings": validation["warnings"],
+        },
+        "policy_proof": [
+            {
+                "analysis_id": result["analysis_id"],
+                "validity": result["validity"],
+                "candidate_capability_ids": result["candidate_capability_ids"],
+                "has_complete_manifest_role_set": result[
+                    "has_complete_manifest_role_set"
+                ],
+                "data_preparation_requirements": result[
+                    "data_preparation_requirements"
+                ],
+            }
+            for result in validation["policy_results"]
+        ],
+        "snapshot_reuse_proof": [
+            {
+                "case_id": case["case_id"],
+                "expected_status": case["expected_status"],
+                "actual_status": case["attachment"]["compatibility"]["status"],
+                "semantic_layer_reusable": case["attachment"]["compatibility"][
+                    "semantic_layer_reusable"
+                ],
+                "snapshot_fingerprint": case["attachment"]["snapshot"][
+                    "snapshot_fingerprint"
+                ],
+                "extension_columns": case["attachment"]["compatibility"][
+                    "extension_columns"
+                ],
+                "available_policy_count": case["attachment"]["compatibility"][
+                    "available_policy_count"
+                ],
+                "period_resolution_counts": case["attachment"]["compatibility"][
+                    "period_resolution"
+                ]["counts"],
+                "resolved_period_rules": [
+                    {
+                        "period_rule_id": resolution["period_rule_id"],
+                        "resolution_status": resolution["resolution_status"],
+                        "resolved_scope": resolution["resolved_scope"],
+                    }
+                    for resolution in case["attachment"]["compatibility"][
+                        "period_resolution"
+                    ]["results"]
+                ],
+            }
+            for case in compatibility_cases
+        ],
+        "boundary": (
+            "This acceptance proves stable semantic-contract wiring and expected "
+            "reuse outcomes for exact packaged snapshots. It does not infer dataset "
+            "identity, prove semantic truth, select an analysis, or render a chart."
+        ),
+    }
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    init_parser = subparsers.add_parser("init", help="Create an unreviewed scaffold.")
+    init_parser.add_argument("--profile", type=Path, required=True)
+    init_parser.add_argument("--output", type=Path, required=True)
+    init_parser.add_argument("--dataset-contract-id")
+    init_parser.add_argument("--semantic-layer-id")
+    init_parser.add_argument("--semantic-version", type=int, default=1)
+    init_parser.add_argument(
+        "--identity-method",
+        choices=["caller_assigned", "source_connector", "project_configuration"],
+        default="caller_assigned",
+    )
+    init_parser.add_argument("--identity-value")
+
+    context_parser = subparsers.add_parser(
+        "context", help="Build a model-facing semantic authoring context."
+    )
+    context_parser.add_argument("--profile", type=Path, required=True)
+    context_parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    context_parser.add_argument("--layer", type=Path)
+    context_parser.add_argument("--output", type=Path, required=True)
+
+    validate_parser = subparsers.add_parser(
+        "validate", help="Validate semantic wiring against profile and manifest."
+    )
+    validate_parser.add_argument("--layer", type=Path, required=True)
+    validate_parser.add_argument("--profile", type=Path, required=True)
+    validate_parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    validate_parser.add_argument("--schema", type=Path, default=DEFAULT_SEMANTIC_SCHEMA)
+    validate_parser.add_argument("--output", type=Path)
+
+    attach_parser = subparsers.add_parser(
+        "attach", help="Attach a compatible snapshot to an existing semantic version."
+    )
+    attach_parser.add_argument("--layer", type=Path, required=True)
+    attach_parser.add_argument("--profile", type=Path, required=True)
+    attach_parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    attach_parser.add_argument("--schema", type=Path, default=DEFAULT_SEMANTIC_SCHEMA)
+    attach_parser.add_argument("--output", type=Path, required=True)
+
+    acceptance_parser = subparsers.add_parser(
+        "acceptance", help="Validate a reviewed fixture and bind exact digests."
+    )
+    acceptance_parser.add_argument("--dataset", type=Path, required=True)
+    acceptance_parser.add_argument("--dataset-id", required=True)
+    acceptance_parser.add_argument("--layer", type=Path, required=True)
+    acceptance_parser.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    acceptance_parser.add_argument(
+        "--schema", type=Path, default=DEFAULT_SEMANTIC_SCHEMA
+    )
+    acceptance_parser.add_argument("--source", type=Path, action="append", default=[])
+    acceptance_parser.add_argument("--snapshot-suite", type=Path)
+    acceptance_parser.add_argument("--output", type=Path, required=True)
+    return parser
+
+
+def _load_snapshot_cases(
+    suite_path: Path | None, dataset_contract_id: str
+) -> list[tuple[str, str, Path, dict[str, Any]]]:
+    if suite_path is None:
+        return []
+    suite = _load_json(suite_path)
+    if suite.get("dataset_contract_id") != dataset_contract_id:
+        raise ValueError(
+            "Snapshot suite dataset_contract_id does not match the acceptance run."
+        )
+    cases: list[tuple[str, str, Path, dict[str, Any]]] = []
+    for raw_case in suite.get("cases") or []:
+        if not isinstance(raw_case, dict):
+            raise ValueError("Snapshot suite cases must be objects.")
+        case_id = str(raw_case.get("case_id") or "")
+        expected_status = str(raw_case.get("expected_status") or "")
+        relative_path = raw_case.get("dataset")
+        if not case_id or expected_status not in SNAPSHOT_COMPATIBILITY_STATUSES:
+            raise ValueError(f"Invalid snapshot compatibility case: {raw_case!r}")
+        if not isinstance(relative_path, str) or not relative_path:
+            raise ValueError(f"Snapshot case {case_id} needs a dataset path.")
+        dataset_path = (suite_path.parent / relative_path).resolve()
+        profile = _profile_dataset_for_acceptance(dataset_path, dataset_contract_id)
+        cases.append((case_id, expected_status, dataset_path, profile))
+    return cases
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run semantic scaffolding, context, validation, or fixture acceptance."""
+
+    args = _parser().parse_args(argv)
+    if args.command == "acceptance":
+        profile = _profile_dataset_for_acceptance(args.dataset, args.dataset_id)
+        manifest = _load_json(args.manifest)
+        layer = _load_json(args.layer)
+        snapshot_cases = _load_snapshot_cases(args.snapshot_suite, args.dataset_id)
+        payload = build_semantic_acceptance_summary(
+            profile,
+            layer,
+            manifest,
+            dataset_path=args.dataset,
+            layer_path=args.layer,
+            manifest_path=args.manifest,
+            schema_path=args.schema,
+            source_paths=args.source,
+            snapshot_cases=snapshot_cases,
+            snapshot_suite_path=args.snapshot_suite,
+        )
+        _write_json(args.output, payload)
+        sys.stdout.write(f"{args.output}\n")
+        return 0 if payload["result"] == "pass" else 1
+
+    profile = _load_json(args.profile)
+    if args.command == "init":
+        payload = build_semantic_layer_scaffold(
+            profile,
+            dataset_contract_id=args.dataset_contract_id,
+            semantic_layer_id=args.semantic_layer_id,
+            semantic_version=args.semantic_version,
+            identity_method=args.identity_method,
+            identity_value=args.identity_value,
+            profile_locator=str(args.profile),
+        )
+        _write_json(args.output, payload)
+        sys.stdout.write(f"{args.output}\n")
+        return 0
+
+    manifest = _load_json(args.manifest)
+    if args.command == "context":
+        layer = _load_json(args.layer) if args.layer else None
+        payload = build_authoring_context(profile, manifest, semantic_layer=layer)
+        _write_json(args.output, payload)
+        sys.stdout.write(f"{args.output}\n")
+        return 0
+
+    layer = _load_json(args.layer)
+    report = validate_semantic_layer(
+        layer,
+        profile,
+        manifest,
+        semantic_schema=_load_json(args.schema),
+    )
+    if args.command == "attach":
+        attachment = build_snapshot_attachment(layer, profile)
+        attachment["semantic_contract_validation"] = {
+            "status": report["status"],
+            "semantic_readiness": report["semantic_readiness"],
+            "errors": report["errors"],
+        }
+        if report["status"] != "contract_valid":
+            attachment["attachment_status"] = "rejected"
+        _write_json(args.output, attachment)
+        sys.stdout.write(f"{args.output}\n")
+        return 0 if attachment["attachment_status"] == "attached" else 1
+    if args.output:
+        _write_json(args.output, report)
+        sys.stdout.write(f"{args.output}\n")
+    else:
+        sys.stdout.write(json.dumps(report, indent=2, ensure_ascii=False) + "\n")
+    return 0 if report["status"] == "contract_valid" else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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/reporting-engine/scripts/semantic_layer.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`