--- before
+++ after
@@ -0,0 +1,8071 @@
+"""Mechanical helpers for the Clara Codex plugin."""
+
+from __future__ import annotations
+
+import html
+import json
+import logging
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+import uuid
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from hashlib import sha256
+from pathlib import Path
+from typing import Any, Iterable, Mapping, Sequence
+from zipfile import ZIP_DEFLATED, BadZipFile, ZipFile
+
+from advisory_evidence_lineage import (
+    CLAIM_REGISTER_FILENAME,
+    EVIDENCE_REGISTER_FILENAME,
+    bind_claim_appearances,
+    initialize_lineage,
+    record_claims,
+    record_evidence,
+    render_evidence_map,
+    validate_lineage,
+    validate_lineage_payloads,
+)
+from bounded_process import run_process
+from case_exchange_safety import load_exchange, validate_destinations
+from case_store import (
+    atomic_bytes,
+    atomic_stream,
+    atomic_text,
+    case_operation,
+    case_reader,
+    track_write,
+)
+from decision_narrative import NARRATIVE_FILENAME, commit_narrative, load_narrative
+from defusedxml.ElementTree import fromstring as parse_xml
+from html_deck_runtime import (
+    apply_fixed_16_9_deck_runtime,
+    assert_fixed_16_9_deck_runtime,
+)
+from jsonschema import Draft202012Validator
+
+LOGGER = logging.getLogger(__name__)
+
+__all__ = [
+    "CASE_BRIEF_FILENAME",
+    "CASE_DIRECTION_RETURNS_DIRNAME",
+    "ADVISORY_WORKPAPER_CHECKPOINT_FILENAME",
+    "ADVISORY_WORKPAPER_FILENAME",
+    "CLARA_KICKOFF_PREPARATION_FILENAME",
+    "CLARA_KICKOFF_DECK_FILENAME",
+    "CLARA_MANDATE_FILENAME",
+    "CLARA_PARTNER_BRIEF_FILENAME",
+    "CASE_FILES",
+    "INCLUSION_BUNDLES_FILENAME",
+    "CaseWorkspaceError",
+    "UnsupportedMaterialTypeError",
+    "CaseExchangeExportResult",
+    "CaseExchangeImportResult",
+    "EditablePptxMergeInputResult",
+    "CaseFileCopyResult",
+    "LegacyPptxNormalizationResult",
+    "CaseSupportPackageResult",
+    "CaseWorkspaceArchiveResult",
+    "MaterialDeleteResult",
+    "CaseBriefResult",
+    "ClaraKickoffPreparationResult",
+    "ClaraKickoffDeckResult",
+    "ClaraPartnerBriefResult",
+    "DecisionPackResult",
+    "InclusionBundleApplyResult",
+    "InclusionReviewResult",
+    "ISSUE_STATUSES",
+    "JUDGEMENT_KINDS",
+    "JUDGEMENT_STATUSES",
+    "MATERIAL_STATUSES",
+    "MATERIAL_TYPES",
+    "OPEN_QUESTION_STATUSES",
+    "SUPPORTED_LANGUAGES",
+    "add_judgement_entries",
+    "add_open_question",
+    "apply_inclusion_bundles",
+    "audit_human_visible_document_text",
+    "build_decision_pack",
+    "build_inclusion_review",
+    "copy_case_file",
+    "commit_advisory_workpaper",
+    "commit_decision_narrative",
+    "verify_decision_pack",
+    "delete_materials",
+    "discover_material_paths",
+    "export_case_update",
+    "export_case_workspace_archive",
+    "index_materials",
+    "ingest_note_file",
+    "ingest_note_text",
+    "inspect_pptx_legacy_media",
+    "import_case_update",
+    "initialize_case",
+    "load_case_file",
+    "normalize_legacy_pptx_for_editable_merge",
+    "prepare_editable_pptx_merge_input",
+    "prepare_clara_kickoff",
+    "prepare_support_package",
+    "register_material",
+    "record_analysis_contribution",
+    "record_case_direction_return",
+    "refresh_case_brief",
+    "render_clara_kickoff_deck",
+    "render_clara_partner_brief",
+    "resolve_soffice_binary",
+    "set_judgement_status",
+    "set_judgement_statuses",
+    "update_clara_mandate_from_kickoff",
+    "upsert_case_issues",
+    "validate_case_workspace",
+]
+
+SCHEMA_VERSION = 1
+CASE_DIRECTION_RETURNS_DIRNAME = "case_direction_returns"
+CASE_DIRECTION_RETURN_SCHEMA_PATH = (
+    Path(__file__).resolve().parents[1]
+    / "contracts"
+    / "advisory_case_direction_return.v1.schema.json"
+)
+EXCHANGE_SCHEMA_VERSION = 2
+EXCHANGE_SOURCE = "case_notes_case_update"
+SUPPORTED_LANGUAGES = {"it", "en", "fr", "de", "es"}
+CASE_STATUSES = {"active", "paused", "complete", "archived"}
+MATERIAL_TYPES = {
+    "source",
+    "note",
+    "transcript",
+    "memo",
+    "proposal",
+    "questionnaire",
+    "other",
+}
+MATERIAL_STATUSES = {"indexed", "reviewed", "superseded", "excluded"}
+JUDGEMENT_KINDS = {
+    "fact",
+    "advisor_judgement",
+    "codex_inference",
+    "open_question",
+    "decision_implication",
+}
+JUDGEMENT_STATUSES = {"pending", "approved", "rejected"}
+OPEN_QUESTION_STATUSES = {"open", "answered", "dismissed"}
+ISSUE_STATUSES = {"active", "resolved", "parked"}
+SUPPORTED_FILE_SUFFIXES = {".md", ".txt", ".docx", ".pdf", ".pptx"}
+TEXT_SUFFIXES = {".md", ".txt"}
+CASE_FILE_KINDS = {"auto", "source", "note", "audio", "deck", "presentation"}
+AUDIO_FILE_SUFFIXES = {
+    ".aac",
+    ".aiff",
+    ".flac",
+    ".m4a",
+    ".mp3",
+    ".mp4",
+    ".ogg",
+    ".wav",
+    ".wma",
+}
+PRESENTATION_FILE_SUFFIXES = {".key", ".ppt", ".pptx"}
+NOTE_FILE_SUFFIXES = {".md", ".txt"}
+PRESENTATION_NAME_TOKENS = {
+    "bozza",
+    "deck",
+    "draft",
+    "incontro",
+    "presentazione",
+    "presentation",
+    "slide",
+    "slides",
+}
+LEGACY_PPTX_MEDIA_SUFFIXES = {".emf", ".wmf"}
+CONTENT_TYPES_NS = "http://schemas.openxmlformats.org/package/2006/content-types"
+CUSTOM_PROPS_CONTENT_TYPE = (
+    "application/vnd.openxmlformats-officedocument.custom-properties+xml"
+)
+DEFAULT_SOFFICE_PATHS = (
+    Path("/opt/homebrew/bin/soffice"),
+    Path("/usr/local/bin/soffice"),
+    Path("/Applications/LibreOffice.app/Contents/MacOS/soffice"),
+    Path("/mnt/c/Program Files/LibreOffice/program/soffice.exe"),
+    Path("/mnt/c/Program Files (x86)/LibreOffice/program/soffice.exe"),
+)
+NOTE_NAME_TOKENS = {
+    "appunti",
+    "intervista",
+    "interview",
+    "nota",
+    "note",
+    "notes",
+    "sintesi",
+    "transcript",
+    "trascrizione",
+}
+
+CASE_FILES = {
+    "manifest": "case_manifest.json",
+    "materials": "material_registry.json",
+    "judgement": "judgement_log.json",
+    "open_questions": "open_questions.json",
+    "issues": "case_issues.json",
+    "clara_mandate": "clara_mandate.json",
+}
+CASE_BRIEF_FILENAME = "case_brief.md"
+ADVISORY_WORKPAPER_FILENAME = "advisory_workpaper.md"
+ADVISORY_WORKPAPER_CHECKPOINT_FILENAME = "advisory_workpaper_checkpoint.json"
+CLARA_MANDATE_FILENAME = "clara_mandate.json"
+CLARA_KICKOFF_PREPARATION_FILENAME = "clara_kickoff_preparation.md"
+CLARA_KICKOFF_DECK_FILENAME = "clara_kickoff_deck.html"
+CLARA_PARTNER_BRIEF_FILENAME = "clara_partner_brief.html"
+INCLUSION_REVIEW_FILENAME = "inclusion_review.md"
+INCLUSION_BUNDLES_FILENAME = "inclusion_bundles.json"
+SUPPORT_REQUEST_FILENAME = "support_request.md"
+SHARE_EXCLUDED_DIR_NAMES = {
+    ".clara-transaction",
+    ".cache",
+    ".git",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".venv",
+    "__pycache__",
+    "case_support_exports",
+    "case_share_exports",
+    "env",
+    "exchange_exports",
+    "node_modules",
+    "venv",
+}
+SHARE_EXCLUDED_FILE_NAMES = {
+    ".clara.lock",
+    ".DS_Store",
+}
+
+
+# Deterministic because these are fixed scaffolding, metadata, placeholder, and
+# filler markers that should never be visible in ordinary human-readable Clara
+# documents. Provenance workpapers are the explicit exception.
+HUMAN_VISIBLE_DOCUMENT_BANNED_PATTERNS: tuple[tuple[str, str], ...] = (
+    ("visible judgement/source id", r"\bjud-\d{4,}\b"),
+    ("page-number scaffolding", r"(?m)^\s*(?:pagina|pagine|page|pages)\s+\d+\s*$"),
+    ("page-count scaffolding", r"\b\d+\s*[-/]\s*\d+\s+pagine\b"),
+    ("placeholder label", r"\betichetta da confermare\b"),
+    ("working-pack jargon", r"\bworking\s+(?:review\s+)?pack\b"),
+    ("working-draft jargon", r"\bworking\s+draft\b"),
+    ("opaque dossier title", r"\bdossier di revisione operativo\b"),
+    ("pseudo-editorial filler", r"\bdocumento piu decidibile\b"),
+    ("pseudo-editorial filler", r"\baiutare a pensare\b"),
+    ("pseudo-editorial filler", r"\blettura non lineare\b"),
+    ("generic value language", r"\bcreare valore\b"),
+    ("generic value language", r"\bgive concrete levers\b"),
+    ("generic process language", r"\bcommenti generici\b"),
+    ("generic process language", r"\bapprovazione del testo\b"),
+    ("unhelpful Clara self-reference", r"\bclara ha preparato\b"),
+    ("unhelpful Clara self-reference", r"\bcosa clara (?:pensa|deve|serve)\b"),
+    ("unhelpful Clara self-reference", r"\bwhat clara (?:thinks|should|needs)\b"),
+    ("unhelpful instruction copy", r"\busa questa scheda\b"),
+    ("unhelpful instruction copy", r"\buse this brief\b"),
+    ("decorative warning styling", r"\bclass=[\"'][^\"']*warning[^\"']*[\"']"),
+    ("decorative shadow styling", r"\bbox-shadow\s*:"),
+)
+
+
+class CaseWorkspaceError(ValueError):
+    """Raised when a case workspace file violates the plugin contract."""
+
+
+def _document_quality_scan_text(value: str) -> str:
+    normalized = value.casefold()
+    normalized = normalized.replace("’", "'")
+    normalized = normalized.replace("è", "e'")
+    normalized = normalized.replace("é", "e'")
+    normalized = normalized.replace("È", "e'")
+    normalized = normalized.replace("É", "e'")
+    normalized = normalized.replace("ù", "u")
+    normalized = normalized.replace("Ù", "u")
+    normalized = normalized.replace("&amp;", "&")
+    return normalized
+
+
+def audit_human_visible_document_text(text: str) -> list[str]:
+    """Return mechanical BS markers in ordinary human-visible Clara output."""
+
+    scan_text = _document_quality_scan_text(text)
+    violations: list[str] = []
+    for label, pattern in HUMAN_VISIBLE_DOCUMENT_BANNED_PATTERNS:
+        if re.search(pattern, scan_text):
+            violations.append(label)
+    return _dedupe_preserve_order(violations)
+
+
+def _assert_human_visible_document_quality(text: str, *, label: str) -> None:
+    violations = audit_human_visible_document_text(text)
+    if violations:
+        joined = "; ".join(violations)
+        raise CaseWorkspaceError(f"{label} failed Clara quality gate: {joined}")
+
+
+@dataclass(frozen=True)
+class CaseBriefResult:
+    """Path and counts produced by derived case-brief rendering."""
+
+    brief_path: Path
+    approved_count: int
+    pending_count: int
+    rejected_count: int
+    open_question_count: int
+    issue_count: int
+
+
+@dataclass(frozen=True)
+class DecisionPackResult:
+    """Paths and counts produced by decision-pack rendering."""
+
+    markdown_path: Path
+    docx_path: Path
+    workpaper_markdown_path: Path
+    workpaper_docx_path: Path
+    approved_count: int
+    pending_count: int
+    rejected_count: int
+
+
+@dataclass(frozen=True)
+class InclusionReviewResult:
+    """Path and counts produced by deterministic inclusion-review rendering."""
+
+    review_path: Path
+    approved_count: int
+    pending_count: int
+    rejected_count: int
+
+
+@dataclass(frozen=True)
+class InclusionBundleApplyResult:
+    """Path and counts produced by deterministic inclusion-bundle persistence."""
+
+    bundles_path: Path
+    bundle_count: int
+    bundled_entry_count: int
+
+
+@dataclass(frozen=True)
+class CaseExchangeExportResult:
+    """Package metadata produced by deterministic case-update export."""
+
+    package_path: Path
+    exchange_id: str
+    material_count: int
+    judgement_count: int
+    open_question_count: int
+    included_file_count: int
+    evidence_count: int = 0
+    claim_count: int = 0
+    issue_count: int = 0
+
+
+@dataclass(frozen=True)
+class CaseWorkspaceArchiveResult:
+    """Metadata produced by clean case-workspace archive export."""
+
+    package_path: Path
+    included_file_count: int
+    excluded_file_count: int
+    excluded_bytes: int
+
+
+@dataclass(frozen=True)
+class CaseSupportPackageResult:
+    """Metadata produced by a clean support package for a delivery backstop."""
+
+    package_path: Path
+    support_request_archive_path: str
+    included_file_count: int
+    excluded_file_count: int
+    excluded_bytes: int
+
+
+@dataclass(frozen=True)
+class ClaraKickoffPreparationResult:
+    """Paths and counts produced by Clara kickoff preparation."""
+
+    mandate_path: Path
+    preparation_path: Path
+    material_count: int
+    baseline_source_count: int
+
+
+@dataclass(frozen=True)
+class ClaraPartnerBriefResult:
+    """Path produced by Clara partner brief rendering."""
+
+    html_path: Path
+    open_clarification_count: int
+    next_step_count: int
+
+
+@dataclass(frozen=True)
+class ClaraKickoffDeckResult:
+    """Path and counts produced by Clara's first partner kickoff deck."""
+
+    html_path: Path
+    hypothesis_count: int
+    open_question_count: int
+
+
+@dataclass(frozen=True)
+class CaseExchangeImportResult:
+    """Counts produced by deterministic append-only case-update import."""
+
+    exchange_id: str
+    imported_material_count: int
+    imported_judgement_count: int
+    imported_open_question_count: int
+    skipped_count: int
+    conflict_count: int
+    imported_evidence_count: int = 0
+    imported_claim_count: int = 0
+    imported_issue_count: int = 0
+    updated_claim_count: int = 0
+
+
+@dataclass(frozen=True)
+class CaseFileCopyResult:
+    """Destination and optional registry record for a copied case file."""
+
+    source_path: Path
+    destination_path: Path
+    kind: str
+    copied: bool
+    registered_material: dict[str, Any] | None
+    legacy_pptx_normalization: LegacyPptxNormalizationResult | None = None
+
+
+@dataclass(frozen=True)
+class MaterialDeleteResult:
+    """Canonical references removed by a material deletion."""
+
+    removed_material_ids: tuple[str, ...]
+    missing_material_ids: tuple[str, ...]
+    removed_material_paths: tuple[Path, ...]
+    updated_judgement_ids: tuple[str, ...]
+    unanchored_judgement_ids: tuple[str, ...]
+    removed_mandate_source_material_ids: tuple[str, ...]
+    removed_mandate_voice_session_paths: tuple[str, ...]
+    removed_preparation_material_anchor_ids: tuple[str, ...]
+    orphan_candidate_paths: tuple[Path, ...]
+    removed_empty_orphan_dirs: tuple[Path, ...]
+    brief_path: Path
+
+
+@dataclass(frozen=True)
+class EditablePptxMergeInputResult:
+    """Audited PPTX base selection for an editable slide merge."""
+
+    source_path: Path
+    merge_base_path: Path
+    report_path: Path
+    status: str
+    source_legacy_media: tuple[str, ...]
+    merge_base_legacy_media: tuple[str, ...]
+    normalized_path: Path | None
+    skip_normalization_reason: str | None
+
+
+@dataclass(frozen=True)
+class LegacyPptxNormalizationResult:
+    """Result of normalizing a legacy PowerPoint deck for editable slide merging."""
+
+    source_path: Path
+    output_path: Path
+    report_path: Path
+    normalized: bool
+    legacy_media_before: tuple[str, ...]
+    legacy_media_after: tuple[str, ...]
+    soffice_binary: Path | None
+
+
+def _now_iso(now: datetime | None = None) -> str:
+    timestamp = now or datetime.now(timezone.utc)
+    if timestamp.tzinfo is None:
+        timestamp = timestamp.replace(tzinfo=timezone.utc)
+    return timestamp.astimezone(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def _slugify(value: str, fallback: str = "note") -> str:
+    slug = re.sub(r"[^a-zA-Z0-9]+", "-", value.strip().lower()).strip("-")
+    return slug or fallback
+
+
+def _compact_timestamp(value: str) -> str:
+    return value.replace("-", "").replace(":", "")[:15] + "Z"
+
+
+def _case_path(case_dir: Path, key: str) -> Path:
+    return case_dir / CASE_FILES[key]
+
+
+def _write_json(path: Path, payload: Mapping[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    atomic_text(
+        path,
+        json.dumps(payload, indent=2, sort_keys=True, ensure_ascii=True) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _snapshot_files(paths: Sequence[Path]) -> dict[Path, bytes | None]:
+    for path in paths:
+        track_write(path)
+    return {path: path.read_bytes() if path.exists() else None for path in paths}
+
+
+def _restore_files(snapshot: Mapping[Path, bytes | None]) -> None:
+    for path, content in snapshot.items():
+        if content is None:
+            path.unlink(missing_ok=True)
+            continue
+        path.parent.mkdir(parents=True, exist_ok=True)
+        atomic_bytes(path, content)
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _next_id(prefix: str, existing_ids: Iterable[str]) -> str:
+    used_numbers: list[int] = []
+    for item_id in existing_ids:
+        match = re.fullmatch(rf"{re.escape(prefix)}-(\d+)", item_id)
+        if match:
+            used_numbers.append(int(match.group(1)))
+    next_number = max(used_numbers, default=0) + 1
+    return f"{prefix}-{next_number:04d}"
+
+
+def _dedupe_preserve_order(values: Iterable[str]) -> list[str]:
+    seen: set[str] = set()
+    deduped: list[str] = []
+    for value in values:
+        clean_value = value.strip()
+        if clean_value and clean_value not in seen:
+            deduped.append(clean_value)
+            seen.add(clean_value)
+    return deduped
+
+
+def _touch_manifest(case_dir: Path, timestamp: str) -> None:
+    manifest_path = _case_path(case_dir, "manifest")
+    manifest = _read_json(manifest_path)
+    manifest["updated_at"] = timestamp
+    _write_json(manifest_path, manifest)
+
+
+def _validate_choice(value: str, allowed: set[str], field_name: str) -> None:
+    if value not in allowed:
+        allowed_values = ", ".join(sorted(allowed))
+        raise CaseWorkspaceError(
+            f"{field_name} must be one of: {allowed_values}; got {value!r}"
+        )
+
+
+def _empty_material_registry() -> dict[str, Any]:
+    return {"schema_version": SCHEMA_VERSION, "materials": []}
+
+
+def _empty_judgement_log() -> dict[str, Any]:
+    return {"schema_version": SCHEMA_VERSION, "entries": []}
+
+
+def _empty_open_questions() -> dict[str, Any]:
+    return {"schema_version": SCHEMA_VERSION, "questions": []}
+
+
+def _empty_case_issues() -> dict[str, Any]:
+    return {"schema_version": SCHEMA_VERSION, "issues": []}
+
+
+def _empty_clara_mandate() -> dict[str, Any]:
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "persona": "Clara",
+        "partner_role": "senior partner",
+        "status": "not_started",
+        "prepared_at": None,
+        "kickoff_imported_at": None,
+        "updated_at": None,
+        "preparation": {
+            "case_snapshot": {},
+            "material_anchors": [],
+            "succession_lenses": [],
+            "red_flags": [],
+            "industry_context": [],
+            "external_research": [],
+            "preparation_note": "",
+        },
+        "mandate": {
+            "engagement_objective": "",
+            "client_decision": "",
+            "clara_understanding": "",
+            "partner_starting_orientation": "",
+            "sensitive_points": [],
+            "what_clara_should_investigate": [],
+            "what_clara_should_not_waste_time_on": [],
+            "essential_clarifications": [],
+            "next_steps": [],
+        },
+        "source_material_ids": [],
+        "voice_session_paths": [],
+    }
+
+
+@case_operation
+def initialize_case(
+    case_dir: Path,
+    *,
+    client: str,
+    project: str,
+    objective: str,
+    audience: str,
+    output_language: str = "it",
+    status: str = "active",
+    overwrite: bool = False,
+    now: datetime | None = None,
+) -> dict[str, Any]:
+    """Create or load the durable case workspace and advisory lineage files."""
+
+    _validate_choice(output_language, SUPPORTED_LANGUAGES, "output_language")
+    _validate_choice(status, CASE_STATUSES, "status")
+
+    case_dir.mkdir(parents=True, exist_ok=True)
+    timestamp = _now_iso(now)
+    manifest_path = _case_path(case_dir, "manifest")
+    existing_case_state = [
+        path
+        for path in (
+            *(_case_path(case_dir, key) for key in CASE_FILES),
+            case_dir / EVIDENCE_REGISTER_FILENAME,
+            case_dir / CLAIM_REGISTER_FILENAME,
+        )
+        if path.exists()
+    ]
+    if overwrite and existing_case_state:
+        raise CaseWorkspaceError(
+            "refusing to overwrite existing Clara case state; append-only evidence, claims, materials, and judgement must be preserved"
+        )
+    if overwrite or not manifest_path.exists():
+        manifest = {
+            "schema_version": SCHEMA_VERSION,
+            "client": client,
+            "project": project,
+            "objective": objective,
+            "audience": audience,
+            "status": status,
+            "output_language": output_language,
+            "created_at": timestamp,
+            "updated_at": timestamp,
+        }
+        _write_json(manifest_path, manifest)
+    else:
+        manifest = _read_json(manifest_path)
+
+    defaults = {
+        "materials": _empty_material_registry(),
+        "judgement": _empty_judgement_log(),
+        "open_questions": _empty_open_questions(),
+        "issues": _empty_case_issues(),
+        "clara_mandate": _empty_clara_mandate(),
+    }
+    for key, payload in defaults.items():
+        path = _case_path(case_dir, key)
+        if overwrite or not path.exists():
+            _write_json(path, payload)
+
+    initialize_lineage(case_dir, overwrite=overwrite)
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+    refresh_case_brief(case_dir, now=now)
+    return manifest
+
+
+@case_reader
+def load_case_file(case_dir: Path, key: str) -> dict[str, Any]:
+    """Load one canonical workspace JSON file by logical key."""
+
+    if key not in CASE_FILES:
+        raise CaseWorkspaceError(f"Unknown case file key: {key}")
+    return _read_json(_case_path(case_dir, key))
+
+
+def _relative_path_from_material(case_dir: Path, material: Mapping[str, Any]) -> str:
+    path = _material_path(case_dir, material)
+    try:
+        return str(path.relative_to(case_dir.resolve()))
+    except ValueError:
+        return str(path)
+
+
+def _validate_audio_pointer_links(
+    *,
+    case_dir: Path,
+    materials: list[Any],
+) -> list[str]:
+    errors: list[str] = []
+    material_by_id = {
+        str(material.get("id")): material
+        for material in materials
+        if isinstance(material, dict) and material.get("id")
+    }
+    for material in materials:
+        if not isinstance(material, dict):
+            continue
+        if material.get("material_type") != "transcript":
+            continue
+        metadata = material.get("source_metadata")
+        if not isinstance(metadata, dict):
+            continue
+        pointer_id = str(metadata.get("raw_audio_pointer_material_id") or "").strip()
+        if not pointer_id:
+            continue
+        transcript_id = str(material.get("id") or "").strip()
+        pointer = material_by_id.get(pointer_id)
+        if pointer is None:
+            errors.append(
+                "material_registry.json: transcript "
+                f"{transcript_id} links missing raw audio pointer {pointer_id}"
+            )
+            continue
+        pointer_metadata = pointer.get("source_metadata")
+        if not isinstance(pointer_metadata, dict):
+            errors.append(
+                "material_registry.json: audio pointer "
+                f"{pointer_id} linked to transcript {transcript_id} "
+                "has no source_metadata"
+            )
+            pointer_metadata = {}
+        if pointer_metadata.get("transcription_status") != "transcribed":
+            errors.append(
+                "material_registry.json: audio pointer "
+                f"{pointer_id} linked to transcript {transcript_id} "
+                "is not marked transcribed"
+            )
+        if pointer_metadata.get("linked_transcript_material_id") != transcript_id:
+            errors.append(
+                "material_registry.json: audio pointer "
+                f"{pointer_id} does not link back to transcript {transcript_id}"
+            )
+        expected_path = _relative_path_from_material(case_dir, material)
+        if pointer_metadata.get("linked_transcript_path") != expected_path:
+            errors.append(
+                "material_registry.json: audio pointer "
+                f"{pointer_id} has stale linked transcript path for {transcript_id}"
+            )
+        pointer_path = _material_path(case_dir, pointer)
+        if pointer_path.is_file():
+            try:
+                pointer_text = pointer_path.read_text(encoding="utf-8")
+            except UnicodeDecodeError:
+                pointer_text = ""
+            stale_markers = (
+                "non ancora trascritto",
+                "not yet transcribed",
+                "Quando sara' prodotta la trascrizione",
+                "Quando sarà prodotta la trascrizione",
+            )
+            if any(marker in pointer_text for marker in stale_markers):
+                errors.append(
+                    "material_registry.json: audio pointer "
+                    f"{pointer_id} linked to transcript {transcript_id} "
+                    "still says not transcribed"
+                )
+    return errors
+
+
+@case_reader
+def validate_case_workspace(case_dir: Path) -> list[str]:
+    """Validate mechanical JSON schemas without making semantic judgments."""
+
+    errors: list[str] = []
+    for key, filename in CASE_FILES.items():
+        path = case_dir / filename
+        if not path.exists():
+            errors.append(f"missing {filename}")
+            continue
+        try:
+            payload = _read_json(path)
+        except json.JSONDecodeError as exc:
+            errors.append(f"{filename}: invalid JSON: {exc}")
+            continue
+        if payload.get("schema_version") != SCHEMA_VERSION:
+            errors.append(f"{filename}: unsupported schema_version")
+        if key == "manifest":
+            for field in (
+                "client",
+                "project",
+                "objective",
+                "audience",
+                "status",
+                "output_language",
+            ):
+                if not payload.get(field):
+                    errors.append(f"{filename}: missing {field}")
+            if payload.get("status") not in CASE_STATUSES:
+                errors.append(f"{filename}: invalid status")
+            if payload.get("output_language") not in SUPPORTED_LANGUAGES:
+                errors.append(f"{filename}: invalid output_language")
+        elif key == "materials":
+            materials = payload.get("materials")
+            if not isinstance(materials, list):
+                errors.append(f"{filename}: materials must be a list")
+            else:
+                errors.extend(
+                    _validate_audio_pointer_links(
+                        case_dir=case_dir,
+                        materials=materials,
+                    )
+                )
+        elif key == "judgement":
+            entries = payload.get("entries")
+            if not isinstance(entries, list):
+                errors.append(f"{filename}: entries must be a list")
+            else:
+                for entry in entries:
+                    if entry.get("kind") not in JUDGEMENT_KINDS:
+                        errors.append(f"{filename}: invalid judgement kind")
+                    if entry.get("status") not in JUDGEMENT_STATUSES:
+                        errors.append(f"{filename}: invalid judgement status")
+        elif key == "open_questions":
+            if not isinstance(payload.get("questions"), list):
+                errors.append(f"{filename}: questions must be a list")
+        elif key == "issues":
+            issues = payload.get("issues")
+            if not isinstance(issues, list):
+                errors.append(f"{filename}: issues must be a list")
+            else:
+                for issue in issues:
+                    if issue.get("status") not in ISSUE_STATUSES:
+                        errors.append(f"{filename}: invalid issue status")
+        elif key == "clara_mandate":
+            if not isinstance(payload.get("preparation"), dict):
+                errors.append(f"{filename}: preparation must be an object")
+            if not isinstance(payload.get("mandate"), dict):
+                errors.append(f"{filename}: mandate must be an object")
+            if not isinstance(payload.get("source_material_ids"), list):
+                errors.append(f"{filename}: source_material_ids must be a list")
+            if not isinstance(payload.get("voice_session_paths"), list):
+                errors.append(f"{filename}: voice_session_paths must be a list")
+    lineage_paths = (
+        case_dir / EVIDENCE_REGISTER_FILENAME,
+        case_dir / CLAIM_REGISTER_FILENAME,
+    )
+    if any(path.exists() for path in lineage_paths):
+        lineage_audit = validate_lineage(case_dir)
+        errors.extend(f"advisory lineage: {error}" for error in lineage_audit["errors"])
+    required_reference_paths = [
+        _case_path(case_dir, "materials"),
+        _case_path(case_dir, "judgement"),
+        _case_path(case_dir, "open_questions"),
+        _case_path(case_dir, "issues"),
+        case_dir / EVIDENCE_REGISTER_FILENAME,
+        case_dir / CLAIM_REGISTER_FILENAME,
+    ]
+    if all(path.is_file() for path in required_reference_paths):
+        materials = _read_json(_case_path(case_dir, "materials")).get("materials", [])
+        judgement_entries = _read_json(_case_path(case_dir, "judgement")).get(
+            "entries", []
+        )
+        questions = _read_json(_case_path(case_dir, "open_questions")).get(
+            "questions", []
+        )
+        issues = _read_json(_case_path(case_dir, "issues")).get("issues", [])
+        evidence_records = _read_json(case_dir / EVIDENCE_REGISTER_FILENAME).get(
+            "evidence", []
+        )
+        claim_records = _read_json(case_dir / CLAIM_REGISTER_FILENAME).get("claims", [])
+        known_material_ids = {
+            str(item.get("id"))
+            for item in materials
+            if isinstance(item, dict) and item.get("id")
+        }
+        known_judgement_ids = {
+            str(item.get("id"))
+            for item in judgement_entries
+            if isinstance(item, dict) and item.get("id")
+        }
+        known_question_ids = {
+            str(item.get("id"))
+            for item in questions
+            if isinstance(item, dict) and item.get("id")
+        }
+        known_evidence_ids = {
+            str(item.get("id"))
+            for item in evidence_records
+            if isinstance(item, dict) and item.get("id")
+        }
+        claims_by_id = {
+            str(item.get("id")): item
+            for item in claim_records
+            if isinstance(item, dict) and item.get("id")
+        }
+        for entry in judgement_entries:
+            if not isinstance(entry, dict):
+                continue
+            entry_id = str(entry.get("id", "judgement"))
+            unknown_materials = sorted(
+                set(entry.get("source_material_ids", [])) - known_material_ids
+            )
+            if unknown_materials:
+                errors.append(
+                    f"judgement_log.json: {entry_id} has unknown material ids: "
+                    + ", ".join(unknown_materials)
+                )
+            claim_id = str(entry.get("advisory_claim_id", ""))
+            claim = claims_by_id.get(claim_id)
+            if claim_id and claim is None:
+                errors.append(
+                    f"judgement_log.json: {entry_id} has unknown advisory claim {claim_id}"
+                )
+            receipt_ids = {
+                str(value) for value in entry.get("evidence_receipt_ids", [])
+            }
+            unknown_receipts = sorted(receipt_ids - known_evidence_ids)
+            if unknown_receipts:
+                errors.append(
+                    f"judgement_log.json: {entry_id} has unknown evidence receipts: "
+                    + ", ".join(unknown_receipts)
+                )
+            if isinstance(claim, dict):
+                linked_receipts = {
+                    str(link.get("evidence_id"))
+                    for link in claim.get("evidence_links", [])
+                    if isinstance(link, dict) and link.get("evidence_id")
+                }
+                if receipt_ids != linked_receipts:
+                    errors.append(
+                        f"judgement_log.json: {entry_id} evidence receipts do not exactly match {claim_id}"
+                    )
+                normalized_claim = re.sub(
+                    r"\s+", " ", str(claim.get("statement", ""))
+                ).strip()
+                normalized_entry = re.sub(
+                    r"\s+", " ", str(entry.get("text", ""))
+                ).strip()
+                if normalized_claim != normalized_entry:
+                    errors.append(
+                        f"judgement_log.json: {entry_id} text does not match {claim_id}"
+                    )
+            if entry.get("status") == "approved" and (
+                not claim_id
+                or not isinstance(claim, dict)
+                or claim.get("state") != "active"
+            ):
+                errors.append(
+                    f"judgement_log.json: approved {entry_id} requires a matching active advisory claim"
+                )
+        for question in questions:
+            if not isinstance(question, dict):
+                continue
+            unknown_entries = sorted(
+                set(question.get("source_entry_ids", [])) - known_judgement_ids
+            )
+            if unknown_entries:
+                errors.append(
+                    f"open_questions.json: {question.get('id', 'question')} has unknown judgement ids: "
+                    + ", ".join(unknown_entries)
+                )
+        for issue in issues:
+            if not isinstance(issue, dict):
+                continue
+            issue_id = str(issue.get("id", "issue"))
+            unknown_entries = sorted(
+                (
+                    set(issue.get("evidence_for", []))
+                    | set(issue.get("evidence_against", []))
+                )
+                - known_judgement_ids
+            )
+            unknown_claims = sorted(
+                (
+                    set(issue.get("claim_ids_for", []))
+                    | set(issue.get("claim_ids_against", []))
+                )
+                - set(claims_by_id)
+            )
+            unknown_questions = sorted(
+                set(issue.get("open_tests", [])) - known_question_ids
+            )
+            if unknown_entries:
+                errors.append(
+                    f"case_issues.json: {issue_id} has unknown judgement ids: "
+                    + ", ".join(unknown_entries)
+                )
+            if unknown_claims:
+                errors.append(
+                    f"case_issues.json: {issue_id} has unknown advisory claim ids: "
+                    + ", ".join(unknown_claims)
+                )
+            if unknown_questions:
+                errors.append(
+                    f"case_issues.json: {issue_id} has unknown open-question ids: "
+                    + ", ".join(unknown_questions)
+                )
+    return errors
+
+
+def _mechanical_text_summary(text: str, *, limit: int = 420) -> str:
+    clean = re.sub(r"\s+", " ", text).strip()
+    if not clean:
+        return "No readable preview text."
+    if len(clean) <= limit:
+        return clean
+    return f"{clean[:limit].rstrip()}..."
+
+
+def _summarize_file(path: Path) -> str:
+    suffix = path.suffix.lower()
+    if suffix in TEXT_SUFFIXES:
+        try:
+            return _mechanical_text_summary(path.read_text(encoding="utf-8"))
+        except UnicodeDecodeError:
+            return "Text file indexed; UTF-8 preview unavailable."
+    if suffix == ".docx":
+        try:
+            from docx import Document
+        except ImportError:
+            return "DOCX indexed; install python-docx for mechanical preview."
+        document = Document(path)
+        text = " ".join(paragraph.text for paragraph in document.paragraphs[:12])
+        return _mechanical_text_summary(text)
+    if suffix == ".pdf":
+        return "PDF indexed; semantic review remains in Codex."
+    if suffix == ".pptx":
+        try:
+            from pptx import Presentation
+        except ImportError:
+            return "PPTX indexed; install python-pptx for mechanical preview."
+        presentation = Presentation(path)
+        slide_text: list[str] = []
+        for index, slide in enumerate(presentation.slides, start=1):
+            if index > 12:
+                break
+            texts = [
+                str(getattr(shape, "text", "")).strip()
+                for shape in slide.shapes
+                if str(getattr(shape, "text", "")).strip()
+            ]
+            if texts:
+                slide_text.append(f"Slide {index}: {' '.join(texts)}")
+        return _mechanical_text_summary(" ".join(slide_text))
+    return "File indexed without preview."
+
+
+class UnsupportedMaterialTypeError(ValueError):
+    """Raised before indexing when an input has no document preview adapter."""
+
+
+def discover_material_paths(paths: Sequence[Path]) -> list[Path]:
+    """Return supported files from explicit files or folders, without copying."""
+
+    discovered: list[Path] = []
+    for source in paths:
+        if not source.exists():
+            raise FileNotFoundError(source)
+        # File adapter availability is mechanical; reject before any registry writes.
+        candidates = [source] if source.is_file() else sorted(source.rglob("*"))
+        for path in candidates:
+            if not path.is_file():
+                continue
+            if path.suffix.lower() not in SUPPORTED_FILE_SUFFIXES:
+                raise UnsupportedMaterialTypeError(
+                    f"Unsupported material for document indexing: {path}. "
+                    f"Supported suffixes: {', '.join(sorted(SUPPORTED_FILE_SUFFIXES))}. "
+                    "Use clara:reporting-engine for CSV/XLSX/Parquet data; "
+                    "register structured JSON as evidence through the owning workflow. "
+                    "No materials were indexed; select supported documents separately."
+                )
+            discovered.append(path)
+    return sorted({path.resolve() for path in discovered})
+
+
+@case_operation
+def register_material(
+    case_dir: Path,
+    path: Path,
+    *,
+    material_type: str = "source",
+    title: str | None = None,
+    status: str = "indexed",
+    summary: str | None = None,
+    source_metadata: Mapping[str, Any] | None = None,
+    now: datetime | None = None,
+) -> dict[str, Any]:
+    """Register one source path in place and return the material record."""
+
+    _validate_choice(material_type, MATERIAL_TYPES, "material_type")
+    _validate_choice(status, MATERIAL_STATUSES, "status")
+    if not path.exists():
+        raise FileNotFoundError(path)
+
+    timestamp = _now_iso(now)
+    registry_path = _case_path(case_dir, "materials")
+    registry = _read_json(registry_path)
+    materials = registry["materials"]
+    resolved_path = str(path.resolve())
+    existing_ids = [item["id"] for item in materials]
+    material_summary = summary if summary is not None else _summarize_file(path)
+    metadata = dict(source_metadata or {})
+    if summary is None:
+        metadata["preview_coverage"] = {
+            "kind": "mechanical_excerpt",
+            "semantic_review_performed": False,
+            "text_character_limit": 420,
+            "scope": {
+                ".docx": "first 12 body paragraphs; tables, headers and footnotes omitted",
+                ".pptx": "text from first 12 slides; charts, images and notes omitted",
+                ".pdf": "no document content extracted by this indexer",
+            }.get(path.suffix.lower(), "leading readable text only"),
+            "next_action": "Read the full source with its document tool before drawing conclusions.",
+        }
+
+    for item in materials:
+        if item["path"] == resolved_path:
+            item.update(
+                {
+                    "title": title or item["title"],
+                    "material_type": material_type,
+                    "status": status,
+                    "summary": material_summary,
+                    "last_reviewed": item.get("last_reviewed"),
+                    "updated_at": timestamp,
+                }
+            )
+            if metadata:
+                existing_metadata = item.get("source_metadata")
+                if existing_metadata is not None and not isinstance(
+                    existing_metadata, dict
+                ):
+                    raise CaseWorkspaceError("source_metadata must be an object")
+                item["source_metadata"] = {
+                    **dict(existing_metadata or {}),
+                    **metadata,
+                }
+            _write_json(registry_path, registry)
+            _touch_manifest(case_dir, timestamp)
+            refresh_case_brief(case_dir, now=now)
+            return item
+
+    material = {
+        "id": _next_id("mat", existing_ids),
+        "path": resolved_path,
+        "title": title or path.stem.replace("_", " ").replace("-", " ").title(),
+        "material_type": material_type,
+        "status": status,
+        "summary": material_summary,
+        "added_at": timestamp,
+        "updated_at": timestamp,
+        "last_reviewed": None,
+    }
+    if metadata:
+        material["source_metadata"] = metadata
+    materials.append(material)
+    _write_json(registry_path, registry)
+    _touch_manifest(case_dir, timestamp)
+    refresh_case_brief(case_dir, now=now)
+    return material
+
+
+def index_materials(
+    case_dir: Path,
+    paths: Sequence[Path],
+    *,
+    material_type: str = "source",
+    source_metadata: Mapping[str, Any] | None = None,
+    now: datetime | None = None,
+) -> list[dict[str, Any]]:
+    """Index supported materials from files or folders without copying them."""
+
+    return [
+        register_material(
+            case_dir,
+            path,
+            material_type=material_type,
+            source_metadata=source_metadata,
+            now=now,
+        )
+        for path in discover_material_paths(paths)
+    ]
+
+
+def _material_path(case_dir: Path, material: Mapping[str, Any]) -> Path:
+    raw_path = Path(str(material.get("path", ""))).expanduser()
+    if raw_path.is_absolute():
+        return raw_path.resolve()
+    return (case_dir / raw_path).resolve()
+
+
+def _case_owned_path(case_dir: Path, path: Path) -> bool:
+    try:
+        path.resolve().relative_to(case_dir.resolve())
+    except ValueError:
+        return False
+    return True
+
+
+def _voice_session_path_for_path(case_dir: Path, path: Path) -> str | None:
+    try:
+        relative_path = path.resolve().relative_to(case_dir.resolve())
+    except ValueError:
+        return None
+    if len(relative_path.parts) < 2 or relative_path.parts[0] != "voice_sessions":
+        return None
+    return str(Path(relative_path.parts[0]) / relative_path.parts[1])
+
+
+def _dedupe_paths(paths: Iterable[Path]) -> tuple[Path, ...]:
+    seen: set[str] = set()
+    deduped: list[Path] = []
+    for path in paths:
+        key = str(path.resolve())
+        if key not in seen:
+            deduped.append(path)
+            seen.add(key)
+    return tuple(deduped)
+
+
+def _filter_material_ids(
+    values: Any,
+    deleted_ids: set[str],
+) -> tuple[list[str], list[str]]:
+    if not isinstance(values, list):
+        return [], []
+    before = [str(item) for item in values if str(item).strip()]
+    after = [item for item in before if item not in deleted_ids]
+    removed = [item for item in before if item in deleted_ids]
+    return _dedupe_preserve_order(after), _dedupe_preserve_order(removed)
+
+
+@case_operation
+def delete_materials(
+    case_dir: Path,
+    material_ids: Sequence[str],
+    *,
+    ignore_missing: bool = False,
+    remove_empty_orphan_dirs: bool = False,
+    now: datetime | None = None,
+) -> MaterialDeleteResult:
+    """Remove material records and scrub canonical source references.
+
+    This is intentionally conservative about files. It removes JSON references,
+    refreshes the derived brief, and reports case-owned orphan candidates. It
+    deletes only empty orphan directories when explicitly requested.
+    """
+
+    requested_ids = _dedupe_preserve_order(str(item) for item in material_ids)
+    if not requested_ids:
+        raise CaseWorkspaceError("at least one material id is required")
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+
+    timestamp = _now_iso(now)
+    registry_path = _case_path(case_dir, "materials")
+    registry = _read_json(registry_path)
+    materials = registry.get("materials")
+    if not isinstance(materials, list):
+        raise CaseWorkspaceError("material_registry.json: materials must be a list")
+
+    materials_by_id = {
+        str(item.get("id")): item for item in materials if isinstance(item, dict)
+    }
+    missing_ids = tuple(
+        item_id for item_id in requested_ids if item_id not in materials_by_id
+    )
+    if missing_ids and not ignore_missing:
+        raise CaseWorkspaceError("unknown material id(s): " + ", ".join(missing_ids))
+
+    removed_materials = [
+        materials_by_id[item_id]
+        for item_id in requested_ids
+        if item_id in materials_by_id
+    ]
+    removed_ids = tuple(str(item["id"]) for item in removed_materials)
+    removed_id_set = set(removed_ids)
+    evidence_path = case_dir / EVIDENCE_REGISTER_FILENAME
+    if evidence_path.is_file() and removed_id_set:
+        evidence_payload = _read_json(evidence_path)
+        referenced_by: dict[str, list[str]] = {}
+        for receipt in evidence_payload.get("evidence", []):
+            if not isinstance(receipt, dict):
+                continue
+            source = receipt.get("source")
+            if not isinstance(source, dict):
+                continue
+            for material_id in source.get("material_ids", []):
+                if material_id in removed_id_set:
+                    referenced_by.setdefault(str(material_id), []).append(
+                        str(receipt.get("id", "unknown"))
+                    )
+        if referenced_by:
+            details = "; ".join(
+                f"{material_id} is cited by {', '.join(receipt_ids)}"
+                for material_id, receipt_ids in sorted(referenced_by.items())
+            )
+            raise CaseWorkspaceError(
+                "cannot delete material with advisory evidence lineage; "
+                "supersede or withdraw the linked claims and preserve the source record: "
+                + details
+            )
+    if not removed_materials:
+        brief_result = refresh_case_brief(case_dir, now=now)
+        return MaterialDeleteResult(
+            removed_material_ids=(),
+            missing_material_ids=missing_ids,
+            removed_material_paths=(),
+            updated_judgement_ids=(),
+            unanchored_judgement_ids=(),
+            removed_mandate_source_material_ids=(),
+            removed_mandate_voice_session_paths=(),
+            removed_preparation_material_anchor_ids=(),
+            orphan_candidate_paths=(),
+            removed_empty_orphan_dirs=(),
+            brief_path=brief_result.brief_path,
+        )
+
+    removed_path_list = [_material_path(case_dir, item) for item in removed_materials]
+    removed_paths = _dedupe_paths(removed_path_list)
+    removed_session_paths = {
+        session_path
+        for path in removed_paths
+        if (session_path := _voice_session_path_for_path(case_dir, path)) is not None
+    }
+
+    remaining_materials = [
+        item for item in materials if str(item.get("id")) not in removed_id_set
+    ]
+    registry["materials"] = remaining_materials
+    _write_json(registry_path, registry)
+
+    judgement_path = _case_path(case_dir, "judgement")
+    judgement = _read_json(judgement_path)
+    updated_judgement_ids: list[str] = []
+    unanchored_judgement_ids: list[str] = []
+    for entry in judgement.get("entries", []):
+        if not isinstance(entry, dict):
+            continue
+        source_ids = entry.get("source_material_ids", [])
+        remaining_source_ids, removed_source_ids = _filter_material_ids(
+            source_ids,
+            removed_id_set,
+        )
+        if not removed_source_ids:
+            continue
+        entry["source_material_ids"] = remaining_source_ids
+        entry_id = str(entry.get("id", "")).strip()
+        if entry_id:
+            updated_judgement_ids.append(entry_id)
+            if not remaining_source_ids:
+                unanchored_judgement_ids.append(entry_id)
+    _write_json(judgement_path, judgement)
+
+    mandate_path = _case_path(case_dir, "clara_mandate")
+    mandate = _read_json(mandate_path)
+    mandate_source_ids, removed_mandate_source_ids = _filter_material_ids(
+        mandate.get("source_material_ids", []),
+        removed_id_set,
+    )
+    mandate["source_material_ids"] = mandate_source_ids
+
+    removed_anchor_ids: list[str] = []
+    preparation = mandate.get("preparation")
+    if isinstance(preparation, dict):
+        anchors = preparation.get("material_anchors", [])
+        if isinstance(anchors, list):
+            kept_anchors = []
+            for anchor in anchors:
+                if not isinstance(anchor, dict):
+                    kept_anchors.append(anchor)
+                    continue
+                anchor_id = str(anchor.get("id", "")).strip()
+                if anchor_id in removed_id_set:
+                    removed_anchor_ids.append(anchor_id)
+                else:
+                    kept_anchors.append(anchor)
+            preparation["material_anchors"] = kept_anchors
+
+    remaining_session_paths = {
+        session_path
+        for material in remaining_materials
+        if isinstance(material, dict)
+        for path in (_material_path(case_dir, material),)
+        if (session_path := _voice_session_path_for_path(case_dir, path)) is not None
+    }
+    removable_session_paths = removed_session_paths - remaining_session_paths
+    voice_session_paths = mandate.get("voice_session_paths", [])
+    removed_voice_session_paths: list[str] = []
+    if isinstance(voice_session_paths, list):
+        kept_voice_session_paths: list[str] = []
+        for session_path in voice_session_paths:
+            session_path_str = str(session_path)
+            if session_path_str in removable_session_paths:
+                removed_voice_session_paths.append(session_path_str)
+            else:
+                kept_voice_session_paths.append(session_path_str)
+        mandate["voice_session_paths"] = _dedupe_preserve_order(
+            kept_voice_session_paths
+        )
+
+    if removed_mandate_source_ids or removed_anchor_ids or removed_voice_session_paths:
+        mandate["updated_at"] = timestamp
+    _write_json(mandate_path, mandate)
+
+    orphan_candidates: list[Path] = []
+    remaining_paths = {
+        str(_material_path(case_dir, item))
+        for item in remaining_materials
+        if isinstance(item, dict)
+    }
+    for path in removed_paths:
+        if (
+            path.exists()
+            and _case_owned_path(case_dir, path)
+            and str(path) not in remaining_paths
+        ):
+            orphan_candidates.append(path)
+    for session_path in removable_session_paths:
+        session_dir = (case_dir / session_path).resolve()
+        if session_dir.exists():
+            orphan_candidates.append(session_dir)
+    orphan_candidate_paths = _dedupe_paths(orphan_candidates)
+
+    removed_empty_dirs: list[Path] = []
+    if remove_empty_orphan_dirs:
+        for candidate in orphan_candidate_paths:
+            if candidate.is_dir():
+                try:
+                    candidate.rmdir()
+                except OSError:
+                    continue
+                removed_empty_dirs.append(candidate)
+
+    _touch_manifest(case_dir, timestamp)
+    brief_result = refresh_case_brief(case_dir, now=now)
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+
+    return MaterialDeleteResult(
+        removed_material_ids=removed_ids,
+        missing_material_ids=missing_ids,
+        removed_material_paths=removed_paths,
+        updated_judgement_ids=tuple(_dedupe_preserve_order(updated_judgement_ids)),
+        unanchored_judgement_ids=tuple(
+            _dedupe_preserve_order(unanchored_judgement_ids)
+        ),
+        removed_mandate_source_material_ids=tuple(
+            _dedupe_preserve_order(removed_mandate_source_ids)
+        ),
+        removed_mandate_voice_session_paths=tuple(
+            _dedupe_preserve_order(removed_voice_session_paths)
+        ),
+        removed_preparation_material_anchor_ids=tuple(
+            _dedupe_preserve_order(removed_anchor_ids)
+        ),
+        orphan_candidate_paths=orphan_candidate_paths,
+        removed_empty_orphan_dirs=tuple(removed_empty_dirs),
+        brief_path=brief_result.brief_path,
+    )
+
+
+@case_operation
+def ingest_note_text(
+    case_dir: Path,
+    *,
+    title: str,
+    text: str,
+    now: datetime | None = None,
+) -> dict[str, Any]:
+    """Persist pasted consultant notes as a source material inside the case."""
+
+    if not text.strip():
+        raise CaseWorkspaceError("note text cannot be empty")
+    timestamp = _now_iso(now)
+    compact_timestamp = timestamp.replace("-", "").replace(":", "")[:15] + "Z"
+    notes_dir = case_dir / "notes"
+    notes_dir.mkdir(parents=True, exist_ok=True)
+    # Captures are distinct evidence, even when title and second are identical.
+    note_path = (
+        notes_dir / f"{compact_timestamp}-{_slugify(title)}-{uuid.uuid4().hex}.md"
+    )
+    note_body = (
+        f"# {title}\n\n"
+        f"Captured: {timestamp}\n"
+        "Source: pasted consultant note\n\n"
+        f"{text.strip()}\n"
+    )
+    track_write(note_path)
+    with note_path.open("x", encoding="utf-8") as handle:
+        handle.write(note_body)
+        handle.flush()
+        os.fsync(handle.fileno())
+    return register_material(
+        case_dir,
+        note_path,
+        material_type="note",
+        title=title,
+        summary=_mechanical_text_summary(text),
+        now=now,
+    )
+
+
+def _owned_note_path(
+    case_dir: Path,
+    *,
+    title: str,
+    suffix: str,
+    now: datetime | None = None,
+) -> Path:
+    timestamp = _now_iso(now)
+    compact_timestamp = timestamp.replace("-", "").replace(":", "")[:15] + "Z"
+    notes_dir = case_dir / "notes"
+    notes_dir.mkdir(parents=True, exist_ok=True)
+    clean_suffix = suffix if suffix.startswith(".") else f".{suffix}"
+    return notes_dir / f"{compact_timestamp}-{_slugify(title)}{clean_suffix}"
+
+
+@case_operation
+def ingest_note_file(
+    case_dir: Path,
+    *,
+    title: str,
+    notes_file: Path,
+    now: datetime | None = None,
+) -> dict[str, Any]:
+    """Copy an existing note file into the case workspace and register it."""
+
+    if not title.strip():
+        raise CaseWorkspaceError("note title cannot be empty")
+    if not notes_file.exists():
+        raise FileNotFoundError(notes_file)
+
+    resolved_source = notes_file.resolve()
+    notes_dir = (case_dir / "notes").resolve()
+    if resolved_source.is_relative_to(notes_dir):
+        note_path = resolved_source
+    else:
+        suffix = notes_file.suffix or ".md"
+        note_path = _owned_note_path(case_dir, title=title, suffix=suffix, now=now)
+        if note_path.resolve() != resolved_source:
+            track_write(note_path)
+            shutil.copy2(resolved_source, note_path)
+
+    return register_material(
+        case_dir,
+        note_path,
+        material_type="note",
+        title=title,
+        now=now,
+    )
+
+
+def _file_sha256(path: Path) -> str:
+    digest = sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _filename_tokens(path: Path) -> set[str]:
+    return {
+        token for token in re.split(r"[^a-zA-Z0-9]+", path.stem.casefold()) if token
+    }
+
+
+def _infer_case_file_kind(path: Path) -> str:
+    suffix = path.suffix.lower()
+    tokens = _filename_tokens(path)
+    if suffix in AUDIO_FILE_SUFFIXES:
+        return "audio"
+    if suffix in NOTE_FILE_SUFFIXES or tokens & NOTE_NAME_TOKENS:
+        return "note"
+    if suffix in PRESENTATION_FILE_SUFFIXES and tokens & PRESENTATION_NAME_TOKENS:
+        return "presentation"
+    return "source"
+
+
+def _normalize_case_file_kind(kind: str, source_path: Path) -> str:
+    _validate_choice(kind, CASE_FILE_KINDS, "kind")
+    if kind == "auto":
+        return _infer_case_file_kind(source_path)
+    if kind == "deck":
+        return "presentation"
+    return kind
+
+
+def _case_file_destination_dir(case_dir: Path, kind: str) -> Path:
+    if kind == "presentation":
+        return case_dir / "outputs" / "presentations" / "current"
+    if kind == "note":
+        return case_dir / "notes"
+    if kind == "audio":
+        return case_dir / "source_materials" / "interviews" / "audio"
+    if kind == "source":
+        return case_dir / "source_materials" / "project_docs"
+    raise CaseWorkspaceError(f"Unsupported case file kind: {kind}")
+
+
+def _copy_destination_for_source(
+    source_path: Path,
+    destination_dir: Path,
+    *,
+    overwrite: bool,
+) -> tuple[Path, bool]:
+    destination = destination_dir / source_path.name
+    if not destination.exists():
+        return destination, True
+    if destination.resolve() == source_path.resolve():
+        return destination, False
+    if _file_sha256(destination) == _file_sha256(source_path):
+        return destination, False
+    if overwrite:
+        return destination, True
+
+    for index in range(2, 1000):
+        candidate = destination.with_name(
+            f"{destination.stem}-{index}{destination.suffix}"
+        )
+        if not candidate.exists():
+            return candidate, True
+        if _file_sha256(candidate) == _file_sha256(source_path):
+            return candidate, False
+    raise CaseWorkspaceError(
+        f"Could not choose a non-conflicting destination for {source_path.name}"
+    )
+
+
+def _default_normalized_pptx_path(path: Path) -> Path:
+    return path.with_name(f"{path.stem}_normalized_for_merge{path.suffix}")
+
+
+@case_operation
+def copy_case_file(
+    case_dir: Path,
+    source_file: Path,
+    *,
+    kind: str = "auto",
+    register: bool = False,
+    title: str | None = None,
+    material_type: str | None = None,
+    overwrite: bool = False,
+    normalize_legacy_pptx: bool = True,
+    soffice_binary: Path | None = None,
+    now: datetime | None = None,
+) -> CaseFileCopyResult:
+    """Copy a downloaded/local file into the appropriate case folder."""
+
+    if not source_file.exists():
+        raise FileNotFoundError(source_file)
+    if not source_file.is_file():
+        raise CaseWorkspaceError(f"case file source must be a file: {source_file}")
+    resolved_source = source_file.resolve()
+    resolved_kind = _normalize_case_file_kind(kind, resolved_source)
+    destination_dir = _case_file_destination_dir(case_dir, resolved_kind)
+    destination_dir.mkdir(parents=True, exist_ok=True)
+    destination_path, should_copy = _copy_destination_for_source(
+        resolved_source,
+        destination_dir,
+        overwrite=overwrite,
+    )
+    if should_copy:
+        track_write(destination_path)
+        shutil.copy2(resolved_source, destination_path)
+
+    legacy_pptx_normalization: LegacyPptxNormalizationResult | None = None
+    if normalize_legacy_pptx and resolved_kind == "presentation":
+        legacy_pptx_normalization = _normalize_copied_presentation_for_merge(
+            destination_path,
+            soffice_binary=soffice_binary,
+            now=now,
+        )
+
+    registered_material: dict[str, Any] | None = None
+    if register:
+        default_material_type = "note" if resolved_kind == "note" else "source"
+        registered_material = register_material(
+            case_dir,
+            destination_path,
+            material_type=material_type or default_material_type,
+            title=title,
+            now=now,
+        )
+
+    return CaseFileCopyResult(
+        source_path=resolved_source,
+        destination_path=destination_path.resolve(),
+        kind=resolved_kind,
+        copied=should_copy,
+        registered_material=registered_material,
+        legacy_pptx_normalization=legacy_pptx_normalization,
+    )
+
+
+def _normalize_copied_presentation_for_merge(
+    deck_path: Path,
+    *,
+    soffice_binary: Path | None = None,
+    now: datetime | None = None,
+) -> LegacyPptxNormalizationResult | None:
+    if deck_path.suffix.lower() != ".pptx":
+        return None
+    try:
+        legacy_media = inspect_pptx_legacy_media(deck_path)
+    except BadZipFile:
+        LOGGER.warning(
+            "Skipping legacy PPTX normalization because %s is not a readable PPTX package.",
+            deck_path,
+        )
+        return None
+    if not legacy_media:
+        return None
+    output_path = _default_normalized_pptx_path(deck_path)
+    return normalize_legacy_pptx_for_editable_merge(
+        deck_path,
+        output_path=output_path,
+        overwrite=True,
+        soffice_binary=soffice_binary,
+        now=now,
+    )
+
+
+def inspect_pptx_legacy_media(path: Path) -> tuple[str, ...]:
+    """Return WMF/EMF media parts embedded in a PPTX package."""
+
+    if not path.exists():
+        raise FileNotFoundError(path)
+    if path.suffix.lower() != ".pptx":
+        raise CaseWorkspaceError(f"legacy deck normalization expects a .pptx: {path}")
+
+    with ZipFile(path) as package:
+        legacy_media = sorted(
+            name
+            for name in package.namelist()
+            if name.startswith("ppt/media/")
+            and Path(name).suffix.lower() in LEGACY_PPTX_MEDIA_SUFFIXES
+        )
+    return tuple(legacy_media)
+
+
+def resolve_soffice_binary(configured: Path | None = None) -> Path:
+    """Resolve the LibreOffice binary used for PPTX normalization."""
+
+    candidates: list[Path] = []
+    if configured is not None:
+        candidates.append(configured)
+    env_value = os.environ.get("SOFFICE_BINARY", "").strip()
+    if env_value:
+        candidates.append(Path(env_value))
+    for binary_name in ("soffice", "libreoffice"):
+        resolved = shutil.which(binary_name)
+        if resolved:
+            candidates.append(Path(resolved))
+    candidates.extend(DEFAULT_SOFFICE_PATHS)
+
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate.resolve()
+    raise CaseWorkspaceError(
+        "No LibreOffice executable found. Install LibreOffice or set SOFFICE_BINARY."
+    )
+
+
+def _soffice_profile_uri(path: Path) -> str:
+    return path.resolve().as_uri()
+
+
+def _run_soffice_pptx_roundtrip(
+    source_path: Path,
+    *,
+    output_dir: Path,
+    soffice_binary: Path,
+) -> Path:
+    """Round-trip a presentation through LibreOffice and return its PPTX output."""
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="clara_soffice_profile_") as profile_dir:
+        command = [
+            str(soffice_binary),
+            f"-env:UserInstallation={_soffice_profile_uri(Path(profile_dir))}",
+            "--headless",
+            "--invisible",
+            "--nodefault",
+            "--nofirststartwizard",
+            "--nolockcheck",
+            "--norestore",
+            "--convert-to",
+            "pptx",
+            "--outdir",
+            str(output_dir),
+            str(source_path.resolve()),
+        ]
+        stdout_path = output_dir / "soffice.stdout.log"
+        stderr_path = output_dir / "soffice.stderr.log"
+        try:
+            with (
+                stdout_path.open("w", encoding="utf-8") as stdout,
+                stderr_path.open("w", encoding="utf-8") as stderr,
+            ):
+                completed = run_process(
+                    command,
+                    check=False,
+                    text=True,
+                    timeout=90,
+                    stdout=stdout,
+                    stderr=stderr,
+                )
+        except (OSError, subprocess.TimeoutExpired) as exc:
+            raise CaseWorkspaceError(
+                f"LibreOffice normalization failed; logs retained in {output_dir}: {exc}"
+            ) from exc
+    output_path = output_dir / source_path.name
+    if completed.returncode != 0 or not output_path.exists():
+        with stderr_path.open(encoding="utf-8", errors="replace") as stream:
+            message = stream.read(800).strip()
+        if not message:
+            with stdout_path.open(encoding="utf-8", errors="replace") as stream:
+                message = stream.read(800).strip()
+        message = message or "unknown error"
+        raise CaseWorkspaceError(
+            f"LibreOffice failed to normalize PPTX for editable merge: {message}"
+        )
+    return output_path
+
+
+def _ensure_custom_props_content_type(content_types_xml: bytes) -> bytes:
+    ET.register_namespace("", CONTENT_TYPES_NS)
+    root = parse_xml(content_types_xml)
+    override_tag = f"{{{CONTENT_TYPES_NS}}}Override"
+    has_override = any(
+        child.tag == override_tag
+        and child.attrib.get("PartName") == "/docProps/custom.xml"
+        for child in root
+    )
+    if not has_override:
+        ET.SubElement(
+            root,
+            override_tag,
+            {
+                "PartName": "/docProps/custom.xml",
+                "ContentType": CUSTOM_PROPS_CONTENT_TYPE,
+            },
+        )
+    return ET.tostring(root, encoding="utf-8", xml_declaration=True)
+
+
+def _replace_zip_parts(zip_path: Path, replacements: Mapping[str, bytes]) -> None:
+    temporary_path = zip_path.with_name(f".{zip_path.name}.tmp")
+    with (
+        ZipFile(zip_path, "r") as source_zip,
+        ZipFile(temporary_path, "w", compression=ZIP_DEFLATED) as target_zip,
+    ):
+        for item in source_zip.infolist():
+            if item.filename in replacements:
+                continue
+            target_zip.writestr(item, source_zip.read(item.filename))
+        for name, data in replacements.items():
+            target_zip.writestr(name, data)
+    temporary_path.replace(zip_path)
+
+
+def _preserve_custom_properties(source_path: Path, output_path: Path) -> bool:
+    with ZipFile(source_path, "r") as source_zip:
+        source_names = set(source_zip.namelist())
+        if "docProps/custom.xml" not in source_names:
+            return False
+        custom_xml = source_zip.read("docProps/custom.xml")
+
+    with ZipFile(output_path, "r") as output_zip:
+        output_names = set(output_zip.namelist())
+        if "[Content_Types].xml" not in output_names:
+            raise CaseWorkspaceError("Normalized PPTX is missing [Content_Types].xml")
+        content_types_xml = _ensure_custom_props_content_type(
+            output_zip.read("[Content_Types].xml")
+        )
+
+    _replace_zip_parts(
+        output_path,
+        {
+            "[Content_Types].xml": content_types_xml,
+            "docProps/custom.xml": custom_xml,
+        },
+    )
+    return True
+
+
+def _validate_pptx_package(path: Path) -> None:
+    with ZipFile(path, "r") as package:
+        corrupt_member = package.testzip()
+    if corrupt_member is not None:
+        raise CaseWorkspaceError(
+            f"Normalized PPTX package contains a corrupt member: {corrupt_member}"
+        )
+
+
+def normalize_legacy_pptx_for_editable_merge(
+    source_path: Path,
+    *,
+    output_path: Path | None = None,
+    report_path: Path | None = None,
+    force: bool = False,
+    overwrite: bool = False,
+    soffice_binary: Path | None = None,
+    now: datetime | None = None,
+) -> LegacyPptxNormalizationResult:
+    """Normalize WMF/EMF-heavy PPTX decks before editable slide merging.
+
+    The helper is deterministic around inspection, package validation, metadata
+    preservation, and reporting. LibreOffice performs only the mechanical PPTX
+    round-trip needed to rewrite legacy presentation internals.
+    """
+
+    resolved_source = source_path.resolve()
+    before = inspect_pptx_legacy_media(resolved_source)
+    resolved_output = (
+        output_path.resolve()
+        if output_path is not None
+        else _default_normalized_pptx_path(resolved_source)
+    )
+    if resolved_output == resolved_source:
+        raise CaseWorkspaceError("normalized PPTX output must not overwrite the source")
+    if resolved_output.exists() and not overwrite:
+        raise CaseWorkspaceError(
+            f"normalized PPTX output already exists: {resolved_output}"
+        )
+    resolved_output.parent.mkdir(parents=True, exist_ok=True)
+
+    used_soffice: Path | None = None
+    normalized = bool(before) or force
+    if normalized:
+        used_soffice = resolve_soffice_binary(soffice_binary)
+        attempts_dir = resolved_output.parent / ".normalization-attempts"
+        attempts_dir.mkdir(parents=True, exist_ok=True)
+        attempt_dir = Path(tempfile.mkdtemp(prefix="attempt-", dir=attempts_dir))
+        roundtrip_path = _run_soffice_pptx_roundtrip(
+            resolved_source,
+            output_dir=attempt_dir,
+            soffice_binary=used_soffice,
+        )
+        shutil.copy2(roundtrip_path, resolved_output)
+        custom_properties_preserved = _preserve_custom_properties(
+            resolved_source, resolved_output
+        )
+    else:
+        shutil.copy2(resolved_source, resolved_output)
+        custom_properties_preserved = _preserve_custom_properties(
+            resolved_source, resolved_output
+        )
+
+    _validate_pptx_package(resolved_output)
+    after = inspect_pptx_legacy_media(resolved_output)
+    resolved_report = (
+        report_path.resolve()
+        if report_path is not None
+        else resolved_output.with_suffix(".normalization_report.json")
+    )
+    resolved_report.parent.mkdir(parents=True, exist_ok=True)
+    report = {
+        "schema_version": 1,
+        "source_path": str(resolved_source),
+        "output_path": str(resolved_output),
+        "normalized": normalized,
+        "legacy_media_before": list(before),
+        "legacy_media_after": list(after),
+        "legacy_media_before_count": len(before),
+        "legacy_media_after_count": len(after),
+        "soffice_binary": str(used_soffice) if used_soffice is not None else None,
+        "custom_properties_preserved": custom_properties_preserved,
+        "created_at": _now_iso(now),
+        "merge_guidance": (
+            "Use this normalized PPTX as the base for editable slide merging."
+            if not after
+            else "Legacy WMF/EMF media remain; prefer image fallback for affected slides."
+        ),
+    }
+    _write_json(resolved_report, report)
+
+    return LegacyPptxNormalizationResult(
+        source_path=resolved_source,
+        output_path=resolved_output,
+        report_path=resolved_report,
+        normalized=normalized,
+        legacy_media_before=before,
+        legacy_media_after=after,
+        soffice_binary=used_soffice,
+    )
+
+
+def prepare_editable_pptx_merge_input(
+    source_path: Path,
+    *,
+    normalized_path: Path | None = None,
+    skip_normalization_reason: str | None = None,
+    report_path: Path | None = None,
+    now: datetime | None = None,
+) -> EditablePptxMergeInputResult:
+    """Select and audit the PPTX base allowed into editable slide merging.
+
+    Legacy WMF/EMF-heavy decks must use a normalized merge base. A caller can
+    bypass that only by recording an explicit skip reason in the generated
+    report; this prevents silent fallback to fragile editable merging.
+    """
+
+    resolved_source = source_path.resolve()
+    source_legacy_media = inspect_pptx_legacy_media(resolved_source)
+    requested_normalized_path = (
+        normalized_path.resolve() if normalized_path is not None else None
+    )
+    discovered_normalized_path = _default_normalized_pptx_path(resolved_source)
+    candidate_normalized_path = requested_normalized_path
+    if candidate_normalized_path is None and discovered_normalized_path.exists():
+        candidate_normalized_path = discovered_normalized_path.resolve()
+
+    reason = (skip_normalization_reason or "").strip()
+    normalized_path_for_report: Path | None = None
+    if source_legacy_media:
+        if candidate_normalized_path is not None:
+            if not candidate_normalized_path.exists():
+                raise FileNotFoundError(candidate_normalized_path)
+            merge_base_path = candidate_normalized_path
+            normalized_path_for_report = candidate_normalized_path
+            status = "normalized_merge_base_ready"
+        elif reason:
+            merge_base_path = resolved_source
+            status = "normalization_skipped_with_reason"
+        else:
+            raise CaseWorkspaceError(
+                "Editable PPTX merge requires a normalized source path for "
+                f"legacy WMF/EMF media in {resolved_source}. Run "
+                "scripts/normalize_legacy_pptx.py or pass a "
+                "skip_normalization_reason to record why normalization is not used."
+            )
+    else:
+        if candidate_normalized_path is not None:
+            if not candidate_normalized_path.exists():
+                raise FileNotFoundError(candidate_normalized_path)
+            merge_base_path = candidate_normalized_path
+            normalized_path_for_report = candidate_normalized_path
+            status = "explicit_merge_base_ready"
+        else:
+            merge_base_path = resolved_source
+            status = "source_clean_for_merge"
+
+    merge_base_legacy_media = inspect_pptx_legacy_media(merge_base_path)
+    if source_legacy_media and status == "normalized_merge_base_ready":
+        if merge_base_path == resolved_source:
+            raise CaseWorkspaceError(
+                "normalized merge base must be a separate file from the legacy source"
+            )
+        if merge_base_legacy_media and not reason:
+            raise CaseWorkspaceError(
+                "Normalized merge base still contains WMF/EMF media; pass a "
+                "skip_normalization_reason to record why editable merge is still "
+                "being attempted, or use an image fallback for affected slides."
+            )
+        if merge_base_legacy_media:
+            status = "normalized_merge_base_has_legacy_media_with_reason"
+
+    resolved_report = (
+        report_path.resolve()
+        if report_path is not None
+        else merge_base_path.with_suffix(".editable_merge_input_report.json")
+    )
+    resolved_report.parent.mkdir(parents=True, exist_ok=True)
+    report = {
+        "schema_version": 1,
+        "source_path": str(resolved_source),
+        "merge_base_path": str(merge_base_path),
+        "normalized_path": (
+            str(normalized_path_for_report)
+            if normalized_path_for_report is not None
+            else None
+        ),
+        "status": status,
+        "source_legacy_media": list(source_legacy_media),
+        "source_legacy_media_count": len(source_legacy_media),
+        "merge_base_legacy_media": list(merge_base_legacy_media),
+        "merge_base_legacy_media_count": len(merge_base_legacy_media),
+        "skip_normalization_reason": reason or None,
+        "editable_merge_guard": (
+            "normalized_required"
+            if source_legacy_media
+            else "normalization_not_required"
+        ),
+        "created_at": _now_iso(now),
+    }
+    _write_json(resolved_report, report)
+
+    return EditablePptxMergeInputResult(
+        source_path=resolved_source,
+        merge_base_path=merge_base_path,
+        report_path=resolved_report,
+        status=status,
+        source_legacy_media=source_legacy_media,
+        merge_base_legacy_media=merge_base_legacy_media,
+        normalized_path=normalized_path_for_report,
+        skip_normalization_reason=reason or None,
+    )
+
+
+def _known_material_ids(case_dir: Path) -> set[str]:
+    registry = _read_json(_case_path(case_dir, "materials"))
+    return {str(item["id"]) for item in registry["materials"]}
+
+
+def _known_judgement_ids(case_dir: Path) -> set[str]:
+    judgement = _read_json(_case_path(case_dir, "judgement"))
+    return {str(item["id"]) for item in judgement["entries"]}
+
+
+def _claim_records_by_id(case_dir: Path) -> dict[str, dict[str, Any]]:
+    path = case_dir / CLAIM_REGISTER_FILENAME
+    payload = _read_json(path)
+    return {
+        str(item["id"]): item
+        for item in payload.get("claims", [])
+        if isinstance(item, dict) and item.get("id")
+    }
+
+
+def _assert_judgement_claim_binding(
+    case_dir: Path,
+    *,
+    text: str,
+    advisory_claim_id: str,
+    evidence_receipt_ids: Sequence[Any],
+) -> None:
+    if not advisory_claim_id:
+        raise CaseWorkspaceError(
+            "approved judgement requires advisory_claim_id so client-pack content cannot bypass advisory lineage"
+        )
+    claim = _claim_records_by_id(case_dir).get(advisory_claim_id)
+    if claim is None:
+        raise CaseWorkspaceError(f"unknown advisory_claim_id: {advisory_claim_id}")
+    if claim.get("state") != "active":
+        raise CaseWorkspaceError(
+            f"approved judgement references non-active claim: {advisory_claim_id}"
+        )
+
+    def normalize(value: Any) -> str:
+        return re.sub(r"\s+", " ", str(value)).strip()
+
+    if normalize(claim.get("statement", "")) != normalize(text):
+        raise CaseWorkspaceError(
+            f"judgement text must exactly carry advisory claim {advisory_claim_id}"
+        )
+    linked_receipts = {
+        str(link.get("evidence_id"))
+        for link in claim.get("evidence_links", [])
+        if isinstance(link, dict) and link.get("evidence_id")
+    }
+    declared_receipts = {str(value) for value in evidence_receipt_ids}
+    if declared_receipts != linked_receipts:
+        raise CaseWorkspaceError(
+            f"judgement evidence_receipt_ids must exactly match {advisory_claim_id}"
+        )
+
+
+def _known_open_question_ids(case_dir: Path) -> set[str]:
+    payload = _read_json(_case_path(case_dir, "open_questions"))
+    return {str(item["id"]) for item in payload["questions"]}
+
+
+@case_operation
+def add_judgement_entries(
+    case_dir: Path,
+    entries: Sequence[Mapping[str, Any]],
+    *,
+    now: datetime | None = None,
+) -> list[dict[str, Any]]:
+    """Store Codex-structured judgement entries with explicit review status."""
+
+    timestamp = _now_iso(now)
+    known_material_ids = _known_material_ids(case_dir)
+    known_claims = _claim_records_by_id(case_dir)
+    judgement_path = _case_path(case_dir, "judgement")
+    judgement = _read_json(judgement_path)
+    existing_ids = [item["id"] for item in judgement["entries"]]
+    added: list[dict[str, Any]] = []
+
+    for raw_entry in entries:
+        kind = str(raw_entry.get("kind", ""))
+        status = str(raw_entry.get("status", "pending"))
+        text = str(raw_entry.get("text", "")).strip()
+        _validate_choice(kind, JUDGEMENT_KINDS, "kind")
+        _validate_choice(status, JUDGEMENT_STATUSES, "status")
+        if not text:
+            raise CaseWorkspaceError("judgement text cannot be empty")
+        source_ids = list(raw_entry.get("source_material_ids", []))
+        unknown_sources = sorted(set(source_ids) - known_material_ids)
+        if unknown_sources:
+            raise CaseWorkspaceError(
+                "unknown source_material_ids: " + ", ".join(unknown_sources)
+            )
+        advisory_claim_id = str(raw_entry.get("advisory_claim_id", "")).strip()
+        if advisory_claim_id and advisory_claim_id not in known_claims:
+            raise CaseWorkspaceError(f"unknown advisory_claim_id: {advisory_claim_id}")
+        evidence_receipt_ids = [
+            str(value).strip()
+            for value in raw_entry.get("evidence_receipt_ids", [])
+            if str(value).strip()
+        ]
+        if len(evidence_receipt_ids) != len(set(evidence_receipt_ids)):
+            raise CaseWorkspaceError("evidence_receipt_ids must be unique")
+        if advisory_claim_id:
+            claim_evidence_ids = {
+                str(link.get("evidence_id"))
+                for link in known_claims[advisory_claim_id].get("evidence_links", [])
+                if isinstance(link, dict) and link.get("evidence_id")
+            }
+            if set(evidence_receipt_ids) != claim_evidence_ids:
+                raise CaseWorkspaceError(
+                    "judgement evidence_receipt_ids must exactly match claim "
+                    f"{advisory_claim_id}"
+                )
+        if status == "approved":
+            _assert_judgement_claim_binding(
+                case_dir,
+                text=text,
+                advisory_claim_id=advisory_claim_id,
+                evidence_receipt_ids=evidence_receipt_ids,
+            )
+
+        entry = {
+            "id": _next_id("jud", [*existing_ids, *(item["id"] for item in added)]),
+            "kind": kind,
+            "text": text,
+            "status": status,
+            "source_material_ids": source_ids,
+            "rationale": str(raw_entry.get("rationale", "")).strip(),
+            "captured_at": timestamp,
+            "reviewed_at": timestamp if status != "pending" else None,
+            "reviewer": str(raw_entry.get("reviewer", "")).strip() or None,
+            "review_note": str(raw_entry.get("review_note", "")).strip(),
+            "advisory_claim_id": advisory_claim_id,
+            "evidence_receipt_ids": evidence_receipt_ids,
+        }
+        judgement["entries"].append(entry)
+        added.append(entry)
+
+    _write_json(judgement_path, judgement)
+    _touch_manifest(case_dir, timestamp)
+    refresh_case_brief(case_dir, now=now)
+    return added
+
+
+@case_operation
+def record_analysis_contribution(
+    case_dir: Path,
+    *,
+    evidence_receipts: Sequence[Mapping[str, Any]],
+    claims: Sequence[Mapping[str, Any]],
+    judgement_entries: Sequence[Mapping[str, Any]] = (),
+    now: datetime | None = None,
+) -> dict[str, Any]:
+    """Commit one model-authored evidence/claim contribution atomically.
+
+    Semantic contents are supplied by Clara or the advisor. This helper is
+    deterministic because it only validates and commits declared records and
+    restores the prior files if any later step fails.
+    """
+
+    paths = [
+        case_dir / EVIDENCE_REGISTER_FILENAME,
+        case_dir / CLAIM_REGISTER_FILENAME,
+        case_dir / "advisory_evidence_map.md",
+        _case_path(case_dir, "judgement"),
+        _case_path(case_dir, "manifest"),
+        case_dir / CASE_BRIEF_FILENAME,
+    ]
+    snapshot = _snapshot_files(paths)
+    completed = False
+    try:
+        evidence_added = record_evidence(case_dir, evidence_receipts)
+        claims_added = record_claims(case_dir, claims)
+        added_judgements = add_judgement_entries(
+            case_dir,
+            judgement_entries,
+            now=now,
+        )
+        errors = validate_case_workspace(case_dir)
+        if errors:
+            raise CaseWorkspaceError("; ".join(errors))
+        completed = True
+    finally:
+        if not completed:
+            _restore_files(snapshot)
+    return {
+        "evidence_added": evidence_added,
+        "claims_added": claims_added,
+        "judgement_entries": added_judgements,
+    }
+
+
+def _semantic_claim_register_sha256(payload: Mapping[str, Any]) -> str:
+    """Hash claim meaning while excluding output appearances.
+
+    Exact output appearances are added after a workpaper is committed. Excluding
+    only that field keeps the checkpoint current across deck builds while every
+    claim, dependency, state, limitation, and supersession change invalidates it.
+    """
+
+    semantic_payload = json.loads(json.dumps(payload))
+    claims = semantic_payload.get("claims", [])
+    if isinstance(claims, list):
+        for claim in claims:
+            if isinstance(claim, dict):
+                claim["appearances"] = []
+    canonical = json.dumps(
+        semantic_payload,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("utf-8")
+    return sha256(canonical).hexdigest()
+
+
+def _claim_and_evidence_closure(
+    claim_by_id: Mapping[str, Mapping[str, Any]],
+    evidence_by_id: Mapping[str, Mapping[str, Any]],
+    selected_claim_ids: Sequence[str],
+) -> tuple[list[str], list[str]]:
+    """Resolve declared claim dependencies and evidence history mechanically."""
+
+    claim_ids = _dedupe_preserve_order(selected_claim_ids)
+    pending_claims = list(claim_ids)
+    while pending_claims:
+        claim_id = pending_claims.pop(0)
+        dependency = claim_by_id[claim_id].get("dependency", {})
+        dependencies = (
+            dependency.get("claim_ids", []) if isinstance(dependency, dict) else []
+        )
+        for dependency_id in dependencies:
+            normalized = str(dependency_id).strip()
+            if normalized and normalized not in claim_ids:
+                claim_ids.append(normalized)
+                pending_claims.append(normalized)
+
+    evidence_ids: list[str] = []
+    for claim_id in claim_ids:
+        claim = claim_by_id[claim_id]
+        for link in claim.get("evidence_links", []):
+            if not isinstance(link, dict):
+                continue
+            evidence_id = str(link.get("evidence_id", "")).strip()
+            if evidence_id and evidence_id not in evidence_ids:
+                evidence_ids.append(evidence_id)
+        dependency = claim.get("dependency", {})
+        if isinstance(dependency, dict):
+            calculation_id = str(dependency.get("calculation_evidence_id", "")).strip()
+            if calculation_id and calculation_id not in evidence_ids:
+                evidence_ids.append(calculation_id)
+
+    history_neighbours: dict[str, set[str]] = {
+        evidence_id: set() for evidence_id in evidence_by_id
+    }
+    for evidence_id, receipt in evidence_by_id.items():
+        for field in ("rechecks_evidence_id", "supersedes_evidence_id"):
+            referenced_id = str(receipt.get(field, "")).strip()
+            if referenced_id and referenced_id in evidence_by_id:
+                history_neighbours[evidence_id].add(referenced_id)
+                history_neighbours[referenced_id].add(evidence_id)
+
+    pending_evidence = list(evidence_ids)
+    while pending_evidence:
+        evidence_id = pending_evidence.pop(0)
+        for referenced_id in sorted(history_neighbours.get(evidence_id, set())):
+            if referenced_id and referenced_id not in evidence_ids:
+                evidence_ids.append(referenced_id)
+                pending_evidence.append(referenced_id)
+    return claim_ids, evidence_ids
+
+
+def _case_direction_return_schema_errors(payload: Any) -> list[str]:
+    """Validate only the mechanically stable case-return envelope shape."""
+
+    try:
+        schema = _read_json(CASE_DIRECTION_RETURN_SCHEMA_PATH)
+        Draft202012Validator.check_schema(schema)
+    except (OSError, json.JSONDecodeError) as exc:
+        return [f"cannot load case-direction return schema: {exc}"]
+    errors = sorted(
+        Draft202012Validator(schema).iter_errors(payload),
+        key=lambda error: tuple(str(part) for part in error.absolute_path),
+    )
+    return [
+        "case-direction return"
+        + (
+            "." + ".".join(str(part) for part in error.absolute_path)
+            if error.absolute_path
+            else ""
+        )
+        + f": {error.message}"
+        for error in errors
+    ]
+
+
+def _json_sha256(payload: Mapping[str, Any]) -> str:
+    canonical = json.dumps(
+        payload,
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("utf-8")
+    return sha256(canonical).hexdigest()
+
+
+def _resolve_case_direction_artifact(
+    case_dir: Path,
+    artifact: Mapping[str, Any],
+) -> Path:
+    raw_path = Path(str(artifact.get("path", ""))).expanduser()
+    reference = str(artifact.get("path_reference", ""))
+    if reference == "case_relative":
+        resolved = (case_dir.resolve() / raw_path).resolve()
+        try:
+            resolved.relative_to(case_dir.resolve())
+        except ValueError as exc:
+            raise CaseWorkspaceError(
+                f"case-relative return artifact escapes the case folder: {raw_path}"
+            ) from exc
+        return resolved
+    if reference == "absolute":
+        if not raw_path.is_absolute():
+            raise CaseWorkspaceError(
+                f"absolute return artifact path is not absolute: {raw_path}"
+            )
+        return raw_path.resolve()
+    raise CaseWorkspaceError(f"unsupported return artifact path_reference: {reference}")
+
+
+def _verify_case_direction_artifact(
+    case_dir: Path,
+    artifact: Mapping[str, Any],
+    *,
+    label: str,
+) -> Path:
+    path = _resolve_case_direction_artifact(case_dir, artifact)
+    if not path.is_file():
+        raise CaseWorkspaceError(f"{label} does not exist: {path}")
+    expected_size = artifact.get("byte_count")
+    if path.stat().st_size != expected_size:
+        raise CaseWorkspaceError(f"{label} byte_count does not match: {path}")
+    actual_sha256 = sha256(path.read_bytes()).hexdigest()
+    if actual_sha256 != artifact.get("sha256"):
+        raise CaseWorkspaceError(f"{label} sha256 does not match: {path}")
+    return path
+
+
+def _validate_validation_return_binding(
+    case_dir: Path,
+    binding: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Bind feedback to exact validator bytes and the pre-feedback lineage.
+
+    These comparisons are deterministic because the validator already declared
+    the reviewed IDs and hashes. They do not decide whether any finding is
+    semantically correct or what the case director should conclude from it.
+    """
+
+    review_path = _verify_case_direction_artifact(
+        case_dir,
+        binding["review_artifact"],
+        label="validation review artifact",
+    )
+    audit_path = _verify_case_direction_artifact(
+        case_dir,
+        binding["audit_artifact"],
+        label="validation audit artifact",
+    )
+    try:
+        review = _read_json(review_path)
+        audit = _read_json(audit_path)
+    except json.JSONDecodeError as exc:
+        raise CaseWorkspaceError(
+            f"validation return artifact is not valid JSON: {exc}"
+        ) from exc
+
+    lineage = audit.get("lineage")
+    if (
+        not isinstance(lineage, dict)
+        or lineage.get("provenance_mode") != "generation_time"
+    ):
+        raise CaseWorkspaceError(
+            "validation feedback can return to a case spine only from generation-time lineage"
+        )
+    review_lineage = review.get("lineage_review")
+    if not isinstance(review_lineage, dict):
+        raise CaseWorkspaceError("validation review lacks lineage_review")
+    review_claim_ids = {
+        str(value) for value in review_lineage.get("reviewed_claim_ids", [])
+    }
+    audit_claim_ids = {str(value) for value in lineage.get("reviewed_claim_ids", [])}
+    if review_claim_ids != audit_claim_ids:
+        raise CaseWorkspaceError(
+            "validation review and audit disagree on reviewed_claim_ids"
+        )
+    audit_deliverable = audit.get("deliverable")
+    if not isinstance(audit_deliverable, dict) or review.get(
+        "deliverable_sha256"
+    ) != audit_deliverable.get("sha256"):
+        raise CaseWorkspaceError(
+            "validation review and audit disagree on deliverable_sha256"
+        )
+
+    known_finding_ids = {
+        str(item.get("id"))
+        for item in review.get("findings", [])
+        if isinstance(item, dict) and item.get("id")
+    }
+    unknown_findings = sorted(
+        set(str(value) for value in binding.get("finding_ids", [])) - known_finding_ids
+    )
+    if unknown_findings:
+        raise CaseWorkspaceError(
+            "validation binding has unknown finding ids: " + ", ".join(unknown_findings)
+        )
+
+    evidence_binding = lineage.get("evidence_register")
+    claim_binding = lineage.get("claim_register")
+    if not isinstance(evidence_binding, dict) or not isinstance(claim_binding, dict):
+        raise CaseWorkspaceError(
+            "validation audit lacks generation-time register bindings"
+        )
+    current_evidence_sha256 = sha256(
+        (case_dir / EVIDENCE_REGISTER_FILENAME).read_bytes()
+    ).hexdigest()
+    current_claim_sha256 = sha256(
+        (case_dir / CLAIM_REGISTER_FILENAME).read_bytes()
+    ).hexdigest()
+    if evidence_binding.get("sha256") != current_evidence_sha256:
+        raise CaseWorkspaceError(
+            "validation feedback is stale: evidence register changed after validation"
+        )
+    if claim_binding.get("sha256") != current_claim_sha256:
+        raise CaseWorkspaceError(
+            "validation feedback is stale: claim register changed after validation"
+        )
+    return {
+        "review_path": str(review_path),
+        "audit_path": str(audit_path),
+        "reviewed_claim_ids": sorted(review_claim_ids),
+        "finding_ids": [str(value) for value in binding.get("finding_ids", [])],
+        "record_complete": bool(audit.get("record_complete")),
+        "effective_delivery_readiness": str(
+            audit.get("effective_delivery_readiness", "blocked")
+        ),
+    }
+
+
+def _apply_case_direction_question_changes(
+    case_dir: Path,
+    *,
+    updates: Sequence[Mapping[str, Any]],
+    additions: Sequence[Mapping[str, Any]],
+    new_judgement_ids: Sequence[str],
+    timestamp: str,
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    questions_path = _case_path(case_dir, "open_questions")
+    payload = _read_json(questions_path)
+    questions = payload.get("questions")
+    if not isinstance(questions, list):
+        raise CaseWorkspaceError("open_questions.json: questions must be a list")
+    by_id = {
+        str(item.get("id")): item
+        for item in questions
+        if isinstance(item, dict) and item.get("id")
+    }
+    applied_updates: list[dict[str, Any]] = []
+    for update in updates:
+        question_id = str(update.get("question_id", ""))
+        question = by_id.get(question_id)
+        if question is None:
+            raise CaseWorkspaceError(f"unknown question_id: {question_id}")
+        status = str(update.get("status", ""))
+        _validate_choice(status, OPEN_QUESTION_STATUSES, "question status")
+        previous_status = str(question.get("status", ""))
+        question["status"] = status
+        question["updated_at"] = timestamp
+        applied_updates.append(
+            {
+                "question_id": question_id,
+                "previous_status": previous_status,
+                "status": status,
+                "explanation": str(update.get("explanation", "")),
+            }
+        )
+
+    judgement_ids = _known_judgement_ids(case_dir)
+    added_questions: list[dict[str, Any]] = []
+    for addition in additions:
+        source_entry_ids = [
+            str(value) for value in addition.get("source_entry_ids", [])
+        ]
+        for raw_index in addition.get("source_judgement_indexes", []):
+            index = int(raw_index)
+            if index >= len(new_judgement_ids):
+                raise CaseWorkspaceError(
+                    f"new question source_judgement_indexes has no judgement at index {index}"
+                )
+            judgement_id = str(new_judgement_ids[index])
+            if judgement_id not in source_entry_ids:
+                source_entry_ids.append(judgement_id)
+        unknown_entries = sorted(set(source_entry_ids) - judgement_ids)
+        if unknown_entries:
+            raise CaseWorkspaceError(
+                "new question has unknown source judgement ids: "
+                + ", ".join(unknown_entries)
+            )
+        question = {
+            "id": _next_id(
+                "q",
+                [str(item.get("id")) for item in questions if isinstance(item, dict)],
+            ),
+            "question": str(addition.get("question", "")).strip(),
+            "why_it_matters": str(addition.get("why_it_matters", "")).strip(),
+            "status": "open",
+            "source_entry_ids": source_entry_ids,
+            "created_at": timestamp,
+            "updated_at": timestamp,
+        }
+        questions.append(question)
+        by_id[question["id"]] = question
+        added_questions.append(question)
+
+    if updates or additions:
+        _write_json(questions_path, payload)
+    return applied_updates, added_questions
+
+
+@case_operation
+def record_case_direction_return(
+    case_dir: Path,
+    declared_return: Mapping[str, Any],
+    *,
+    now: datetime | None = None,
+) -> dict[str, Any]:
+    """Record one model-authored branch or validator return into the case spine.
+
+    The helper enforces shape, IDs, hashes, graph reachability, atomicity, and
+    replay safety. The model remains responsible for the question, answer,
+    claims, evidence relationships, answer effect, and next questions.
+    """
+
+    payload = json.loads(json.dumps(dict(declared_return)))
+    schema_errors = _case_direction_return_schema_errors(payload)
+    if schema_errors:
+        raise CaseWorkspaceError("; ".join(schema_errors))
+    case_dir = case_dir.resolve()
+    request_sha256 = _json_sha256(payload)
+    return_id = str(payload["return_id"])
+    receipt_path = case_dir / CASE_DIRECTION_RETURNS_DIRNAME / f"{return_id}.json"
+    if receipt_path.is_file():
+        existing = _read_json(receipt_path)
+        if existing.get("request_sha256") != request_sha256:
+            raise CaseWorkspaceError(
+                f"case-direction return id {return_id!r} already exists with different content"
+            )
+        return {**existing, "receipt_path": str(receipt_path), "replayed": True}
+
+    workspace_errors = validate_case_workspace(case_dir)
+    if workspace_errors:
+        raise CaseWorkspaceError("; ".join(workspace_errors))
+    for index, artifact in enumerate(payload["source_artifacts"]):
+        _verify_case_direction_artifact(
+            case_dir,
+            artifact,
+            label=f"source_artifacts[{index}]",
+        )
+
+    validation_summary: dict[str, Any] | None = None
+    if payload["return_type"] == "validation_feedback":
+        validation_summary = _validate_validation_return_binding(
+            case_dir, payload["validation_binding"]
+        )
+
+    questions_payload = _read_json(_case_path(case_dir, "open_questions"))
+    questions_by_id = {
+        str(item.get("id")): item
+        for item in questions_payload.get("questions", [])
+        if isinstance(item, dict) and item.get("id")
+    }
+    branch = payload["branch"]
+    branch_question_id = str(branch.get("question_id", ""))
+    if branch_question_id:
+        question = questions_by_id.get(branch_question_id)
+        if question is None:
+            raise CaseWorkspaceError(
+                f"branch references unknown question_id: {branch_question_id}"
+            )
+        if str(question.get("question", "")) != str(branch.get("question", "")):
+            raise CaseWorkspaceError(
+                "branch.question must exactly match the referenced open question"
+            )
+        updated_question_ids = {
+            str(item.get("question_id")) for item in payload["question_updates"]
+        }
+        if branch_question_id not in updated_question_ids:
+            raise CaseWorkspaceError(
+                "a return bound to an existing question must declare its question update"
+            )
+
+    timestamp = _now_iso(now)
+    mutation_paths = [
+        case_dir / EVIDENCE_REGISTER_FILENAME,
+        case_dir / CLAIM_REGISTER_FILENAME,
+        case_dir / "advisory_evidence_map.md",
+        _case_path(case_dir, "judgement"),
+        _case_path(case_dir, "open_questions"),
+        _case_path(case_dir, "manifest"),
+        case_dir / CASE_BRIEF_FILENAME,
+        receipt_path,
+    ]
+    snapshot = _snapshot_files(mutation_paths)
+    completed = False
+    try:
+        evidence_receipts = payload["evidence_receipts"]
+        claims = payload["claims"]
+        judgement_entries = payload["judgement_entries"]
+        if evidence_receipts or claims or judgement_entries:
+            contribution = record_analysis_contribution(
+                case_dir,
+                evidence_receipts=evidence_receipts,
+                claims=claims,
+                judgement_entries=judgement_entries,
+                now=now,
+            )
+        else:
+            contribution = {
+                "evidence_added": 0,
+                "claims_added": 0,
+                "judgement_entries": [],
+            }
+        question_updates, new_questions = _apply_case_direction_question_changes(
+            case_dir,
+            updates=payload["question_updates"],
+            additions=payload["new_questions"],
+            new_judgement_ids=[
+                str(item.get("id")) for item in contribution["judgement_entries"]
+            ],
+            timestamp=timestamp,
+        )
+
+        evidence_register = _read_json(case_dir / EVIDENCE_REGISTER_FILENAME)
+        claim_register = _read_json(case_dir / CLAIM_REGISTER_FILENAME)
+        evidence_by_id = {
+            str(item.get("id")): item
+            for item in evidence_register.get("evidence", [])
+            if isinstance(item, dict) and item.get("id")
+        }
+        claim_by_id = {
+            str(item.get("id")): item
+            for item in claim_register.get("claims", [])
+            if isinstance(item, dict) and item.get("id")
+        }
+        result_claim_ids = [str(value) for value in payload["result_claim_ids"]]
+        unknown_result_claims = sorted(set(result_claim_ids) - set(claim_by_id))
+        if unknown_result_claims:
+            raise CaseWorkspaceError(
+                "unknown result_claim_ids: " + ", ".join(unknown_result_claims)
+            )
+        inactive_result_claims = sorted(
+            claim_id
+            for claim_id in result_claim_ids
+            if claim_by_id[claim_id].get("state") != "active"
+        )
+        if inactive_result_claims:
+            raise CaseWorkspaceError(
+                "result_claim_ids must be active: " + ", ".join(inactive_result_claims)
+            )
+        closure_claim_ids, closure_evidence_ids = _claim_and_evidence_closure(
+            claim_by_id,
+            evidence_by_id,
+            result_claim_ids,
+        )
+        declared_claim_ids = {
+            str(item.get("id")) for item in claims if isinstance(item, dict)
+        }
+        orphan_claim_ids = sorted(declared_claim_ids - set(closure_claim_ids))
+        if orphan_claim_ids:
+            raise CaseWorkspaceError(
+                "returned claims are outside the result dependency closure: "
+                + ", ".join(orphan_claim_ids)
+            )
+        declared_evidence_ids = {
+            str(item.get("id")) for item in evidence_receipts if isinstance(item, dict)
+        }
+        orphan_evidence_ids = sorted(declared_evidence_ids - set(closure_evidence_ids))
+        if orphan_evidence_ids:
+            raise CaseWorkspaceError(
+                "returned evidence is outside the result claim closure: "
+                + ", ".join(orphan_evidence_ids)
+            )
+
+        final_errors = validate_case_workspace(case_dir)
+        if final_errors:
+            raise CaseWorkspaceError("; ".join(final_errors))
+        receipt = {
+            "schema_version": "clara.case_direction_return_receipt.v1",
+            "recorded_at": timestamp,
+            "request_sha256": request_sha256,
+            "return_id": return_id,
+            "return_type": payload["return_type"],
+            "branch": branch,
+            "answer_effect": payload["answer_effect"],
+            "result_claim_ids": result_claim_ids,
+            "result_claim_closure": closure_claim_ids,
+            "result_evidence_closure": closure_evidence_ids,
+            "source_artifacts": payload["source_artifacts"],
+            "limitations": payload["limitations"],
+            "contribution": {
+                "evidence_added": contribution["evidence_added"],
+                "claims_added": contribution["claims_added"],
+                "judgement_entry_ids": [
+                    str(item.get("id")) for item in contribution["judgement_entries"]
+                ],
+            },
+            "question_updates": question_updates,
+            "new_question_ids": [item["id"] for item in new_questions],
+            "validation_binding": validation_summary,
+            "mechanical_limit": (
+                "This receipt proves declared hand-off integrity and graph closure; "
+                "it does not prove claim truth, support quality, materiality, or reasoning."
+            ),
+        }
+        _write_json(receipt_path, receipt)
+        _touch_manifest(case_dir, timestamp)
+        refresh_case_brief(case_dir, now=now)
+        completed = True
+    finally:
+        if not completed:
+            _restore_files(snapshot)
+    return {**receipt, "receipt_path": str(receipt_path), "replayed": False}
+
+
+@case_operation
+def commit_advisory_workpaper(
+    case_dir: Path,
+    authored_workpaper: Path,
+    *,
+    referenced_claim_ids: Sequence[str],
+    change_summary: str,
+    now: datetime | None = None,
+) -> dict[str, Any]:
+    """Commit one model-authored workpaper against current declared lineage.
+
+    This helper does not read the prose semantically or decide whether the
+    selected claims are complete. It validates the model-declared claim IDs,
+    resolves their declared dependency/evidence closure, preserves the prior
+    workpaper, and binds the new bytes to the current semantic lineage state.
+    """
+
+    source = authored_workpaper.expanduser().resolve()
+    target = (case_dir / ADVISORY_WORKPAPER_FILENAME).resolve()
+    checkpoint_path = case_dir / ADVISORY_WORKPAPER_CHECKPOINT_FILENAME
+    if not source.is_file():
+        raise CaseWorkspaceError(f"authored workpaper does not exist: {source}")
+    if source == target:
+        raise CaseWorkspaceError(
+            "authored workpaper must be staged separately before it is committed"
+        )
+    try:
+        workpaper_text = source.read_text(encoding="utf-8")
+    except UnicodeDecodeError as exc:
+        raise CaseWorkspaceError("authored workpaper must be UTF-8 Markdown") from exc
+    if not workpaper_text.strip():
+        raise CaseWorkspaceError("authored workpaper cannot be empty")
+    if source.suffix.casefold() not in {".md", ".markdown"}:
+        raise CaseWorkspaceError("authored workpaper must be Markdown")
+    if not change_summary.strip():
+        raise CaseWorkspaceError("change_summary cannot be empty")
+
+    workspace_errors = validate_case_workspace(case_dir)
+    if workspace_errors:
+        raise CaseWorkspaceError("; ".join(workspace_errors))
+    evidence_path = case_dir / EVIDENCE_REGISTER_FILENAME
+    claim_path = case_dir / CLAIM_REGISTER_FILENAME
+    evidence_register = _read_json(evidence_path)
+    claim_register = _read_json(claim_path)
+    evidence_by_id = {
+        str(item.get("id")): item
+        for item in evidence_register.get("evidence", [])
+        if isinstance(item, dict) and item.get("id")
+    }
+    claim_by_id = {
+        str(item.get("id")): item
+        for item in claim_register.get("claims", [])
+        if isinstance(item, dict) and item.get("id")
+    }
+    selected_claim_ids = _dedupe_preserve_order(
+        str(value).strip() for value in referenced_claim_ids if str(value).strip()
+    )
+    if not selected_claim_ids:
+        raise CaseWorkspaceError(
+            "at least one model-declared referenced claim id is required"
+        )
+    unknown_claim_ids = sorted(set(selected_claim_ids) - set(claim_by_id))
+    if unknown_claim_ids:
+        raise CaseWorkspaceError(
+            "unknown referenced claim ids: " + ", ".join(unknown_claim_ids)
+        )
+    claim_ids, evidence_ids = _claim_and_evidence_closure(
+        claim_by_id,
+        evidence_by_id,
+        selected_claim_ids,
+    )
+
+    timestamp = _now_iso(now)
+    prior_bytes = target.read_bytes() if target.is_file() else None
+    prior_sha256 = sha256(prior_bytes).hexdigest() if prior_bytes is not None else None
+    new_bytes = workpaper_text.encode("utf-8")
+    new_sha256 = sha256(new_bytes).hexdigest()
+    history_path: Path | None = None
+    if prior_bytes is not None and prior_bytes != new_bytes:
+        history_dir = case_dir / "history"
+        compact = re.sub(r"[^0-9A-Za-z]", "", timestamp)
+        history_path = history_dir / (
+            f"advisory_workpaper.{compact}.{prior_sha256[:8]}.md"
+        )
+
+    snapshot_paths = [target, checkpoint_path]
+    if history_path is not None:
+        snapshot_paths.append(history_path)
+    snapshot = _snapshot_files(snapshot_paths)
+    completed = False
+    try:
+        if history_path is not None:
+            history_path.parent.mkdir(parents=True, exist_ok=True)
+            if history_path.exists() and history_path.read_bytes() != prior_bytes:
+                raise CaseWorkspaceError(
+                    f"refusing to overwrite different workpaper history: {history_path}"
+                )
+            atomic_bytes(history_path, prior_bytes or b"")
+        target.parent.mkdir(parents=True, exist_ok=True)
+        atomic_bytes(target, new_bytes)
+        checkpoint = {
+            "schema_version": "clara.advisory_workpaper_checkpoint.v1",
+            "committed_at": timestamp,
+            "change_summary": change_summary.strip(),
+            "workpaper": {
+                "path": ADVISORY_WORKPAPER_FILENAME,
+                "path_reference": "case_relative",
+                "sha256": new_sha256,
+                "byte_count": len(new_bytes),
+            },
+            "prior_workpaper": {
+                "sha256": prior_sha256,
+                "history_path": (
+                    history_path.relative_to(case_dir).as_posix()
+                    if history_path is not None
+                    else None
+                ),
+            },
+            "lineage": {
+                "evidence_register_sha256": _file_sha256(evidence_path),
+                "claim_register_sha256": _file_sha256(claim_path),
+                "claim_semantic_sha256": _semantic_claim_register_sha256(
+                    claim_register
+                ),
+                "referenced_claim_ids": claim_ids,
+                "referenced_evidence_ids": evidence_ids,
+            },
+            "boundary": (
+                "The active model authored the workpaper and selected the claim IDs. "
+                "This checkpoint proves file and declared-lineage consistency only."
+            ),
+        }
+        _write_json(checkpoint_path, checkpoint)
+        completed = True
+    finally:
+        if not completed:
+            _restore_files(snapshot)
+    return checkpoint
+
+
+@case_operation
+def set_judgement_status(
+    case_dir: Path,
+    entry_id: str,
+    *,
+    status: str,
+    reviewer: str,
+    review_note: str = "",
+    now: datetime | None = None,
+) -> dict[str, Any]:
+    """Mark one judgement entry included, excluded, or pending."""
+
+    updated_entries = set_judgement_statuses(
+        case_dir,
+        [entry_id],
+        status=status,
+        reviewer=reviewer,
+        review_note=review_note,
+        now=now,
+    )
+    return updated_entries[0]
+
+
+@case_operation
+def set_judgement_statuses(
+    case_dir: Path,
+    entry_ids: Sequence[str],
+    *,
+    status: str,
+    reviewer: str,
+    review_note: str = "",
+    now: datetime | None = None,
+) -> list[dict[str, Any]]:
+    """Mark multiple judgement entries included, excluded, or pending."""
+
+    _validate_choice(status, JUDGEMENT_STATUSES, "status")
+    if status != "pending" and not reviewer.strip():
+        raise CaseWorkspaceError(
+            "recorded-by advisor name is required for include/exclude status"
+        )
+    requested_ids = _dedupe_preserve_order(entry_ids)
+    if not requested_ids:
+        raise CaseWorkspaceError("at least one judgement entry id is required")
+
+    timestamp = _now_iso(now)
+    judgement_path = _case_path(case_dir, "judgement")
+    judgement = _read_json(judgement_path)
+    entries_by_id = {entry["id"]: entry for entry in judgement["entries"]}
+    missing_ids = [
+        entry_id for entry_id in requested_ids if entry_id not in entries_by_id
+    ]
+    if missing_ids:
+        raise CaseWorkspaceError(
+            "judgement entries not found: " + ", ".join(missing_ids)
+        )
+
+    updated_entries: list[dict[str, Any]] = []
+    selected_ids = set(requested_ids)
+    for entry in judgement["entries"]:
+        if entry["id"] in selected_ids:
+            if status == "approved":
+                _assert_judgement_claim_binding(
+                    case_dir,
+                    text=str(entry.get("text", "")),
+                    advisory_claim_id=str(entry.get("advisory_claim_id", "")).strip(),
+                    evidence_receipt_ids=entry.get("evidence_receipt_ids", []),
+                )
+            entry["status"] = status
+            entry["reviewed_at"] = None if status == "pending" else timestamp
+            entry["reviewer"] = reviewer.strip() or None
+            entry["review_note"] = review_note.strip()
+            updated_entries.append(entry)
+    _write_json(judgement_path, judgement)
+    _touch_manifest(case_dir, timestamp)
+    refresh_case_brief(case_dir, now=now)
+    return sorted(
+        updated_entries,
+        key=lambda entry: requested_ids.index(entry["id"]),
+    )
+
+
+@case_operation
+def add_open_question(
+    case_dir: Path,
+    *,
+    question: str,
+    why_it_matters: str,
+    source_entry_ids: Sequence[str] = (),
+    status: str = "open",
+    now: datetime | None = None,
+) -> dict[str, Any]:
+    """Store a targeted follow-up question for the advisor or client team."""
+
+    _validate_choice(status, OPEN_QUESTION_STATUSES, "status")
+    if not question.strip():
+        raise CaseWorkspaceError("question cannot be empty")
+    timestamp = _now_iso(now)
+    questions_path = _case_path(case_dir, "open_questions")
+    payload = _read_json(questions_path)
+    question_item = {
+        "id": _next_id("q", [item["id"] for item in payload["questions"]]),
+        "question": question.strip(),
+        "why_it_matters": why_it_matters.strip(),
+        "status": status,
+        "source_entry_ids": list(source_entry_ids),
+        "created_at": timestamp,
+        "updated_at": timestamp,
+    }
+    payload["questions"].append(question_item)
+    _write_json(questions_path, payload)
+    _touch_manifest(case_dir, timestamp)
+    refresh_case_brief(case_dir, now=now)
+    return question_item
+
+
+def _clean_id_list(raw_values: Any, *, field_name: str) -> list[str]:
+    if raw_values is None:
+        return []
+    if not isinstance(raw_values, list):
+        raise CaseWorkspaceError(f"{field_name} must be a list")
+    return _dedupe_preserve_order(str(value).strip() for value in raw_values)
+
+
+def _clean_issue_id(issue_id: str) -> str:
+    cleaned = issue_id.strip()
+    if not cleaned:
+        raise CaseWorkspaceError("issue id cannot be empty")
+    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_-]*", cleaned):
+        raise CaseWorkspaceError(
+            "issue id may contain only letters, numbers, hyphen, and underscore"
+        )
+    return cleaned
+
+
+@case_operation
+def upsert_case_issues(
+    case_dir: Path,
+    issues: Sequence[Mapping[str, Any]],
+    *,
+    now: datetime | None = None,
+) -> list[dict[str, Any]]:
+    """Create or update cross-interview case issues linked to evidence entries."""
+
+    timestamp = _now_iso(now)
+    known_judgement_ids = _known_judgement_ids(case_dir)
+    known_claim_ids = set(_claim_records_by_id(case_dir))
+    known_question_ids = _known_open_question_ids(case_dir)
+    issues_path = _case_path(case_dir, "issues")
+    payload = _read_json(issues_path)
+    existing_by_id = {str(item["id"]): item for item in payload["issues"]}
+    existing_ids = [str(item["id"]) for item in payload["issues"]]
+    updated: list[dict[str, Any]] = []
+
+    for raw_issue in issues:
+        title = str(raw_issue.get("title", "")).strip()
+        if not title and not raw_issue.get("id"):
+            raise CaseWorkspaceError("issue title is required for new issues")
+        issue_id = (
+            _clean_issue_id(str(raw_issue["id"]))
+            if raw_issue.get("id")
+            else _next_id("issue", [*existing_ids, *(item["id"] for item in updated)])
+        )
+        status = str(raw_issue.get("status", "active"))
+        _validate_choice(status, ISSUE_STATUSES, "status")
+
+        evidence_for = _clean_id_list(
+            raw_issue.get("evidence_for", []),
+            field_name="evidence_for",
+        )
+        evidence_against = _clean_id_list(
+            raw_issue.get("evidence_against", []),
+            field_name="evidence_against",
+        )
+        open_tests = _clean_id_list(
+            raw_issue.get("open_tests", []),
+            field_name="open_tests",
+        )
+        claim_ids_for = _clean_id_list(
+            raw_issue.get(
+                "claim_ids_for",
+                existing_by_id.get(issue_id, {}).get("claim_ids_for", []),
+            ),
+            field_name="claim_ids_for",
+        )
+        claim_ids_against = _clean_id_list(
+            raw_issue.get(
+                "claim_ids_against",
+                existing_by_id.get(issue_id, {}).get("claim_ids_against", []),
+            ),
+            field_name="claim_ids_against",
+        )
+        unknown_judgement_ids = sorted(
+            (set(evidence_for) | set(evidence_against)) - known_judgement_ids
+        )
+        if unknown_judgement_ids:
+            raise CaseWorkspaceError(
+                "unknown judgement entry ids: " + ", ".join(unknown_judgement_ids)
+            )
+        unknown_claim_ids = sorted(
+            (set(claim_ids_for) | set(claim_ids_against)) - known_claim_ids
+        )
+        if unknown_claim_ids:
+            raise CaseWorkspaceError(
+                "unknown advisory claim ids: " + ", ".join(unknown_claim_ids)
+            )
+        unknown_question_ids = sorted(set(open_tests) - known_question_ids)
+        if unknown_question_ids:
+            raise CaseWorkspaceError(
+                "unknown open question ids: " + ", ".join(unknown_question_ids)
+            )
+
+        existing = existing_by_id.get(issue_id)
+        issue = {
+            "id": issue_id,
+            "title": title or str(existing.get("title", "") if existing else ""),
+            "decision_area": str(
+                raw_issue.get(
+                    "decision_area",
+                    existing.get("decision_area", "") if existing else "",
+                )
+            ).strip(),
+            "current_synthesis": str(
+                raw_issue.get(
+                    "current_synthesis",
+                    existing.get("current_synthesis", "") if existing else "",
+                )
+            ).strip(),
+            "status": status,
+            "evidence_for": evidence_for,
+            "evidence_against": evidence_against,
+            "claim_ids_for": claim_ids_for,
+            "claim_ids_against": claim_ids_against,
+            "open_tests": open_tests,
+            "created_at": (
+                existing.get("created_at", timestamp) if existing else timestamp
+            ),
+            "updated_at": timestamp,
+        }
+        if existing is None:
+            payload["issues"].append(issue)
+        else:
+            existing.update(issue)
+            issue = existing
+        updated.append(issue)
+
+    _write_json(issues_path, payload)
+    _touch_manifest(case_dir, timestamp)
+    refresh_case_brief(case_dir, now=now)
+    return updated
+
+
+def _plugin_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def _load_clara_playbook() -> dict[str, Any]:
+    playbook_path = _plugin_root() / "playbook" / "clara_kickoff_playbook.json"
+    if playbook_path.exists():
+        payload = json.loads(playbook_path.read_text(encoding="utf-8"))
+        return payload if isinstance(payload, dict) else {}
+    return {}
+
+
+def _fallback_clara_playbook() -> dict[str, Any]:
+    return {
+        "succession_lenses": [
+            "Ownership transfer and economic rights",
+            "Control, vetoes, and real decision rights",
+            "Operating leadership and successor credibility",
+            "Founder role after transition",
+            "Family alignment and politically acceptable narrative",
+            "Governance mechanisms that make agreement operational",
+            "Tax, legal, and financial constraints",
+            "Industry-specific capabilities needed by the next leader",
+        ],
+        "red_flags": [
+            "A successor is named but authority is not actually transferred.",
+            "Family agreement is stated but not translated into governance mechanisms.",
+            "A tax or legal structure solves wealth transfer but not leadership continuity.",
+            "The founder's future role is emotionally or operationally ambiguous.",
+            "The case contains a private preference that is being disguised as analysis.",
+        ],
+        "baseline_sources": [
+            {
+                "title": "HBS Working Knowledge - Governing the Family-Run Business",
+                "url": "https://www.library.hbs.edu/working-knowledge/governing-the-family-run-business",
+                "takeaway": "Separate family, ownership, and business governance roles.",
+            },
+            {
+                "title": "HBS Working Knowledge - Developing Your Next CEO for the Family Business",
+                "url": "https://www.library.hbs.edu/working-knowledge/managing-the-family-business-developing-your-next-ceo",
+                "takeaway": "CEO succession in family companies requires both capability and family-system fit.",
+            },
+            {
+                "title": "IFC Family Business Governance Handbook",
+                "url": "https://www.ifc.org/en/insights-reports/2011/ifc-family-business-governance-handbook",
+                "takeaway": "Family-business governance needs explicit structures, roles, and policies.",
+            },
+        ],
+    }
+
+
+def _clara_playbook_value(key: str) -> list[Any]:
+    playbook = _load_clara_playbook() or _fallback_clara_playbook()
+    value = playbook.get(key)
+    fallback = _fallback_clara_playbook()[key]
+    return value if isinstance(value, list) else fallback
+
+
+def _clean_string_list(values: Any) -> list[str]:
+    if isinstance(values, str):
+        values = [values]
+    if not isinstance(values, Sequence):
+        return []
+    cleaned: list[str] = []
+    for value in values:
+        clean = " ".join(str(value).split())
+        if clean:
+            cleaned.append(clean)
+    return _dedupe_preserve_order(cleaned)
+
+
+def _clean_research_items(values: Sequence[Mapping[str, Any]]) -> list[dict[str, str]]:
+    cleaned: list[dict[str, str]] = []
+    for value in values:
+        if not isinstance(value, Mapping):
+            continue
+        title = str(value.get("title", "")).strip()
+        url = str(value.get("url", "")).strip()
+        takeaway = str(value.get("takeaway", "")).strip()
+        if title or url or takeaway:
+            cleaned.append({"title": title, "url": url, "takeaway": takeaway})
+    return cleaned
+
+
+def _material_anchors(materials: Sequence[Mapping[str, Any]]) -> list[dict[str, str]]:
+    anchors: list[dict[str, str]] = []
+    for material in materials:
+        anchors.append(
+            {
+                "id": str(material["id"]),
+                "title": str(material["title"]),
+                "material_type": str(material["material_type"]),
+                "summary": str(material.get("summary", "")).strip(),
+            }
+        )
+    return anchors
+
+
+def _render_clara_kickoff_preparation_markdown(
+    *,
+    manifest: Mapping[str, Any],
+    material_anchors: Sequence[Mapping[str, str]],
+    succession_lenses: Sequence[str],
+    red_flags: Sequence[str],
+    industry_context: Sequence[str],
+    external_research: Sequence[Mapping[str, str]],
+    generated_at: str,
+) -> str:
+    language = _ui_language(manifest)
+    if language == "es":
+        copy = {
+            "title": "Preparación del kickoff de Clara",
+            "intro": (
+                "Preparación interna para el kickoff con el socio. Clara ha leído "
+                "los resúmenes de los materiales del caso y el playbook controlado. "
+                "Toda investigación web debe registrarse mediante enlaces a las "
+                "fuentes y conclusiones, sin copiar el texto de las fuentes."
+            ),
+            "generated": "Generado",
+            "snapshot": "Resumen del caso",
+            "project": "Proyecto",
+            "objective": "Objetivo",
+            "audience": "Destinatario",
+            "output_language": "Idioma de salida",
+            "materials": "Materiales de referencia",
+            "no_materials": "Aún no hay materiales del caso indexados.",
+            "lenses": "Perspectivas para la sucesión",
+            "red_flags": "Señales de alerta que vigilar",
+            "industry": "Contexto sectorial",
+            "no_industry": (
+                "Aún no se ha registrado investigación sectorial específica. "
+                "Clara debe añadir implicaciones sectoriales concisas y respaldadas "
+                "por fuentes antes de basarse en afirmaciones sobre el sector."
+            ),
+            "research": "Notas de investigación externa",
+            "source": "Fuente",
+            "no_takeaway": "No se ha registrado ninguna conclusión.",
+            "no_research": "No se han registrado notas de investigación externa.",
+            "posture": "Enfoque para el kickoff",
+            "posture_items": (
+                "El socio informa a Clara; Clara no dirige un interrogatorio.",
+                "Clara formula únicamente las preguntas de aclaración imprescindibles "
+                "cuando falta un dato que impide comprender el caso.",
+                "Clara debe inferir de la explicación del socio si el caso es "
+                "analítico, político, orientado primero a la presentación o mixto, "
+                "sin preguntar directamente por esa clasificación.",
+                "Clara no debe presentar el contenido del playbook como una "
+                "conclusión. El playbook es una perspectiva para preparar y dar "
+                "seguimiento al trabajo.",
+            ),
+        }
+    else:
+        copy = {
+            "title": "Clara Kickoff Preparation",
+            "intro": (
+                "Internal preparation for the partner kickoff. Clara has read the "
+                "case material summaries and the controlled playbook. Any web "
+                "research should be recorded as source links and takeaways, not "
+                "copied source text."
+            ),
+            "generated": "Generated",
+            "snapshot": "Case Snapshot",
+            "project": "Project",
+            "objective": "Objective",
+            "audience": "Audience",
+            "output_language": "Output language",
+            "materials": "Material Anchors",
+            "no_materials": "No case materials indexed yet.",
+            "lenses": "Succession Lenses",
+            "red_flags": "Red Flags To Watch",
+            "industry": "Industry Context",
+            "no_industry": (
+                "No industry-specific research has been recorded yet. Clara should "
+                "add concise, source-backed industry implications before relying on "
+                "industry claims."
+            ),
+            "research": "External Research Notes",
+            "source": "Source",
+            "no_takeaway": "No takeaway recorded.",
+            "no_research": "No external research notes recorded.",
+            "posture": "Kickoff Posture",
+            "posture_items": (
+                "The partner briefs Clara; Clara does not run an interrogation.",
+                "Clara asks only essential clarification questions when a missing "
+                "point blocks understanding.",
+                "Clara should infer whether the case is analytical, political, "
+                "presentation-first, or mixed from the partner's explanation rather "
+                "than asking that classification directly.",
+                "Clara should not present playbook material as a conclusion. The "
+                "playbook is a lens for preparation and follow-up.",
+            ),
+        }
+    localized_lenses = _localized_default_items(succession_lenses, language)
+    localized_red_flags = _localized_default_items(red_flags, language)
+    localized_research = _localized_default_research_items(
+        external_research,
+        language,
+    )
+    lines = [
+        f"# {copy['title']} - {manifest['client']}",
+        "",
+        copy["intro"],
+        "",
+        f"{copy['generated']}: {generated_at}",
+        "",
+        f"## {copy['snapshot']}",
+        "",
+        f"- {copy['project']}: {manifest['project']}",
+        f"- {copy['objective']}: {manifest['objective']}",
+        f"- {copy['audience']}: {manifest['audience']}",
+        f"- {copy['output_language']}: {manifest['output_language']}",
+        "",
+        f"## {copy['materials']}",
+        "",
+    ]
+    if material_anchors:
+        lines.extend(
+            f"- `{item['id']}` {item['title']} [{item['material_type']}]: {item['summary']}"
+            for item in material_anchors
+        )
+    else:
+        lines.append(f"- {copy['no_materials']}")
+    lines.extend(["", f"## {copy['lenses']}", ""])
+    lines.extend(f"- {item}" for item in localized_lenses)
+    lines.extend(["", f"## {copy['red_flags']}", ""])
+    lines.extend(f"- {item}" for item in localized_red_flags)
+    lines.extend(["", f"## {copy['industry']}", ""])
+    if industry_context:
+        lines.extend(f"- {item}" for item in industry_context)
+    else:
+        lines.append(f"- {copy['no_industry']}")
+    lines.extend(["", f"## {copy['research']}", ""])
+    if localized_research:
+        for item in localized_research:
+            label = item.get("title") or item.get("url") or copy["source"]
+            takeaway = item.get("takeaway") or copy["no_takeaway"]
+            url = item.get("url", "")
+            source = f" ({url})" if url else ""
+            lines.append(f"- {label}{source}: {takeaway}")
+    else:
+        lines.append(f"- {copy['no_research']}")
+    lines.extend(
+        [
+            "",
+            f"## {copy['posture']}",
+            "",
+            *(f"- {item}" for item in copy["posture_items"]),
+            "",
+        ]
+    )
+    return "\n".join(lines)
+
+
+@case_operation
+def prepare_clara_kickoff(
+    case_dir: Path,
+    *,
+    industry_context: Sequence[str] = (),
+    external_research: Sequence[Mapping[str, Any]] = (),
+    now: datetime | None = None,
+) -> ClaraKickoffPreparationResult:
+    """Prepare Clara's first partner kickoff from case state and playbook.
+
+    This is deterministic preparation. Codex may browse public or authorized
+    sources before calling it, but the helper itself only records supplied
+    source takeaways and controlled playbook lenses.
+    """
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+
+    timestamp = _now_iso(now)
+    manifest = _read_json(_case_path(case_dir, "manifest"))
+    materials = _read_json(_case_path(case_dir, "materials"))["materials"]
+    mandate_path = _case_path(case_dir, "clara_mandate")
+    mandate = _read_json(mandate_path)
+    succession_lenses = _clean_string_list(_clara_playbook_value("succession_lenses"))
+    red_flags = _clean_string_list(_clara_playbook_value("red_flags"))
+    research_items = _clean_research_items(
+        external_research or _clara_playbook_value("baseline_sources")
+    )
+    material_items = _material_anchors(materials)
+    industry_items = _clean_string_list(industry_context)
+    language = _ui_language(manifest)
+    preparation = {
+        "case_snapshot": {
+            "client": manifest["client"],
+            "project": manifest["project"],
+            "objective": manifest["objective"],
+            "audience": manifest["audience"],
+            "output_language": manifest["output_language"],
+        },
+        "material_anchors": material_items,
+        "succession_lenses": succession_lenses,
+        "red_flags": red_flags,
+        "industry_context": industry_items,
+        "external_research": research_items,
+        "preparation_note": (
+            "Clara está preparada para el briefing del socio. El socio debe explicar "
+            "el caso con naturalidad; Clara debe escuchar y formular únicamente las "
+            "preguntas de aclaración imprescindibles."
+            if language == "es"
+            else (
+                "Clara is prepared for a partner briefing. The partner should "
+                "explain the case naturally; Clara should listen and ask only "
+                "essential clarifications."
+            )
+        ),
+    }
+    mandate["status"] = "prepared"
+    mandate["prepared_at"] = timestamp
+    mandate["updated_at"] = timestamp
+    mandate["preparation"] = preparation
+    mandate["source_material_ids"] = [item["id"] for item in materials]
+    _write_json(mandate_path, mandate)
+    _touch_manifest(case_dir, timestamp)
+
+    preparation_path = case_dir / CLARA_KICKOFF_PREPARATION_FILENAME
+    atomic_text(
+        preparation_path,
+        _render_clara_kickoff_preparation_markdown(
+            manifest=manifest,
+            material_anchors=material_items,
+            succession_lenses=succession_lenses,
+            red_flags=red_flags,
+            industry_context=industry_items,
+            external_research=research_items,
+            generated_at=timestamp,
+        ),
+        encoding="utf-8",
+    )
+    refresh_case_brief(case_dir, now=now)
+    return ClaraKickoffPreparationResult(
+        mandate_path=mandate_path,
+        preparation_path=preparation_path,
+        material_count=len(materials),
+        baseline_source_count=len(research_items),
+    )
+
+
+def _merge_clean_strings(existing: Sequence[str], incoming: Any) -> list[str]:
+    return _dedupe_preserve_order([*existing, *_clean_string_list(incoming)])
+
+
+@case_operation
+def update_clara_mandate_from_kickoff(
+    case_dir: Path,
+    kickoff_payload: Mapping[str, Any],
+    *,
+    material_id: str = "",
+    session_path: str = "",
+    now: datetime | None = None,
+) -> dict[str, Any]:
+    """Update Clara's mandate after a partner kickoff briefing."""
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+    timestamp = _now_iso(now)
+    mandate_path = _case_path(case_dir, "clara_mandate")
+    mandate = _read_json(mandate_path)
+    extracted = kickoff_payload.get("clara_mandate", kickoff_payload)
+    if not isinstance(extracted, Mapping):
+        extracted = {}
+    body = mandate["mandate"]
+
+    for field in (
+        "engagement_objective",
+        "client_decision",
+        "clara_understanding",
+        "partner_starting_orientation",
+    ):
+        value = str(extracted.get(field, "")).strip()
+        if value:
+            body[field] = value
+    for field in (
+        "sensitive_points",
+        "what_clara_should_investigate",
+        "what_clara_should_not_waste_time_on",
+        "essential_clarifications",
+        "next_steps",
+    ):
+        body[field] = _merge_clean_strings(
+            body.get(field, []), extracted.get(field, [])
+        )
+
+    mandate["status"] = "kickoff_imported"
+    mandate["kickoff_imported_at"] = timestamp
+    mandate["updated_at"] = timestamp
+    if material_id:
+        mandate["source_material_ids"] = _dedupe_preserve_order(
+            [*mandate.get("source_material_ids", []), material_id]
+        )
+    if session_path:
+        mandate["voice_session_paths"] = _dedupe_preserve_order(
+            [*mandate.get("voice_session_paths", []), session_path]
+        )
+    mandate["mandate"] = body
+    _write_json(mandate_path, mandate)
+    _touch_manifest(case_dir, timestamp)
+    refresh_case_brief(case_dir, now=now)
+    return mandate
+
+
+def _html_escape(value: Any) -> str:
+    return html.escape(str(value), quote=True)
+
+
+def _ui_language(manifest: Mapping[str, Any]) -> str:
+    language = str(manifest.get("output_language", "en")).strip().lower()
+    return language if language in SUPPORTED_LANGUAGES else "en"
+
+
+def _html_copy(language: str) -> dict[str, str]:
+    if language == "it":
+        return {
+            "already_requested_next_steps": "Prossimi passi gia' richiesti",
+            "approved_entries": "Voci gia' approvate per il pack cliente",
+            "approved_metric": "voci approvate per il pack cliente",
+            "brief_eyebrow": "Briefing partner",
+            "brief_lead": (
+                "Scheda interna per distinguere contenuti pronti, ipotesi "
+                "candidate e prossime verifiche."
+            ),
+            "candidate_count": "voci candidate",
+            "candidate_empty": "Nessun giudizio candidato registrato.",
+            "candidate_judgement": "Giudizio candidato",
+            "case_state": "Stato del caso",
+            "clarification_empty": "Nessun chiarimento essenziale registrato.",
+            "client_decision": "Decisione cliente",
+            "control_note": "Nota di controllo",
+            "control_note_body": (
+                "Materiale di lavoro locale. Il giudizio professionale resta al "
+                "partner senior."
+            ),
+            "deck_eyebrow": "Kickoff",
+            "deck_note": "Materiale di lavoro interno.",
+            "direction": "Direzione",
+            "direction_item_include": "Quali voci candidate includere, escludere o correggere.",
+            "direction_item_output": "Quale output il partner vuole come prossimo passo.",
+            "engagement_objective": "Obiettivo dell'incarico",
+            "essential_clarifications": "Chiarimenti essenziali",
+            "evidence_gaps": "Punti da chiarire",
+            "executive_storyline": "Traccia esecutiva",
+            "facts_empty": "Nessun fatto acquisito registrato.",
+            "facts_title": "Fatti acquisiti",
+            "hypotheses_empty": "Nessuna ipotesi candidata registrata.",
+            "hypotheses_heading": "Ipotesi candidate da confermare o correggere.",
+            "hypotheses_eyebrow": "Ipotesi da verificare",
+            "initial_readout": "Sintesi iniziale",
+            "initial_readout_heading": "Fatti e orientamento emersi.",
+            "investigation": "Indagine",
+            "investigation_empty": "Nessun punto di indagine registrato.",
+            "investigation_prompt": "Quali evidenze recuperare per prime.",
+            "investigation_title": "Verifiche necessarie",
+            "industry_context": "Contesto settoriale",
+            "industry_context_empty": "Nessun contesto settoriale registrato.",
+            "judgement": "Giudizio",
+            "judgement_item_client": "Cosa puo' essere usato con il cliente.",
+            "judgement_item_right": "Cosa e' gia' corretto.",
+            "judgement_item_sensitive": "Cosa e' politicamente sensibile.",
+            "known_facts": "Fatti acquisiti",
+            "lenses_empty": "Nessuna lente di preparazione registrata.",
+            "mandate": "Mandato",
+            "materials_metric": "materiali indicizzati",
+            "next_conversation": "Prossima conversazione",
+            "next_conversation_heading": "Decisioni per il prossimo passaggio.",
+            "next_step_empty": "Nessun prossimo passo registrato.",
+            "next_steps": "Prossimi passi",
+            "open_questions_metric": "domande aperte",
+            "partner_orientation": "Orientamento del partner",
+            "partner_orientation_empty": (
+                "Orientamento del partner non ancora registrato."
+            ),
+            "partner_orientation_waiting": (
+                "Orientamento del partner non ancora registrato; partire dalle "
+                "voci candidate."
+            ),
+            "pending_metric": "voci di giudizio pending",
+            "pending_note": (
+                "Voci approvate per il pack cliente: {approved_count}. "
+                "Il giudizio pending resta materiale di lavoro."
+            ),
+            "preparation_lenses": "Controlli di preparazione",
+            "preparation_lenses_heading": "Punti da testare nella prima conversazione.",
+            "priority_checks": "Verifiche prioritarie",
+            "questions_empty": "Nessuna domanda aperta registrata.",
+            "questions_heading": (
+                "Domande da risolvere prima che qualcosa diventi materiale cliente."
+            ),
+            "red_flags": "Punti di attenzione",
+            "red_flags_empty": "Nessun punto di attenzione registrato.",
+            "research_empty": "Nessuna ricerca esterna registrata.",
+            "research_notes": "Note di ricerca esterna",
+            "ready_judgement": "Contenuto pronto per il pack cliente",
+            "ready_judgement_empty": "Nessun contenuto approvato registrato.",
+            "sensitive_empty": "Nessun punto sensibile registrato.",
+            "sensitive_points": "Punti sensibili",
+            "sensitive_default_gate": (
+                "Il giudizio candidato non diventa materiale cliente finche' "
+                "il partner non lo approva."
+            ),
+            "sensitive_default_paths": (
+                "L'output cliente non deve esporre percorsi locali o meccaniche interne."
+            ),
+            "what_clara_needs": "Decisioni per il prossimo passaggio.",
+        }
+    if language == "es":
+        return {
+            "already_requested_next_steps": "Próximos pasos ya solicitados",
+            "approved_entries": "Elementos aprobados para el paquete del cliente",
+            "approved_metric": "elementos listos para el paquete del cliente",
+            "brief_eyebrow": "Briefing del socio",
+            "brief_lead": (
+                "Documento interno para separar contenido listo, hipótesis "
+                "candidatas y próximas comprobaciones."
+            ),
+            "candidate_count": "elementos candidatos",
+            "candidate_empty": "Aún no se ha registrado ningún juicio candidato.",
+            "candidate_judgement": "Juicio candidato",
+            "case_state": "Estado del caso",
+            "clarification_empty": "Aún no se han registrado aclaraciones esenciales.",
+            "client_decision": "Decisión del cliente",
+            "control_note": "Nota de control",
+            "control_note_body": (
+                "Material de trabajo local. El juicio profesional corresponde al "
+                "socio sénior."
+            ),
+            "deck_eyebrow": "Kickoff",
+            "deck_note": "Material de trabajo interno.",
+            "direction": "Dirección",
+            "direction_item_include": (
+                "Qué elementos candidatos incluir, excluir o corregir."
+            ),
+            "direction_item_output": "Qué entregable quiere el socio a continuación.",
+            "engagement_objective": "Objetivo del encargo",
+            "essential_clarifications": "Aclaraciones esenciales",
+            "evidence_gaps": "Lagunas de evidencia",
+            "executive_storyline": "Línea argumental ejecutiva",
+            "facts_empty": "Aún no se han registrado hechos.",
+            "facts_title": "Hechos conocidos",
+            "hypotheses_empty": "Aún no se han registrado hipótesis candidatas.",
+            "hypotheses_heading": "Hipótesis candidatas que confirmar o corregir.",
+            "hypotheses_eyebrow": "Hipótesis que comprobar",
+            "initial_readout": "Síntesis inicial",
+            "initial_readout_heading": "Hechos y orientación recogidos hasta ahora.",
+            "investigation": "Investigación",
+            "investigation_empty": "Aún no se han registrado puntos de investigación.",
+            "investigation_prompt": "Qué evidencia obtener primero.",
+            "investigation_title": "Comprobaciones necesarias",
+            "industry_context": "Contexto sectorial",
+            "industry_context_empty": "Aún no se ha registrado contexto sectorial.",
+            "judgement": "Juicio",
+            "judgement_item_client": "Qué puede utilizarse con el cliente.",
+            "judgement_item_right": "Qué ya es correcto.",
+            "judgement_item_sensitive": "Qué es políticamente sensible.",
+            "known_facts": "Hechos conocidos",
+            "lenses_empty": "No se han registrado perspectivas de preparación.",
+            "mandate": "Mandato",
+            "materials_metric": "materiales indexados",
+            "next_conversation": "Próxima conversación",
+            "next_conversation_heading": "Decisiones para el siguiente paso.",
+            "next_step_empty": "Aún no se han registrado próximos pasos.",
+            "next_steps": "Próximos pasos",
+            "open_questions_metric": "preguntas abiertas",
+            "partner_orientation": "Orientación del socio",
+            "partner_orientation_empty": "Aún no se ha registrado la orientación del socio.",
+            "partner_orientation_waiting": (
+                "Aún no se ha registrado la orientación del socio; empezar por "
+                "los elementos candidatos."
+            ),
+            "pending_metric": "elementos de juicio pendientes",
+            "pending_note": (
+                "Elementos aprobados para el paquete del cliente: {approved_count}. "
+                "El juicio pendiente es solo material de trabajo."
+            ),
+            "preparation_lenses": "Comprobaciones de preparación",
+            "preparation_lenses_heading": (
+                "Puntos que comprobar en la primera conversación con el socio."
+            ),
+            "priority_checks": "Comprobaciones prioritarias",
+            "questions_empty": "Aún no se han registrado preguntas abiertas.",
+            "questions_heading": (
+                "Preguntas que Clara debe resolver antes de que el contenido esté "
+                "listo para el cliente."
+            ),
+            "red_flags": "Señales de alerta",
+            "red_flags_empty": "No se han registrado señales de alerta.",
+            "research_empty": "No se ha registrado investigación externa.",
+            "research_notes": "Notas de investigación externa",
+            "ready_judgement": "Contenido listo para el paquete del cliente",
+            "ready_judgement_empty": "No se ha registrado contenido aprobado.",
+            "sensitive_empty": "No se han registrado puntos sensibles.",
+            "sensitive_points": "Puntos sensibles",
+            "sensitive_default_gate": (
+                "El juicio candidato no está listo para el cliente hasta que el "
+                "socio lo marque como tal."
+            ),
+            "sensitive_default_paths": (
+                "El entregable para el cliente no debe mostrar rutas de archivos "
+                "locales ni mecanismos internos de trabajo."
+            ),
+            "what_clara_needs": "Decisiones para el siguiente paso.",
+        }
+    return {
+        "already_requested_next_steps": "Already requested next steps",
+        "approved_entries": "Approved client-pack entries",
+        "approved_metric": "client-pack ready items",
+        "brief_eyebrow": "Partner Brief",
+        "brief_lead": (
+            "Internal brief to separate ready content, candidate hypotheses, "
+            "and the next checks."
+        ),
+        "candidate_count": "candidate items",
+        "candidate_empty": "No candidate judgement captured yet.",
+        "candidate_judgement": "Candidate Judgement",
+        "case_state": "Case State",
+        "clarification_empty": "No essential clarifications recorded yet.",
+        "client_decision": "Client decision",
+        "control_note": "Control Note",
+        "control_note_body": (
+            "Local working material. Professional judgement remains with the "
+            "senior partner."
+        ),
+        "deck_eyebrow": "Kickoff",
+        "deck_note": "Internal working material.",
+        "direction": "Direction",
+        "direction_item_include": "Which candidate items to include, exclude, or correct.",
+        "direction_item_output": "What output the partner wants next.",
+        "engagement_objective": "Engagement objective",
+        "essential_clarifications": "Essential Clarifications",
+        "evidence_gaps": "Evidence gaps",
+        "executive_storyline": "Executive Storyline",
+        "facts_empty": "No facts captured yet.",
+        "facts_title": "Known facts",
+        "hypotheses_empty": "No candidate hypotheses captured yet.",
+        "hypotheses_heading": "Candidate hypotheses to confirm or correct.",
+        "hypotheses_eyebrow": "Hypotheses to test",
+        "initial_readout": "Initial synthesis",
+        "initial_readout_heading": "Facts and orientation captured so far.",
+        "investigation": "Investigation",
+        "investigation_empty": "No investigation items recorded yet.",
+        "investigation_prompt": "Which evidence to get first.",
+        "investigation_title": "Required checks",
+        "industry_context": "Industry Context",
+        "industry_context_empty": "No industry context recorded yet.",
+        "judgement": "Judgement",
+        "judgement_item_client": "What can be used with the client.",
+        "judgement_item_right": "What is already right.",
+        "judgement_item_sensitive": "What is politically sensitive.",
+        "known_facts": "Known facts",
+        "lenses_empty": "No succession lenses recorded.",
+        "mandate": "Mandate",
+        "materials_metric": "materials indexed",
+        "next_conversation": "Next conversation",
+        "next_conversation_heading": "Decisions for the next step.",
+        "next_step_empty": "No next steps recorded yet.",
+        "next_steps": "Next Steps",
+        "open_questions_metric": "open questions",
+        "partner_orientation": "Partner orientation",
+        "partner_orientation_empty": ("Partner orientation not recorded yet."),
+        "partner_orientation_waiting": (
+            "Partner orientation not recorded yet; start from the candidate items."
+        ),
+        "pending_metric": "pending judgement entries",
+        "pending_note": (
+            "Approved client-pack entries: {approved_count}. "
+            "Pending judgement is working material only."
+        ),
+        "preparation_lenses": "Preparation Checks",
+        "preparation_lenses_heading": "Points to test in the first partner conversation.",
+        "priority_checks": "Priority Checks",
+        "questions_empty": "No open questions registered yet.",
+        "questions_heading": (
+            "Questions Clara should resolve before anything becomes client-ready."
+        ),
+        "red_flags": "Red flags",
+        "red_flags_empty": "No red flags recorded.",
+        "research_empty": "No external research recorded.",
+        "research_notes": "External Research Notes",
+        "ready_judgement": "Client-Pack Ready Content",
+        "ready_judgement_empty": "No approved content recorded yet.",
+        "sensitive_empty": "No sensitive points recorded yet.",
+        "sensitive_points": "Sensitive Points",
+        "sensitive_default_gate": (
+            "Candidate judgement is not client-ready until the partner marks it ready."
+        ),
+        "sensitive_default_paths": (
+            "Client-facing output should not expose local file paths or internal "
+            "workpaper mechanics."
+        ),
+        "what_clara_needs": "Decisions for the next step.",
+    }
+
+
+def _same_text_sequence(left: Sequence[str], right: Sequence[str]) -> bool:
+    return _clean_string_list(left) == _clean_string_list(right)
+
+
+ITALIAN_DEFAULT_TEXT = {
+    "Ownership transfer and economic rights": "Trasferimento proprieta' e diritti economici",
+    "Control, vetoes, and real decision rights": "Controllo, veto e poteri decisionali reali",
+    "Operating leadership and successor credibility": (
+        "Leadership operativa e credibilita' del successore"
+    ),
+    "Founder role after transition": "Ruolo del fondatore dopo la transizione",
+    "Family alignment and politically acceptable narrative": (
+        "Allineamento familiare e narrativa politicamente accettabile"
+    ),
+    "Governance mechanisms that make agreement operational": (
+        "Meccanismi di governance che rendono operativo l'accordo"
+    ),
+    "Tax, legal, and financial constraints": "Vincoli fiscali, legali e finanziari",
+    "Industry-specific capabilities needed by the next leader": (
+        "Capacita' settoriali richieste al prossimo leader"
+    ),
+    "A successor is named but authority is not actually transferred.": (
+        "Viene nominato un successore, ma l'autorita' non viene realmente trasferita."
+    ),
+    "Family agreement is stated but not translated into governance mechanisms.": (
+        "L'accordo familiare e' dichiarato, ma non tradotto in meccanismi di governance."
+    ),
+    "A tax or legal structure solves wealth transfer but not leadership continuity.": (
+        "Una struttura fiscale o legale risolve il trasferimento patrimoniale, "
+        "ma non la continuita' della leadership."
+    ),
+    "The founder's future role is emotionally or operationally ambiguous.": (
+        "Il ruolo futuro del fondatore resta ambiguo sul piano emotivo o operativo."
+    ),
+    "The case contains a private preference that is being disguised as analysis.": (
+        "Il caso contiene una preferenza privata mascherata da analisi."
+    ),
+    "Customer, supplier, or employee trust is personal to the founder and not institutionalized.": (
+        "La fiducia di clienti, fornitori o persone chiave e' personale al fondatore "
+        "e non istituzionalizzata."
+    ),
+    "The next client decision is unclear, so a final recommendation would be premature.": (
+        "La prossima decisione del cliente non e' chiara, quindi una raccomandazione "
+        "finale sarebbe prematura."
+    ),
+    "Separate family, ownership, and business governance roles.": (
+        "Separare ruoli di famiglia, proprieta' e governo dell'impresa."
+    ),
+    "CEO succession in family companies requires both capability and family-system fit.": (
+        "La successione dell'AD nelle aziende familiari richiede capacita' e coerenza "
+        "con il sistema familiare."
+    ),
+    "Family-business negotiation must protect both the economic decision and the family relationship.": (
+        "La negoziazione familiare deve proteggere sia la decisione economica sia "
+        "la relazione familiare."
+    ),
+    "Family-business governance needs explicit structures, roles, and policies.": (
+        "La governance dell'azienda familiare richiede strutture, ruoli e policy espliciti."
+    ),
+}
+
+SPANISH_DEFAULT_TEXT = {
+    "Ownership transfer and economic rights": (
+        "Transferencia de la propiedad y derechos económicos"
+    ),
+    "Control, vetoes, and real decision rights": (
+        "Control, vetos y derechos de decisión reales"
+    ),
+    "Operating leadership and successor credibility": (
+        "Liderazgo operativo y credibilidad del sucesor"
+    ),
+    "Founder role after transition": "Papel del fundador tras la transición",
+    "Family alignment and politically acceptable narrative": (
+        "Alineación familiar y narrativa políticamente aceptable"
+    ),
+    "Governance mechanisms that make agreement operational": (
+        "Mecanismos de gobernanza que hacen operativo el acuerdo"
+    ),
+    "Tax, legal, and financial constraints": (
+        "Restricciones fiscales, jurídicas y financieras"
+    ),
+    "Industry-specific capabilities needed by the next leader": (
+        "Capacidades sectoriales que necesita el próximo líder"
+    ),
+    "A successor is named but authority is not actually transferred.": (
+        "Se nombra a un sucesor, pero la autoridad no se transfiere realmente."
+    ),
+    "Family agreement is stated but not translated into governance mechanisms.": (
+        "Se declara un acuerdo familiar, pero no se traduce en mecanismos de gobernanza."
+    ),
+    "A tax or legal structure solves wealth transfer but not leadership continuity.": (
+        "Una estructura fiscal o jurídica resuelve la transferencia patrimonial, "
+        "pero no la continuidad del liderazgo."
+    ),
+    "The founder's future role is emotionally or operationally ambiguous.": (
+        "El futuro papel del fundador es ambiguo en términos emocionales u operativos."
+    ),
+    "The case contains a private preference that is being disguised as analysis.": (
+        "El caso contiene una preferencia privada disfrazada de análisis."
+    ),
+    "Customer, supplier, or employee trust is personal to the founder and not institutionalized.": (
+        "La confianza de clientes, proveedores o empleados depende personalmente "
+        "del fundador y no está institucionalizada."
+    ),
+    "The next client decision is unclear, so a final recommendation would be premature.": (
+        "La próxima decisión del cliente no está clara, por lo que una "
+        "recomendación final sería prematura."
+    ),
+    "Separate family, ownership, and business governance roles.": (
+        "Separar las funciones de familia, propiedad y gobierno empresarial."
+    ),
+    "CEO succession in family companies requires both capability and family-system fit.": (
+        "La sucesión del consejero delegado en empresas familiares exige tanto "
+        "capacidad como encaje en el sistema familiar."
+    ),
+    "Family-business negotiation must protect both the economic decision and the family relationship.": (
+        "La negociación en la empresa familiar debe proteger tanto la decisión "
+        "económica como la relación familiar."
+    ),
+    "Family-business governance needs explicit structures, roles, and policies.": (
+        "La gobernanza de la empresa familiar necesita estructuras, funciones y "
+        "políticas explícitas."
+    ),
+}
+
+
+def _localized_default_text(value: str, language: str) -> str:
+    if language == "it":
+        return ITALIAN_DEFAULT_TEXT.get(value, value)
+    if language == "es":
+        return SPANISH_DEFAULT_TEXT.get(value, value)
+    return value
+
+
+def _localized_default_items(items: Any, language: str) -> list[str]:
+    return [
+        _localized_default_text(item, language) for item in _clean_string_list(items)
+    ]
+
+
+def _localized_default_research_items(
+    items: Sequence[Mapping[str, Any]], language: str
+) -> list[dict[str, str]]:
+    localized: list[dict[str, str]] = []
+    for item in _clean_research_items(items):
+        localized.append(
+            {
+                "title": item["title"],
+                "url": item["url"],
+                "takeaway": _localized_default_text(item["takeaway"], language),
+            }
+        )
+    return localized
+
+
+def _default_partner_next_steps(language: str) -> list[str]:
+    if language == "it":
+        return [
+            "Aprire il kickoff deck e reagire alle ipotesi iniziali.",
+            "Decidere quali voci candidate includere, escludere, correggere o espandere.",
+            "Registrare orientamento del partner e priorita' del primo output.",
+        ]
+    if language == "es":
+        return [
+            "Abrir el deck de kickoff y reaccionar a las hipótesis iniciales.",
+            "Decidir qué elementos candidatos incluir, excluir, corregir o ampliar.",
+            "Registrar la orientación del socio y la prioridad del primer entregable.",
+        ]
+    return [
+        "Open the kickoff deck and react to the initial hypotheses.",
+        "Decide which candidate items to include, exclude, correct, or expand.",
+        "Record the partner's orientation and first output priority.",
+    ]
+
+
+def _html_list(items: Sequence[str], *, empty: str) -> str:
+    cleaned = _clean_string_list(items)
+    if not cleaned:
+        return f'<p class="empty">{_html_escape(empty)}</p>'
+    return (
+        "<ul>" + "".join(f"<li>{_html_escape(item)}</li>" for item in cleaned) + "</ul>"
+    )
+
+
+def _html_research_list(
+    items: Sequence[Mapping[str, Any]], *, empty: str = "No external research recorded."
+) -> str:
+    cleaned = _clean_research_items(items)
+    if not cleaned:
+        return f'<p class="empty">{_html_escape(empty)}</p>'
+    rows: list[str] = []
+    for item in cleaned:
+        title = _html_escape(item.get("title") or "Source")
+        takeaway = _html_escape(item.get("takeaway") or "No takeaway recorded.")
+        url = str(item.get("url", "")).strip()
+        source = f'<a href="{_html_escape(url)}">{_html_escape(url)}</a>' if url else ""
+        rows.append(
+            "<li>"
+            f"<strong>{title}</strong>"
+            f"<span>{takeaway}</span>"
+            f"{source}"
+            "</li>"
+        )
+    return '<ul class="research-list">' + "".join(rows) + "</ul>"
+
+
+def _html_compact_list(items: Sequence[str], *, limit: int, empty: str) -> str:
+    return _html_list(list(items)[:limit], empty=empty)
+
+
+def _entry_texts_by_status(
+    entries: Sequence[Mapping[str, Any]],
+    *,
+    statuses: set[str],
+    kinds: set[str] | None = None,
+) -> list[str]:
+    selected: list[str] = []
+    for entry in entries:
+        if entry.get("status") not in statuses:
+            continue
+        if kinds is not None and entry.get("kind") not in kinds:
+            continue
+        selected.append(str(entry.get("text", "")).strip())
+    return [item for item in selected if item]
+
+
+def _open_question_texts(questions: Sequence[Mapping[str, Any]]) -> list[str]:
+    return [
+        f"{item['question']} ({item['why_it_matters']})"
+        for item in questions
+        if item.get("status") == "open"
+    ]
+
+
+def _strip_local_paths(value: str) -> str:
+    return re.sub(r"/Users/[^\s,)`]+", "[percorso locale]", value)
+
+
+def _partner_approved_content(entries: Sequence[Mapping[str, Any]]) -> list[str]:
+    return _entry_texts_by_status(
+        entries,
+        statuses={"approved"},
+        kinds={"fact", "advisor_judgement", "codex_inference", "decision_implication"},
+    )
+
+
+def _indexed_industry_context_items(
+    materials: Sequence[Mapping[str, Any]],
+) -> list[str]:
+    keywords = (
+        "industry",
+        "market",
+        "mercato",
+        "settore",
+        "research",
+        "ricerca",
+        "premium",
+        "successione",
+        "family business",
+    )
+    items: list[str] = []
+    for material in materials:
+        haystack = " ".join(
+            [
+                str(material.get("title", "")),
+                str(material.get("path", "")),
+                str(material.get("material_type", "")),
+            ]
+        ).lower()
+        if not any(keyword in haystack for keyword in keywords):
+            continue
+        summary = str(material.get("summary", "")).strip()
+        if not summary or summary in {
+            "No readable preview text.",
+            "PDF indexed; semantic review remains in Codex.",
+        }:
+            continue
+        title = str(material.get("title", "Source")).strip() or "Source"
+        clean_summary = _strip_local_paths(_mechanical_text_summary(summary, limit=300))
+        items.append(f"{title}: {clean_summary}")
+    return _dedupe_preserve_order(items)[:5]
+
+
+@case_operation
+def render_clara_kickoff_deck(
+    case_dir: Path,
+    *,
+    output_path: Path | None = None,
+) -> ClaraKickoffDeckResult:
+    """Render Clara's first quiet partner kickoff deck from case state."""
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+    manifest = _read_json(_case_path(case_dir, "manifest"))
+    language = _ui_language(manifest)
+    copy = _html_copy(language)
+    materials = _read_json(_case_path(case_dir, "materials"))["materials"]
+    entries = _read_json(_case_path(case_dir, "judgement"))["entries"]
+    questions = _read_json(_case_path(case_dir, "open_questions"))["questions"]
+    mandate = _read_json(_case_path(case_dir, "clara_mandate"))
+    preparation = mandate.get("preparation", {})
+    body = mandate.get("mandate", {})
+    target_path = output_path or case_dir / CLARA_KICKOFF_DECK_FILENAME
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+
+    facts = _entry_texts_by_status(
+        entries, statuses={"approved", "pending"}, kinds={"fact"}
+    )
+    hypotheses = _entry_texts_by_status(
+        entries,
+        statuses={"approved", "pending"},
+        kinds={"advisor_judgement", "codex_inference", "decision_implication"},
+    )
+    approved_count = sum(1 for entry in entries if entry["status"] == "approved")
+    pending_count = sum(1 for entry in entries if entry["status"] == "pending")
+    open_question_items = _open_question_texts(questions)
+    material_count = len(materials)
+    client_decision = (
+        str(body.get("client_decision", "")).strip()
+        or str(manifest.get("objective", "")).strip()
+    )
+    partner_orientation = str(body.get("partner_starting_orientation", "")).strip()
+    if not partner_orientation:
+        partner_orientation = copy["partner_orientation_empty"]
+    investigation_items = _clean_string_list(
+        body.get("what_clara_should_investigate", [])
+    )
+    next_step_items = _clean_string_list(body.get("next_steps", []))
+    preparation_lenses = _localized_default_items(
+        preparation.get("succession_lenses", []), language
+    )
+    preparation_red_flags = _localized_default_items(
+        preparation.get("red_flags", []), language
+    )
+
+    html_text = f"""<!doctype html>
+<html lang="{_html_escape(manifest['output_language'])}">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>{_html_escape(copy['deck_eyebrow'])} - {_html_escape(manifest['client'])}</title>
+  <style>
+    :root {{
+      --paper: #ffffff;
+      --ink: #243027;
+      --text: #465148;
+      --muted: #6d776f;
+      --line: #dfe6dd;
+      --soft: #f6f8f5;
+      --accent: #496a60;
+      font-family: "Segoe UI", -apple-system, BlinkMacSystemFont, sans-serif;
+    }}
+    * {{ box-sizing: border-box; }}
+    body {{ margin: 0; background: var(--paper); color: var(--text); line-height: 1.5; }}
+    main {{ width: min(1120px, calc(100% - 40px)); margin: 0 auto; padding: 42px 0 64px; }}
+    section {{ min-height: min(720px, calc(100vh - 44px)); padding: 40px 0; border-bottom: 1px solid var(--line); display: grid; align-content: center; gap: 24px; }}
+    h1, h2, h3 {{ margin: 0; color: var(--ink); line-height: 1.12; letter-spacing: 0; }}
+    h1 {{ max-width: 840px; font-size: 2.65rem; font-weight: 620; }}
+    h2 {{ max-width: 880px; font-size: 2rem; font-weight: 620; }}
+    h3 {{ font-size: 1rem; font-weight: 650; }}
+    p {{ margin: 0; }}
+    .eyebrow {{ color: var(--accent); font-size: 12px; font-weight: 700; letter-spacing: .08em; text-transform: uppercase; }}
+    .lead {{ max-width: 820px; font-size: 1.08rem; }}
+    .meta {{ display: flex; flex-wrap: wrap; gap: 8px; color: var(--muted); }}
+    .meta span {{ border: 1px solid var(--line); border-radius: 999px; padding: 6px 10px; }}
+    .grid {{ display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 14px; }}
+    .grid.two {{ grid-template-columns: repeat(2, minmax(0, 1fr)); }}
+    .panel {{ border: 1px solid var(--line); border-radius: 8px; padding: 18px; background: var(--soft); }}
+    .metric strong {{ display: block; color: var(--ink); font-size: 2rem; }}
+    ul {{ margin: 12px 0 0; padding-left: 20px; }}
+    li {{ margin: 7px 0; }}
+    .note {{ border-left: 4px solid var(--accent); background: var(--soft); padding: 14px 16px; }}
+    @media (max-width: 820px) {{
+      main {{ width: auto; margin: 0 20px; }}
+      section {{ min-height: auto; }}
+      h1 {{ font-size: 2rem; }}
+      h2 {{ font-size: 1.5rem; }}
+      .grid, .grid.two {{ grid-template-columns: minmax(0, 1fr); }}
+    }}
+  </style>
+</head>
+<body>
+<main>
+  <section>
+    <div>
+      <p class="eyebrow">{_html_escape(copy['deck_eyebrow'])}</p>
+      <h1>{_html_escape(manifest['client'])}</h1>
+    </div>
+    <p class="lead">{_html_escape(client_decision)}</p>
+    <div class="meta">
+      <span>{_html_escape(material_count)} {_html_escape(copy['materials_metric'])}</span>
+      <span>{_html_escape(pending_count)} {_html_escape(copy['candidate_count'])}</span>
+      <span>{_html_escape(approved_count)} {_html_escape(copy['approved_metric'])}</span>
+    </div>
+    <p class="note">{_html_escape(copy['deck_note'])}</p>
+  </section>
+
+  <section>
+    <div>
+      <p class="eyebrow">{_html_escape(copy['initial_readout'])}</p>
+      <h2>{_html_escape(copy['initial_readout_heading'])}</h2>
+    </div>
+    <div class="grid two">
+      <div class="panel"><h3>{_html_escape(copy['known_facts'])}</h3>{_html_compact_list(facts, limit=4, empty=copy['facts_empty'])}</div>
+      <div class="panel"><h3>{_html_escape(copy['partner_orientation'])}</h3><p>{_html_escape(partner_orientation)}</p></div>
+    </div>
+  </section>
+
+  <section>
+    <div>
+      <p class="eyebrow">{_html_escape(copy['hypotheses_eyebrow'])}</p>
+      <h2>{_html_escape(copy['hypotheses_heading'])}</h2>
+    </div>
+    {_html_compact_list(hypotheses, limit=7, empty=copy['hypotheses_empty'])}
+  </section>
+
+  <section>
+    <div>
+      <p class="eyebrow">{_html_escape(copy['evidence_gaps'])}</p>
+      <h2>{_html_escape(copy['questions_heading'])}</h2>
+    </div>
+    {_html_compact_list(open_question_items, limit=7, empty=copy['questions_empty'])}
+  </section>
+
+  <section>
+    <div>
+      <p class="eyebrow">{_html_escape(copy['preparation_lenses'])}</p>
+      <h2>{_html_escape(copy['preparation_lenses_heading'])}</h2>
+    </div>
+    <div class="grid two">
+      <div class="panel"><h3>{_html_escape(copy['preparation_lenses'])}</h3>{_html_compact_list(preparation_lenses, limit=5, empty=copy['lenses_empty'])}</div>
+      <div class="panel"><h3>{_html_escape(copy['red_flags'])}</h3>{_html_compact_list(preparation_red_flags, limit=5, empty=copy['red_flags_empty'])}</div>
+    </div>
+  </section>
+
+  <section>
+    <div>
+      <p class="eyebrow">{_html_escape(copy['next_conversation'])}</p>
+      <h2>{_html_escape(copy['next_conversation_heading'])}</h2>
+    </div>
+    <div class="grid two">
+      <div class="panel"><h3>{_html_escape(copy['judgement'])}</h3><ul><li>{_html_escape(copy['judgement_item_right'])}</li><li>{_html_escape(copy['judgement_item_sensitive'])}</li><li>{_html_escape(copy['judgement_item_client'])}</li></ul></div>
+      <div class="panel"><h3>{_html_escape(copy['investigation'])}</h3>{_html_compact_list(investigation_items, limit=5, empty=copy['investigation_prompt'])}</div>
+      <div class="panel"><h3>{_html_escape(copy['direction'])}</h3><ul><li>{_html_escape(copy['direction_item_include'])}</li><li>{_html_escape(copy['direction_item_output'])}</li></ul></div>
+      <div class="panel"><h3>{_html_escape(copy['already_requested_next_steps'])}</h3>{_html_compact_list(next_step_items, limit=5, empty=copy['next_step_empty'])}</div>
+    </div>
+  </section>
+</main>
+</body>
+</html>
+"""
+    try:
+        html_text = apply_fixed_16_9_deck_runtime(html_text)
+        assert_fixed_16_9_deck_runtime(html_text, label=CLARA_KICKOFF_DECK_FILENAME)
+    except ValueError as exc:
+        raise CaseWorkspaceError(str(exc)) from exc
+    _assert_human_visible_document_quality(html_text, label=CLARA_KICKOFF_DECK_FILENAME)
+    atomic_text(target_path, html_text, encoding="utf-8")
+    return ClaraKickoffDeckResult(
+        html_path=target_path,
+        hypothesis_count=len(hypotheses),
+        open_question_count=len(open_question_items),
+    )
+
+
+@case_operation
+def render_clara_partner_brief(
+    case_dir: Path,
+    *,
+    output_path: Path | None = None,
+) -> ClaraPartnerBriefResult:
+    """Render Clara's first local HTML brief for the senior partner."""
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+    manifest = _read_json(_case_path(case_dir, "manifest"))
+    language = _ui_language(manifest)
+    copy = _html_copy(language)
+    materials = _read_json(_case_path(case_dir, "materials"))["materials"]
+    entries = _read_json(_case_path(case_dir, "judgement"))["entries"]
+    questions = _read_json(_case_path(case_dir, "open_questions"))["questions"]
+    mandate = _read_json(_case_path(case_dir, "clara_mandate"))
+    body = mandate["mandate"]
+    preparation = mandate["preparation"]
+    pending_count = sum(1 for entry in entries if entry["status"] == "pending")
+    approved_count = sum(1 for entry in entries if entry["status"] == "approved")
+    open_question_count = sum(1 for item in questions if item["status"] == "open")
+    candidate_items = _entry_texts_by_status(
+        entries,
+        statuses={"pending"},
+        kinds={"advisor_judgement", "codex_inference", "decision_implication"},
+    )
+    approved_partner_items = _partner_approved_content(entries)
+    judgement_section_title = copy["candidate_judgement"]
+    judgement_empty = copy["candidate_empty"]
+    displayed_judgement_items = candidate_items
+    if not candidate_items and approved_partner_items:
+        judgement_section_title = copy["ready_judgement"]
+        judgement_empty = copy["ready_judgement_empty"]
+        displayed_judgement_items = approved_partner_items
+    open_question_items = _open_question_texts(questions)
+    client_decision_text = (
+        str(body.get("client_decision", "")).strip()
+        or str(manifest.get("objective", "")).strip()
+    )
+    partner_orientation_text = str(body.get("partner_starting_orientation", "")).strip()
+    if not partner_orientation_text:
+        partner_orientation_text = copy["partner_orientation_waiting"]
+    investigation_items = (
+        _clean_string_list(body.get("what_clara_should_investigate", []))
+        or open_question_items[:5]
+    )
+    clarification_items = (
+        _clean_string_list(body.get("essential_clarifications", []))
+        or open_question_items[:5]
+    )
+    next_step_items = _clean_string_list(
+        body.get("next_steps", [])
+    ) or _default_partner_next_steps(language)
+    sensitive_items = _clean_string_list(body.get("sensitive_points", [])) or [
+        copy["sensitive_default_gate"],
+        copy["sensitive_default_paths"],
+    ]
+    preparation_lenses = _localized_default_items(
+        preparation.get("succession_lenses", []), language
+    )
+    research_items = _localized_default_research_items(
+        preparation.get("external_research", []), language
+    )
+    industry_context_items = _clean_string_list(
+        preparation.get("industry_context", [])
+    ) or _indexed_industry_context_items(materials)
+    target_path = output_path or case_dir / CLARA_PARTNER_BRIEF_FILENAME
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    if _same_text_sequence(investigation_items, clarification_items):
+        investigation_sections = f"""
+  <section>
+    <h2>{_html_escape(copy['priority_checks'])}</h2>
+    {_html_compact_list(investigation_items, limit=7, empty=copy['investigation_empty'])}
+  </section>
+"""
+    else:
+        investigation_sections = f"""
+  <section>
+    <h2>{_html_escape(copy['investigation_title'])}</h2>
+    {_html_compact_list(investigation_items, limit=7, empty=copy['investigation_empty'])}
+  </section>
+
+  <section>
+    <h2>{_html_escape(copy['essential_clarifications'])}</h2>
+    {_html_compact_list(clarification_items, limit=7, empty=copy['clarification_empty'])}
+  </section>
+"""
+
+    html_text = f"""<!doctype html>
+<html lang="{_html_escape(manifest['output_language'])}">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>{_html_escape(copy['brief_eyebrow'])} - {_html_escape(manifest['client'])}</title>
+  <style>
+    :root {{
+      --paper: #ffffff;
+      --ink: #243027;
+      --text: #465148;
+      --muted: #6d776f;
+      --line: #dfe6dd;
+      --soft: #f6f8f5;
+      --accent: #496a60;
+      font-family: "Segoe UI", -apple-system, BlinkMacSystemFont, sans-serif;
+    }}
+    * {{ box-sizing: border-box; }}
+    body {{ margin: 0; color: var(--text); background: var(--paper); line-height: 1.55; }}
+    main {{ width: min(1080px, calc(100% - 40px)); margin: 0 auto; padding: 48px 0 64px; }}
+    header {{ padding-bottom: 34px; border-bottom: 1px solid var(--line); }}
+    .eyebrow {{ margin: 0 0 12px; color: var(--accent); font-size: 12px; font-weight: 700; letter-spacing: .08em; text-transform: uppercase; }}
+    h1, h2, h3 {{ margin: 0; color: var(--ink); letter-spacing: 0; line-height: 1.12; }}
+    h1 {{ max-width: 820px; font-size: 2.7rem; font-weight: 620; }}
+    h2 {{ font-size: 1.55rem; font-weight: 620; }}
+    h3 {{ font-size: 1rem; font-weight: 650; }}
+    p {{ margin: 0; }}
+    .lead {{ max-width: 780px; margin-top: 18px; font-size: 1.05rem; }}
+    section {{ padding: 34px 0; border-bottom: 1px solid var(--line); }}
+    .grid {{ display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 14px; margin-top: 18px; }}
+    .metric, .panel {{ border: 1px solid var(--line); border-radius: 8px; padding: 18px; background: #fff; }}
+    .metric strong {{ display: block; color: var(--ink); font-size: 1.8rem; line-height: 1; }}
+    .metric span, .empty {{ color: var(--muted); }}
+    .panel {{ background: var(--soft); }}
+    ul {{ margin: 14px 0 0; padding-left: 20px; }}
+    li {{ margin: 7px 0; }}
+    .research-list {{ display: grid; gap: 10px; padding-left: 0; list-style: none; }}
+    .research-list li {{ display: grid; gap: 4px; padding-bottom: 10px; border-bottom: 1px solid var(--line); }}
+    a {{ color: var(--accent); overflow-wrap: anywhere; }}
+    .note {{ margin-top: 16px; padding: 14px 16px; border-left: 4px solid var(--accent); background: var(--soft); }}
+    @media (max-width: 760px) {{
+      main {{ width: auto; margin: 0 20px; }}
+      h1 {{ font-size: 2rem; }}
+      .grid {{ grid-template-columns: minmax(0, 1fr); }}
+    }}
+  </style>
+</head>
+<body>
+<main>
+  <header>
+    <p class="eyebrow">{_html_escape(copy['brief_eyebrow'])}</p>
+    <h1>{_html_escape(manifest['client'])}</h1>
+    <p class="lead">{_html_escape(body.get('clara_understanding') or copy['brief_lead'])}</p>
+  </header>
+
+  <section>
+    <h2>{_html_escape(copy['case_state'])}</h2>
+    <div class="grid">
+      <div class="metric"><strong>{len(materials)}</strong><span>{_html_escape(copy['materials_metric'])}</span></div>
+      <div class="metric"><strong>{pending_count}</strong><span>{_html_escape(copy['pending_metric'])}</span></div>
+      <div class="metric"><strong>{open_question_count}</strong><span>{_html_escape(copy['open_questions_metric'])}</span></div>
+    </div>
+    <p class="note">{_html_escape(copy['pending_note'].format(approved_count=approved_count))}</p>
+  </section>
+
+  <section>
+    <h2>{_html_escape(copy['mandate'])}</h2>
+    <div class="grid">
+      <div class="panel"><h3>{_html_escape(copy['engagement_objective'])}</h3><p>{_html_escape(body.get('engagement_objective') or manifest['objective'])}</p></div>
+      <div class="panel"><h3>{_html_escape(copy['client_decision'])}</h3><p>{_html_escape(client_decision_text)}</p></div>
+      <div class="panel"><h3>{_html_escape(copy['partner_orientation'])}</h3><p>{_html_escape(partner_orientation_text)}</p></div>
+    </div>
+  </section>
+
+  <section>
+    <h2>{_html_escape(judgement_section_title)}</h2>
+    {_html_compact_list(displayed_judgement_items, limit=8, empty=judgement_empty)}
+  </section>
+
+  <section>
+    <h2>{_html_escape(copy['sensitive_points'])}</h2>
+    {_html_compact_list(sensitive_items, limit=5, empty=copy['sensitive_empty'])}
+  </section>
+
+{investigation_sections}
+
+  <section>
+    <h2>{_html_escape(copy['next_steps'])}</h2>
+    {_html_compact_list(next_step_items, limit=5, empty=copy['next_step_empty'])}
+  </section>
+
+  <section>
+    <h2>{_html_escape(copy['preparation_lenses'])}</h2>
+    {_html_list(preparation_lenses, empty=copy['lenses_empty'])}
+  </section>
+
+  <section>
+    <h2>{_html_escape(copy['industry_context'])}</h2>
+    {_html_list(industry_context_items, empty=copy['industry_context_empty'])}
+  </section>
+
+  <section>
+    <h2>{_html_escape(copy['research_notes'])}</h2>
+    {_html_research_list(research_items, empty=copy['research_empty'])}
+  </section>
+
+  <section>
+    <h2>{_html_escape(copy['control_note'])}</h2>
+    <p>{_html_escape(copy['control_note_body'])}</p>
+  </section>
+</main>
+</body>
+</html>
+"""
+    _assert_human_visible_document_quality(
+        html_text, label=CLARA_PARTNER_BRIEF_FILENAME
+    )
+    atomic_text(target_path, html_text, encoding="utf-8")
+    return ClaraPartnerBriefResult(
+        html_path=target_path,
+        open_clarification_count=len(clarification_items),
+        next_step_count=len(next_step_items),
+    )
+
+
+def _case_fingerprint(manifest: Mapping[str, Any]) -> str:
+    stable_fields = {
+        key: manifest.get(key, "")
+        for key in (
+            "client",
+            "project",
+            "objective",
+            "audience",
+            "created_at",
+        )
+    }
+    raw = json.dumps(stable_fields, sort_keys=True, ensure_ascii=True)
+    return sha256(raw.encode("utf-8")).hexdigest()[:16]
+
+
+def _record_origin_key(
+    record: Mapping[str, Any],
+    *,
+    source_case_id: str,
+    record_type: str,
+) -> str:
+    existing = str(record.get("origin_key", "")).strip()
+    if existing:
+        return existing
+    return f"{source_case_id}:{record_type}:{record['id']}"
+
+
+def _case_relative_file(case_dir: Path, path_value: str) -> Path | None:
+    path = Path(path_value).expanduser()
+    if not path.is_absolute():
+        path = case_dir / path
+    try:
+        resolved = path.resolve()
+    except OSError:
+        return None
+    case_root = case_dir.resolve()
+    if not resolved.is_file() or not resolved.is_relative_to(case_root):
+        return None
+    relative = resolved.relative_to(case_root)
+    if relative.name in CASE_FILES.values():
+        return None
+    return relative
+
+
+def _exchange_id(source_case_id: str, exported_at: str, exporter: str) -> str:
+    raw = f"{source_case_id}|{exported_at}|{exporter}"
+    return sha256(raw.encode("utf-8")).hexdigest()[:16]
+
+
+def _exchange_package_name(exchange_id: str) -> str:
+    return f"case-update-{exchange_id}.zip"
+
+
+def _workspace_archive_name(case_dir: Path, exported_at: str) -> str:
+    return f"{_slugify(case_dir.name, fallback='case')}-workspace-{_compact_timestamp(exported_at)}.zip"
+
+
+def _support_package_name(case_dir: Path, exported_at: str) -> str:
+    return f"{_slugify(case_dir.name, fallback='case')}-support-{_compact_timestamp(exported_at)}.zip"
+
+
+def _is_runtime_dependency_dir(name: str) -> bool:
+    return name.startswith(".codex_") and name.endswith("_py")
+
+
+def _share_exclusion_reason(path: Path) -> str:
+    name = path.name
+    if name in SHARE_EXCLUDED_FILE_NAMES:
+        return "local metadata file"
+    if name.startswith("._"):
+        return "macOS resource fork"
+    if name in SHARE_EXCLUDED_DIR_NAMES:
+        return "local runtime or cache directory"
+    if _is_runtime_dependency_dir(name):
+        return "local plugin dependency directory"
+    return ""
+
+
+def _path_file_count_and_size(path: Path) -> tuple[int, int]:
+    try:
+        if path.is_symlink():
+            return 1, path.lstat().st_size
+        if path.is_file():
+            return 1, path.stat().st_size
+        if not path.is_dir():
+            return 0, 0
+    except OSError:
+        return 0, 0
+    file_count = 0
+    byte_count = 0
+    for item in path.rglob("*"):
+        try:
+            if item.is_file() or item.is_symlink():
+                file_count += 1
+                byte_count += item.lstat().st_size
+        except OSError:
+            continue
+    return file_count, byte_count
+
+
+def _iter_share_archive_files(
+    case_dir: Path,
+    package_path: Path,
+) -> tuple[list[Path], int, int]:
+    included_files: list[Path] = []
+    excluded_file_count = 0
+    excluded_bytes = 0
+    package_resolved = package_path.resolve()
+    pending = [case_dir]
+    while pending:
+        current = pending.pop()
+        for child in sorted(current.iterdir(), key=lambda item: item.name.lower()):
+            try:
+                if child.resolve() == package_resolved:
+                    count, size = _path_file_count_and_size(child)
+                    excluded_file_count += count
+                    excluded_bytes += size
+                    continue
+            except OSError:
+                continue
+            reason = _share_exclusion_reason(child)
+            if reason:
+                count, size = _path_file_count_and_size(child)
+                excluded_file_count += count
+                excluded_bytes += size
+                LOGGER.debug("Skipping %s from case share archive: %s", child, reason)
+                continue
+            if child.is_symlink():
+                count, size = _path_file_count_and_size(child)
+                excluded_file_count += count
+                excluded_bytes += size
+                LOGGER.debug("Skipping symlink from case share archive: %s", child)
+            elif child.is_dir():
+                pending.append(child)
+            elif child.is_file():
+                included_files.append(child)
+    return sorted(included_files), excluded_file_count, excluded_bytes
+
+
+@case_reader
+def export_case_workspace_archive(
+    case_dir: Path,
+    *,
+    package_path: Path | None = None,
+    now: datetime | None = None,
+) -> CaseWorkspaceArchiveResult:
+    """Export a clean full-workspace ZIP that excludes local runtimes and caches."""
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+
+    timestamp = _now_iso(now)
+    target_path = package_path
+    if target_path is None:
+        target_dir = case_dir.parent / "case_share_exports"
+        target_dir.mkdir(parents=True, exist_ok=True)
+        target_path = target_dir / _workspace_archive_name(case_dir, timestamp)
+    else:
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+
+    files, excluded_file_count, excluded_bytes = _iter_share_archive_files(
+        case_dir,
+        target_path,
+    )
+    root_name = case_dir.name.strip() or "case-workspace"
+    with ZipFile(target_path, "w", compression=ZIP_DEFLATED) as archive:
+        for path in files:
+            relative_path = path.relative_to(case_dir)
+            archive.write(path, f"{root_name}/{relative_path.as_posix()}")
+
+    return CaseWorkspaceArchiveResult(
+        package_path=target_path,
+        included_file_count=len(files),
+        excluded_file_count=excluded_file_count,
+        excluded_bytes=excluded_bytes,
+    )
+
+
+def _support_markdown_value(value: Any, *, missing: str = "Not recorded") -> str:
+    text = str(value or "").strip()
+    return text or missing
+
+
+def _support_request_block(
+    request: str,
+    *,
+    empty: str = "No request text provided.",
+) -> str:
+    lines = request.strip().splitlines() or [empty]
+    return "\n".join(f"> {line}" if line.strip() else ">" for line in lines)
+
+
+def _render_support_request_markdown(
+    *,
+    manifest: Mapping[str, Any],
+    request: str,
+    requested_by: str,
+    recipient: str,
+    created_at: str,
+    included_paths: Sequence[str],
+    excluded_file_count: int,
+    excluded_bytes: int,
+) -> str:
+    language = _ui_language(manifest)
+    if language == "es":
+        copy = {
+            "title": "Solicitud de apoyo para {recipient}",
+            "created": "Creada el",
+            "requested_by": "Solicitada por",
+            "recipient": "Destinatario",
+            "client": "Cliente",
+            "project": "Proyecto",
+            "objective": "Objetivo",
+            "audience": "Destinatario del trabajo",
+            "language": "Idioma",
+            "needed": "Qué se necesita",
+            "included_state": "Estado de Clara incluido",
+            "included": "incluido",
+            "not_present": "no presente",
+            "generated_only": "generado únicamente para este paquete",
+            "exclusions": "Exclusiones locales",
+            "excluded_count": "Número de archivos locales o de ejecución excluidos",
+            "excluded_bytes": "Bytes locales o de ejecución excluidos",
+            "exclusion_note": (
+                "No se incluyen las carpetas ocultas de dependencias de OCR o de "
+                "ejecución, como `.codex_*_py`, los entornos virtuales, las cachés, "
+                "los metadatos de macOS ni las exportaciones de intercambio anteriores."
+            ),
+            "operating_note": "Nota operativa",
+            "operating_body": (
+                "La carpeta local de Clara de quien realiza la solicitud sigue "
+                "siendo la copia de trabajo autoritativa. El destinatario puede "
+                "utilizar Clara, Pro, edición manual o cambios del plugin para "
+                "desbloquear la entrega. El material devuelto que resulte útil debe "
+                "registrarse de nuevo en el caso cuando sea pertinente."
+            ),
+            "missing": "No registrado",
+            "empty_request": "No se ha facilitado el texto de la solicitud.",
+            "default_recipient": "Revisor de apoyo",
+        }
+    else:
+        copy = {
+            "title": "Support Request For {recipient}",
+            "created": "Created at",
+            "requested_by": "Requested by",
+            "recipient": "Recipient",
+            "client": "Client",
+            "project": "Project",
+            "objective": "Objective",
+            "audience": "Audience",
+            "language": "Language",
+            "needed": "What Is Needed",
+            "included_state": "Included Clara State",
+            "included": "included",
+            "not_present": "not present",
+            "generated_only": "generated for this package only",
+            "exclusions": "Local Exclusions",
+            "excluded_count": "Excluded local/runtime file count",
+            "excluded_bytes": "Excluded local/runtime bytes",
+            "exclusion_note": (
+                "Hidden OCR/runtime dependency folders such as `.codex_*_py`, "
+                "virtual environments, caches, macOS metadata, and prior exchange "
+                "exports are not included."
+            ),
+            "operating_note": "Operating Note",
+            "operating_body": (
+                "The requester's local Clara folder remains the authoritative "
+                "working copy. The recipient may use Clara, Pro, manual editing, "
+                "or plugin changes to unblock delivery. Useful returned material "
+                "should be registered back into the case when it matters."
+            ),
+            "missing": "Not recorded",
+            "empty_request": "No request text provided.",
+            "default_recipient": "Support reviewer",
+        }
+    tracked_artifacts = (
+        "case_manifest.json",
+        "case_brief.md",
+        "clara_mandate.json",
+        "clara_kickoff_preparation.md",
+        "clara_partner_brief.html",
+        "material_registry.json",
+        "judgement_log.json",
+        "open_questions.json",
+        "case_issues.json",
+        "voice_sessions/",
+        "outputs/",
+    )
+    included_set = set(included_paths)
+    included_artifact_lines = []
+    for artifact in tracked_artifacts:
+        if artifact.endswith("/"):
+            status = (
+                copy["included"]
+                if any(path.startswith(artifact) for path in included_set)
+                else copy["not_present"]
+            )
+        else:
+            status = (
+                copy["included"] if artifact in included_set else copy["not_present"]
+            )
+        included_artifact_lines.append(f"- `{artifact}`: {status}")
+
+    request_block = _support_request_block(request, empty=copy["empty_request"])
+    requested_by_value = _support_markdown_value(
+        requested_by,
+        missing=copy["missing"],
+    )
+    recipient_value = _support_markdown_value(recipient, missing=copy["missing"])
+    if language == "es" and recipient_value == "Support reviewer":
+        recipient_value = copy["default_recipient"]
+    return (
+        f"# {copy['title'].format(recipient=recipient_value)}\n\n"
+        f"- {copy['created']}: {created_at}\n"
+        f"- {copy['requested_by']}: {requested_by_value}\n"
+        f"- {copy['recipient']}: {recipient_value}\n"
+        f"- {copy['client']}: {_support_markdown_value(manifest.get('client'), missing=copy['missing'])}\n"
+        f"- {copy['project']}: {_support_markdown_value(manifest.get('project'), missing=copy['missing'])}\n"
+        f"- {copy['objective']}: {_support_markdown_value(manifest.get('objective'), missing=copy['missing'])}\n"
+        f"- {copy['audience']}: {_support_markdown_value(manifest.get('audience'), missing=copy['missing'])}\n"
+        f"- {copy['language']}: {_support_markdown_value(manifest.get('output_language'), missing=copy['missing'])}\n\n"
+        f"## {copy['needed']}\n\n"
+        f"{request_block}\n\n"
+        f"## {copy['included_state']}\n\n" + "\n".join(included_artifact_lines) + "\n"
+        f"- `{SUPPORT_REQUEST_FILENAME}`: {copy['generated_only']}\n\n"
+        f"## {copy['exclusions']}\n\n"
+        f"- {copy['excluded_count']}: {excluded_file_count}\n"
+        f"- {copy['excluded_bytes']}: {excluded_bytes}\n"
+        f"- {copy['exclusion_note']}\n\n"
+        f"## {copy['operating_note']}\n\n"
+        f"{copy['operating_body']}\n"
+    )
+
+
+@case_reader
+def prepare_support_package(
+    case_dir: Path,
+    *,
+    request: str,
+    requested_by: str = "",
+    recipient: str = "Support reviewer",
+    package_path: Path | None = None,
+    now: datetime | None = None,
+) -> CaseSupportPackageResult:
+    """Create a clean support ZIP for delivery escalation."""
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+
+    clean_request = request.strip()
+    if not clean_request:
+        raise CaseWorkspaceError("support request cannot be empty")
+
+    timestamp = _now_iso(now)
+    target_path = package_path
+    if target_path is None:
+        target_dir = case_dir.parent / "case_support_exports"
+        target_dir.mkdir(parents=True, exist_ok=True)
+        target_path = target_dir / _support_package_name(case_dir, timestamp)
+    else:
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+
+    files, excluded_file_count, excluded_bytes = _iter_share_archive_files(
+        case_dir,
+        target_path,
+    )
+    root_name = case_dir.name.strip() or "case-workspace"
+    support_archive_path = f"{root_name}/{SUPPORT_REQUEST_FILENAME}"
+    included_paths: list[str] = []
+    with ZipFile(target_path, "w", compression=ZIP_DEFLATED) as archive:
+        for path in files:
+            relative_path = path.relative_to(case_dir)
+            relative_name = relative_path.as_posix()
+            if relative_name == SUPPORT_REQUEST_FILENAME:
+                continue
+            archive.write(path, f"{root_name}/{relative_name}")
+            included_paths.append(relative_name)
+        manifest = _read_json(_case_path(case_dir, "manifest"))
+        archive.writestr(
+            support_archive_path,
+            _render_support_request_markdown(
+                manifest=manifest,
+                request=clean_request,
+                requested_by=requested_by,
+                recipient=recipient,
+                created_at=timestamp,
+                included_paths=included_paths,
+                excluded_file_count=excluded_file_count,
+                excluded_bytes=excluded_bytes,
+            ),
+        )
+
+    return CaseSupportPackageResult(
+        package_path=target_path,
+        support_request_archive_path=support_archive_path,
+        included_file_count=len(included_paths) + 1,
+        excluded_file_count=excluded_file_count,
+        excluded_bytes=excluded_bytes,
+    )
+
+
+@case_reader
+def export_case_update(
+    case_dir: Path,
+    *,
+    package_path: Path | None = None,
+    exporter: str = "",
+    now: datetime | None = None,
+) -> CaseExchangeExportResult:
+    """Export a deterministic ZIP package for local-first case exchange."""
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+
+    timestamp = _now_iso(now)
+    manifest = _read_json(_case_path(case_dir, "manifest"))
+    materials = _read_json(_case_path(case_dir, "materials"))["materials"]
+    entries = _read_json(_case_path(case_dir, "judgement"))["entries"]
+    questions = _read_json(_case_path(case_dir, "open_questions"))["questions"]
+    issues = _read_json(_case_path(case_dir, "issues"))["issues"]
+    evidence = _read_json(case_dir / EVIDENCE_REGISTER_FILENAME)["evidence"]
+    claims = _read_json(case_dir / CLAIM_REGISTER_FILENAME)["claims"]
+    source_case_id = str(manifest.get("case_id") or _case_fingerprint(manifest))
+    exchange_id = _exchange_id(source_case_id, timestamp, exporter)
+
+    included_files: list[dict[str, str]] = []
+    for material in materials:
+        relative_path = _case_relative_file(case_dir, str(material.get("path", "")))
+        if relative_path is None:
+            continue
+        archive_path = f"files/{relative_path.as_posix()}"
+        included_files.append(
+            {
+                "material_id": str(material["id"]),
+                "relative_path": relative_path.as_posix(),
+                "archive_path": archive_path,
+            }
+        )
+
+    included_lineage_files: list[dict[str, Any]] = []
+    lineage_archive_by_source: dict[Path, str] = {}
+
+    def include_lineage_artifact(
+        *,
+        record_type: str,
+        record_id: str,
+        artifact_index: int,
+        receipt: Mapping[str, Any],
+    ) -> None:
+        raw_path = Path(str(receipt.get("path", ""))).expanduser()
+        source_path = (
+            (case_dir / raw_path).resolve()
+            if receipt.get("path_reference") == "case_relative"
+            else raw_path.resolve()
+        )
+        if not source_path.is_file():
+            raise CaseWorkspaceError(
+                f"lineage artifact is missing during export: {source_path}"
+            )
+        archive_path = lineage_archive_by_source.get(source_path)
+        if archive_path is None:
+            archive_path = (
+                f"lineage_files/artifacts/{len(lineage_archive_by_source) + 1:04d}-"
+                f"{source_path.name}"
+            )
+            lineage_archive_by_source[source_path] = archive_path
+        included_lineage_files.append(
+            {
+                "record_type": record_type,
+                "record_id": record_id,
+                "artifact_index": artifact_index,
+                "source_path": str(source_path),
+                "archive_path": archive_path,
+            }
+        )
+
+    for receipt in evidence:
+        if not isinstance(receipt, dict):
+            continue
+        source = receipt.get("source")
+        if not isinstance(source, dict):
+            continue
+        for artifact_index, artifact in enumerate(source.get("artifact_refs", [])):
+            if isinstance(artifact, dict):
+                include_lineage_artifact(
+                    record_type="evidence",
+                    record_id=str(receipt["id"]),
+                    artifact_index=artifact_index,
+                    receipt=artifact,
+                )
+    for claim in claims:
+        if not isinstance(claim, dict):
+            continue
+        for artifact_index, appearance in enumerate(claim.get("appearances", [])):
+            if isinstance(appearance, dict):
+                include_lineage_artifact(
+                    record_type="claim_appearance",
+                    record_id=str(claim["id"]),
+                    artifact_index=artifact_index,
+                    receipt={
+                        "path": appearance.get("artifact", ""),
+                        "path_reference": appearance.get("path_reference", ""),
+                    },
+                )
+
+    update_payload = {
+        "schema_version": EXCHANGE_SCHEMA_VERSION,
+        "source": EXCHANGE_SOURCE,
+        "exchange_id": exchange_id,
+        "source_case_id": source_case_id,
+        "exported_at": timestamp,
+        "exporter": exporter,
+        "case_manifest": manifest,
+        "materials": [
+            {
+                **material,
+                "origin_key": _record_origin_key(
+                    material,
+                    source_case_id=source_case_id,
+                    record_type="material",
+                ),
+            }
+            for material in materials
+        ],
+        "judgement_entries": [
+            {
+                **entry,
+                "origin_key": _record_origin_key(
+                    entry,
+                    source_case_id=source_case_id,
+                    record_type="judgement",
+                ),
+            }
+            for entry in entries
+        ],
+        "open_questions": [
+            {
+                **question,
+                "origin_key": _record_origin_key(
+                    question,
+                    source_case_id=source_case_id,
+                    record_type="open_question",
+                ),
+            }
+            for question in questions
+        ],
+        "case_issues": [
+            {
+                **issue,
+                "origin_key": _record_origin_key(
+                    issue,
+                    source_case_id=source_case_id,
+                    record_type="case_issue",
+                ),
+            }
+            for issue in issues
+        ],
+        "evidence_receipts": evidence,
+        "claims": claims,
+        "included_files": included_files,
+        "included_lineage_files": included_lineage_files,
+    }
+
+    target_path = package_path
+    if target_path is None:
+        target_dir = case_dir / "exchange_exports"
+        target_dir.mkdir(parents=True, exist_ok=True)
+        target_path = target_dir / _exchange_package_name(exchange_id)
+    else:
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with ZipFile(target_path, "w", compression=ZIP_DEFLATED) as archive:
+        archive.writestr(
+            "case_update.json",
+            json.dumps(update_payload, indent=2, sort_keys=True, ensure_ascii=True)
+            + "\n",
+        )
+        for file_item in included_files:
+            archive.write(
+                case_dir / file_item["relative_path"],
+                file_item["archive_path"],
+            )
+        written_lineage_paths: set[str] = set()
+        for file_item in included_lineage_files:
+            if file_item["archive_path"] in written_lineage_paths:
+                continue
+            archive.write(
+                file_item["source_path"],
+                file_item["archive_path"],
+            )
+            written_lineage_paths.add(file_item["archive_path"])
+
+    return CaseExchangeExportResult(
+        package_path=target_path,
+        exchange_id=exchange_id,
+        material_count=len(materials),
+        judgement_count=len(entries),
+        open_question_count=len(questions),
+        included_file_count=len(included_files) + len(lineage_archive_by_source),
+        evidence_count=len(evidence),
+        claim_count=len(claims),
+        issue_count=len(issues),
+    )
+
+
+def _load_case_update(package_path: Path) -> dict[str, Any]:
+    try:
+        payload = load_exchange(package_path)
+    except ValueError as exc:
+        raise CaseWorkspaceError(str(exc)) from exc
+    if payload.get("schema_version") != EXCHANGE_SCHEMA_VERSION:
+        raise CaseWorkspaceError("unsupported case update schema_version")
+    if payload.get("source") != EXCHANGE_SOURCE:
+        raise CaseWorkspaceError("unsupported case update source")
+    return payload
+
+
+def _origin_index(records: Sequence[Mapping[str, Any]]) -> dict[str, Mapping[str, Any]]:
+    return {
+        str(record["origin_key"]): record
+        for record in records
+        if str(record.get("origin_key", "")).strip()
+    }
+
+
+def _material_compare_fields(record: Mapping[str, Any]) -> dict[str, Any]:
+    return {
+        key: record.get(key) for key in ("title", "material_type", "status", "summary")
+    }
+
+
+def _judgement_compare_fields(record: Mapping[str, Any]) -> dict[str, Any]:
+    return {
+        key: record.get(key)
+        for key in (
+            "kind",
+            "text",
+            "status",
+            "rationale",
+            "reviewer",
+            "review_note",
+            "source_material_ids",
+            "advisory_claim_id",
+            "evidence_receipt_ids",
+        )
+    }
+
+
+def _question_compare_fields(record: Mapping[str, Any]) -> dict[str, Any]:
+    return {
+        key: record.get(key)
+        for key in ("question", "why_it_matters", "status", "source_entry_ids")
+    }
+
+
+def _issue_compare_fields(record: Mapping[str, Any]) -> dict[str, Any]:
+    return {
+        key: record.get(key)
+        for key in (
+            "title",
+            "decision_area",
+            "current_synthesis",
+            "status",
+            "evidence_for",
+            "evidence_against",
+            "claim_ids_for",
+            "claim_ids_against",
+            "open_tests",
+        )
+    }
+
+
+def _evidence_compare_fields(record: Mapping[str, Any]) -> dict[str, Any]:
+    """Normalize imported-path differences while preserving receipt meaning."""
+
+    normalized = json.loads(json.dumps(dict(record)))
+    normalized.pop("id", None)
+    normalized.pop("origin", None)
+    source = normalized.get("source")
+    artifact_identity_by_path: dict[str, tuple[Any, ...]] = {}
+    if isinstance(source, dict):
+        normalized_artifacts: list[dict[str, Any]] = []
+        for artifact in source.get("artifact_refs", []):
+            if not isinstance(artifact, dict):
+                continue
+            identity = (
+                artifact.get("sha256"),
+                artifact.get("byte_count"),
+                artifact.get("media_type"),
+            )
+            artifact_identity_by_path[str(artifact.get("path", ""))] = identity
+            normalized_artifacts.append(
+                {
+                    "sha256": identity[0],
+                    "byte_count": identity[1],
+                    "media_type": identity[2],
+                }
+            )
+        source["artifact_refs"] = normalized_artifacts
+    calculation = normalized.get("calculation")
+    if isinstance(calculation, dict):
+        for field in (
+            "input_artifact_paths",
+            "output_artifact_paths",
+            "verification_artifact_paths",
+        ):
+            calculation[field] = [
+                artifact_identity_by_path.get(str(path), ("missing", str(path)))
+                for path in calculation.get(field, [])
+            ]
+    return normalized
+
+
+def _claim_compare_fields(record: Mapping[str, Any]) -> dict[str, Any]:
+    """Return the immutable semantic part of an advisory claim."""
+
+    normalized = json.loads(json.dumps(dict(record)))
+    for field in ("id", "origin", "state", "appearances"):
+        normalized.pop(field, None)
+    return normalized
+
+
+def _appearance_identity(record: Mapping[str, Any]) -> tuple[Any, ...]:
+    return (
+        record.get("artifact_sha256"),
+        record.get("artifact_byte_count"),
+        record.get("locator"),
+        record.get("format_claim_id", ""),
+    )
+
+
+def _remap_declared_ids(
+    values: Sequence[Any],
+    mapping: Mapping[str, str],
+    *,
+    subject: str,
+) -> list[str]:
+    source_ids = [str(value) for value in values]
+    unknown = sorted(set(source_ids) - set(mapping))
+    if unknown:
+        raise CaseWorkspaceError(
+            f"{subject} references records omitted from the case update: "
+            + ", ".join(unknown)
+        )
+    return [mapping[value] for value in source_ids]
+
+
+def _append_conflict_question(
+    questions: list[dict[str, Any]],
+    *,
+    origin_key: str,
+    record_type: str,
+    label: str,
+    timestamp: str,
+) -> bool:
+    conflict_origin = f"conflict:{origin_key}"
+    if any(item.get("origin_key") == conflict_origin for item in questions):
+        return False
+    question = {
+        "id": _next_id("q", [item["id"] for item in questions]),
+        "question": f"Review imported {record_type} conflict: {label}",
+        "why_it_matters": (
+            "Case-update import is append-only and did not overwrite the "
+            "existing local record."
+        ),
+        "status": "open",
+        "source_entry_ids": [],
+        "created_at": timestamp,
+        "updated_at": timestamp,
+        "origin_key": conflict_origin,
+    }
+    questions.append(question)
+    return True
+
+
+def _safe_extract_archive_file(
+    archive: ZipFile,
+    *,
+    archive_path: str,
+    target_path: Path,
+) -> None:
+    archive_target = Path(archive_path)
+    if archive_target.is_absolute() or ".." in archive_target.parts:
+        raise CaseWorkspaceError(f"unsafe archive path: {archive_path}")
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    with archive.open(archive_path) as source:
+        atomic_stream(target_path, source)
+
+
+def _append_exchange_log(
+    case_dir: Path,
+    *,
+    exchange_id: str,
+    source_case_id: str,
+    package_path: Path,
+    timestamp: str,
+    counts: Mapping[str, int],
+) -> None:
+    log_path = case_dir / "exchange_log.json"
+    if log_path.exists():
+        payload = _read_json(log_path)
+        if payload.get("schema_version") != SCHEMA_VERSION:
+            raise CaseWorkspaceError("exchange_log.json: unsupported schema_version")
+    else:
+        payload = {"schema_version": SCHEMA_VERSION, "imports": []}
+    payload["imports"].append(
+        {
+            "exchange_id": exchange_id,
+            "source_case_id": source_case_id,
+            "package_path": str(package_path.resolve()),
+            "imported_at": timestamp,
+            "counts": dict(counts),
+        }
+    )
+    _write_json(log_path, payload)
+
+
+def _lineage_origin_index(
+    records: Sequence[Mapping[str, Any]],
+) -> dict[tuple[str, str], Mapping[str, Any]]:
+    index: dict[tuple[str, str], Mapping[str, Any]] = {}
+    for record in records:
+        origin = record.get("origin")
+        if not isinstance(origin, Mapping):
+            continue
+        source_case_id = str(origin.get("source_case_id", ""))
+        source_id = str(origin.get("source_id", ""))
+        if source_case_id and source_id:
+            index[(source_case_id, source_id)] = record
+    return index
+
+
+def _mapped_lineage_id(
+    source_id: str,
+    *,
+    source_case_id: str,
+    known_ids: set[str],
+) -> str:
+    if source_id not in known_ids:
+        known_ids.add(source_id)
+        return source_id
+    suffix = sha256(source_case_id.encode("utf-8")).hexdigest()[:10]
+    candidate = f"{source_id}-{suffix}"
+    serial = 2
+    while candidate in known_ids:
+        candidate = f"{source_id}-{suffix}-{serial}"
+        serial += 1
+    known_ids.add(candidate)
+    return candidate
+
+
+def _import_case_update_unprotected(
+    case_dir: Path,
+    package_path: Path,
+    *,
+    now: datetime | None = None,
+    source_package_path: Path | None = None,
+) -> CaseExchangeImportResult:
+    """Import a case update by appending records and logging conflicts."""
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+
+    timestamp = _now_iso(now)
+    update_payload = _load_case_update(package_path)
+    exchange_id = str(update_payload["exchange_id"])
+    source_case_id = str(update_payload["source_case_id"])
+
+    materials_path = _case_path(case_dir, "materials")
+    judgement_path = _case_path(case_dir, "judgement")
+    questions_path = _case_path(case_dir, "open_questions")
+    issues_path = _case_path(case_dir, "issues")
+    evidence_path = case_dir / EVIDENCE_REGISTER_FILENAME
+    claims_path = case_dir / CLAIM_REGISTER_FILENAME
+    material_payload = _read_json(materials_path)
+    judgement_payload = _read_json(judgement_path)
+    questions_payload = _read_json(questions_path)
+    issues_payload = _read_json(issues_path)
+    evidence_payload = _read_json(evidence_path)
+    claims_payload = _read_json(claims_path)
+    materials = material_payload["materials"]
+    entries = judgement_payload["entries"]
+    questions = questions_payload["questions"]
+    issues = issues_payload["issues"]
+    evidence = evidence_payload["evidence"]
+    claims = claims_payload["claims"]
+
+    material_origins = _origin_index(materials)
+    judgement_origins = _origin_index(entries)
+    question_origins = _origin_index(questions)
+    issue_origins = _origin_index(issues)
+    included_by_material_id = {
+        str(item["material_id"]): item
+        for item in update_payload.get("included_files", [])
+        if isinstance(item, Mapping)
+    }
+
+    imported_materials = 0
+    imported_entries = 0
+    imported_questions = 0
+    imported_issues = 0
+    imported_evidence = 0
+    imported_claims = 0
+    updated_claims = 0
+    skipped = 0
+    conflicts = 0
+    material_id_map: dict[str, str] = {}
+
+    with ZipFile(package_path) as archive:
+        for raw_material in update_payload.get("materials", []):
+            if not isinstance(raw_material, Mapping):
+                continue
+            origin_key = _record_origin_key(
+                raw_material,
+                source_case_id=source_case_id,
+                record_type="material",
+            )
+            existing = material_origins.get(origin_key)
+            if existing is not None:
+                material_id_map[str(raw_material["id"])] = str(existing["id"])
+                if _material_compare_fields(existing) != _material_compare_fields(
+                    raw_material
+                ):
+                    added_conflict = _append_conflict_question(
+                        questions,
+                        origin_key=origin_key,
+                        record_type="material",
+                        label=str(raw_material.get("title", raw_material["id"])),
+                        timestamp=timestamp,
+                    )
+                    conflicts += int(added_conflict)
+                else:
+                    skipped += 1
+                continue
+
+            new_id = _next_id("mat", [item["id"] for item in materials])
+            source_material_id = str(raw_material["id"])
+            included_file = included_by_material_id.get(source_material_id)
+            imported_path = str(raw_material.get("path", ""))
+            availability = "external_reference"
+            if included_file is not None:
+                relative_path = Path(str(included_file["relative_path"]))
+                if relative_path.is_absolute() or ".." in relative_path.parts:
+                    raise CaseWorkspaceError(
+                        f"unsafe included file path: {relative_path}"
+                    )
+                imported_file_path = (
+                    case_dir / "exchange_imports" / exchange_id / relative_path
+                )
+                _safe_extract_archive_file(
+                    archive,
+                    archive_path=str(included_file["archive_path"]),
+                    target_path=imported_file_path,
+                )
+                imported_path = str(imported_file_path.resolve())
+                availability = "local_copy"
+            material = {
+                **dict(raw_material),
+                "id": new_id,
+                "path": imported_path,
+                "imported_at": timestamp,
+                "updated_at": timestamp,
+                "origin_key": origin_key,
+                "origin_case_id": source_case_id,
+                "origin_material_id": source_material_id,
+                "exchange_id": exchange_id,
+                "availability": availability,
+            }
+            materials.append(material)
+            material_origins[origin_key] = material
+            material_id_map[source_material_id] = new_id
+            imported_materials += 1
+
+    included_lineage_files = {
+        (
+            str(item.get("record_type", "")),
+            str(item.get("record_id", "")),
+            int(item.get("artifact_index", -1)),
+        ): item
+        for item in update_payload.get("included_lineage_files", [])
+        if isinstance(item, Mapping)
+    }
+    extracted_lineage_paths: dict[str, Path] = {}
+
+    def extract_lineage_artifact(
+        archive: ZipFile,
+        included: Mapping[str, Any],
+    ) -> Path:
+        archive_path = str(included["archive_path"])
+        existing_path = extracted_lineage_paths.get(archive_path)
+        if existing_path is not None:
+            return existing_path
+        imported_path = (
+            case_dir
+            / "exchange_imports"
+            / exchange_id
+            / "lineage"
+            / "artifacts"
+            / Path(archive_path).name
+        )
+        _safe_extract_archive_file(
+            archive,
+            archive_path=archive_path,
+            target_path=imported_path,
+        )
+        extracted_lineage_paths[archive_path] = imported_path
+        return imported_path
+
+    evidence_origins = _lineage_origin_index(evidence)
+    evidence_id_map: dict[str, str] = {}
+    known_evidence_ids = {
+        str(item.get("id"))
+        for item in evidence
+        if isinstance(item, Mapping) and item.get("id")
+    }
+    raw_evidence = [
+        item
+        for item in update_payload.get("evidence_receipts", [])
+        if isinstance(item, Mapping)
+    ]
+    for raw_receipt in raw_evidence:
+        source_id = str(raw_receipt.get("id", ""))
+        existing = evidence_origins.get((source_case_id, source_id))
+        if existing is not None:
+            evidence_id_map[source_id] = str(existing["id"])
+            continue
+        evidence_id_map[source_id] = _mapped_lineage_id(
+            source_id,
+            source_case_id=source_case_id,
+            known_ids=known_evidence_ids,
+        )
+
+    with ZipFile(package_path) as archive:
+        for raw_receipt in raw_evidence:
+            source_id = str(raw_receipt.get("id", ""))
+            mapped_id = evidence_id_map[source_id]
+            receipt = json.loads(json.dumps(dict(raw_receipt)))
+            receipt["id"] = mapped_id
+            receipt["origin"] = {
+                "source_case_id": source_case_id,
+                "source_id": source_id,
+                "exchange_id": exchange_id,
+            }
+            source = receipt.get("source")
+            if not isinstance(source, dict):
+                raise CaseWorkspaceError(
+                    f"invalid imported evidence source: {source_id}"
+                )
+            source["material_ids"] = _remap_declared_ids(
+                source.get("material_ids", []),
+                material_id_map,
+                subject=f"evidence {source_id} material_ids",
+            )
+            for field in ("rechecks_evidence_id", "supersedes_evidence_id"):
+                source_reference = str(receipt.get(field, ""))
+                if source_reference:
+                    receipt[field] = _remap_declared_ids(
+                        [source_reference],
+                        evidence_id_map,
+                        subject=f"evidence {source_id} {field}",
+                    )[0]
+            existing = evidence_origins.get((source_case_id, source_id))
+            if existing is not None:
+                if _evidence_compare_fields(existing) != _evidence_compare_fields(
+                    receipt
+                ):
+                    raise CaseWorkspaceError(
+                        f"imported evidence changed immutable source record: {source_id}"
+                    )
+                skipped += 1
+                continue
+            artifact_path_map: dict[str, str] = {}
+            for artifact_index, artifact in enumerate(source.get("artifact_refs", [])):
+                if not isinstance(artifact, dict):
+                    continue
+                included = included_lineage_files.get(
+                    ("evidence", source_id, artifact_index)
+                )
+                if included is None:
+                    raise CaseWorkspaceError(
+                        f"case update omitted evidence artifact {source_id}[{artifact_index}]"
+                    )
+                imported_path = extract_lineage_artifact(archive, included)
+                old_path = str(artifact.get("path", ""))
+                new_path = imported_path.relative_to(case_dir).as_posix()
+                artifact_path_map[old_path] = new_path
+                artifact["path"] = new_path
+                artifact["path_reference"] = "case_relative"
+            calculation = receipt.get("calculation")
+            if isinstance(calculation, dict):
+                for field in (
+                    "input_artifact_paths",
+                    "output_artifact_paths",
+                    "verification_artifact_paths",
+                ):
+                    calculation[field] = [
+                        artifact_path_map.get(str(path), str(path))
+                        for path in calculation.get(field, [])
+                    ]
+            evidence.append(receipt)
+            evidence_origins[(source_case_id, source_id)] = receipt
+            imported_evidence += 1
+
+    claim_origins = _lineage_origin_index(claims)
+    claim_id_map: dict[str, str] = {}
+    known_claim_ids = {
+        str(item.get("id"))
+        for item in claims
+        if isinstance(item, Mapping) and item.get("id")
+    }
+    raw_claims = [
+        item for item in update_payload.get("claims", []) if isinstance(item, Mapping)
+    ]
+    for raw_claim in raw_claims:
+        source_id = str(raw_claim.get("id", ""))
+        existing = claim_origins.get((source_case_id, source_id))
+        if existing is not None:
+            claim_id_map[source_id] = str(existing["id"])
+            continue
+        claim_id_map[source_id] = _mapped_lineage_id(
+            source_id,
+            source_case_id=source_case_id,
+            known_ids=known_claim_ids,
+        )
+
+    with ZipFile(package_path) as archive:
+        for raw_claim in raw_claims:
+            source_id = str(raw_claim.get("id", ""))
+            claim = json.loads(json.dumps(dict(raw_claim)))
+            claim["id"] = claim_id_map[source_id]
+            claim["origin"] = {
+                "source_case_id": source_case_id,
+                "source_id": source_id,
+                "exchange_id": exchange_id,
+            }
+            for link in claim.get("evidence_links", []):
+                if isinstance(link, dict):
+                    link["evidence_id"] = _remap_declared_ids(
+                        [str(link["evidence_id"])],
+                        evidence_id_map,
+                        subject=f"claim {source_id} evidence_links",
+                    )[0]
+            dependency = claim.get("dependency")
+            if isinstance(dependency, dict):
+                dependency["claim_ids"] = _remap_declared_ids(
+                    dependency.get("claim_ids", []),
+                    claim_id_map,
+                    subject=f"claim {source_id} dependency claim_ids",
+                )
+                calculation_id = str(dependency.get("calculation_evidence_id", ""))
+                if calculation_id:
+                    dependency["calculation_evidence_id"] = _remap_declared_ids(
+                        [calculation_id],
+                        evidence_id_map,
+                        subject=(
+                            f"claim {source_id} dependency calculation_evidence_id"
+                        ),
+                    )[0]
+            supersedes = str(claim.get("supersedes_claim_id", ""))
+            if supersedes:
+                claim["supersedes_claim_id"] = _remap_declared_ids(
+                    [supersedes],
+                    claim_id_map,
+                    subject=f"claim {source_id} supersedes_claim_id",
+                )[0]
+            existing = claim_origins.get((source_case_id, source_id))
+            if existing is not None and _claim_compare_fields(
+                existing
+            ) != _claim_compare_fields(claim):
+                raise CaseWorkspaceError(
+                    f"imported claim changed immutable source record: {source_id}"
+                )
+            target_appearances = (
+                existing.get("appearances", [])
+                if isinstance(existing, dict)
+                else claim.get("appearances", [])
+            )
+            if not isinstance(target_appearances, list):
+                raise CaseWorkspaceError(
+                    f"imported claim appearances must be an array: {source_id}"
+                )
+            existing_appearance_ids = (
+                {
+                    _appearance_identity(item)
+                    for item in target_appearances
+                    if isinstance(item, dict)
+                }
+                if existing is not None
+                else set()
+            )
+            changed = False
+            for artifact_index, appearance in enumerate(claim.get("appearances", [])):
+                if not isinstance(appearance, dict):
+                    continue
+                appearance_id = _appearance_identity(appearance)
+                if appearance_id in existing_appearance_ids:
+                    continue
+                included = included_lineage_files.get(
+                    ("claim_appearance", source_id, artifact_index)
+                )
+                if included is None:
+                    raise CaseWorkspaceError(
+                        f"case update omitted claim appearance {source_id}[{artifact_index}]"
+                    )
+                imported_path = extract_lineage_artifact(archive, included)
+                appearance["artifact"] = imported_path.relative_to(case_dir).as_posix()
+                appearance["path_reference"] = "case_relative"
+                if existing is not None:
+                    target_appearances.append(appearance)
+                    existing_appearance_ids.add(appearance_id)
+                    changed = True
+            if existing is not None:
+                source_state = str(claim.get("state", ""))
+                target_state = str(existing.get("state", ""))
+                if target_state == "active" and source_state in {
+                    "superseded",
+                    "withdrawn",
+                }:
+                    existing["state"] = source_state
+                    changed = True
+                elif source_state != "active" and target_state != source_state:
+                    raise CaseWorkspaceError(
+                        f"imported claim has incompatible append-only state transition: {source_id}"
+                    )
+                if changed:
+                    updated_claims += 1
+                else:
+                    skipped += 1
+                continue
+            claims.append(claim)
+            claim_origins[(source_case_id, source_id)] = claim
+            imported_claims += 1
+
+    judgement_id_map: dict[str, str] = {}
+    for raw_entry in update_payload.get("judgement_entries", []):
+        if not isinstance(raw_entry, Mapping):
+            continue
+        origin_key = _record_origin_key(
+            raw_entry,
+            source_case_id=source_case_id,
+            record_type="judgement",
+        )
+        source_ids = _remap_declared_ids(
+            raw_entry.get("source_material_ids", []),
+            material_id_map,
+            subject=f"judgement {raw_entry.get('id')} source_material_ids",
+        )
+        source_claim_id = str(raw_entry.get("advisory_claim_id", ""))
+        mapped_claim_id = (
+            _remap_declared_ids(
+                [source_claim_id],
+                claim_id_map,
+                subject=f"judgement {raw_entry.get('id')} advisory_claim_id",
+            )[0]
+            if source_claim_id
+            else ""
+        )
+        mapped_receipt_ids = _remap_declared_ids(
+            raw_entry.get("evidence_receipt_ids", []),
+            evidence_id_map,
+            subject=f"judgement {raw_entry.get('id')} evidence_receipt_ids",
+        )
+        mapped_raw_entry = {
+            **dict(raw_entry),
+            "source_material_ids": source_ids,
+            "advisory_claim_id": mapped_claim_id,
+            "evidence_receipt_ids": mapped_receipt_ids,
+        }
+        existing = judgement_origins.get(origin_key)
+        if existing is not None:
+            judgement_id_map[str(raw_entry["id"])] = str(existing["id"])
+            if _judgement_compare_fields(existing) != _judgement_compare_fields(
+                mapped_raw_entry
+            ):
+                added_conflict = _append_conflict_question(
+                    questions,
+                    origin_key=origin_key,
+                    record_type="judgement",
+                    label=str(raw_entry.get("text", raw_entry["id"]))[:120],
+                    timestamp=timestamp,
+                )
+                conflicts += int(added_conflict)
+            else:
+                skipped += 1
+            continue
+
+        new_judgement_id = _next_id("jud", [item["id"] for item in entries])
+        entry = {
+            **mapped_raw_entry,
+            "id": new_judgement_id,
+            "imported_at": timestamp,
+            "origin_key": origin_key,
+            "origin_case_id": source_case_id,
+            "origin_judgement_id": str(raw_entry["id"]),
+            "exchange_id": exchange_id,
+        }
+        _validate_choice(str(entry["kind"]), JUDGEMENT_KINDS, "kind")
+        _validate_choice(str(entry["status"]), JUDGEMENT_STATUSES, "status")
+        entries.append(entry)
+        judgement_id_map[str(raw_entry["id"])] = new_judgement_id
+        judgement_origins[origin_key] = entry
+        imported_entries += 1
+
+    question_id_map: dict[str, str] = {}
+    for raw_question in update_payload.get("open_questions", []):
+        if not isinstance(raw_question, Mapping):
+            continue
+        origin_key = _record_origin_key(
+            raw_question,
+            source_case_id=source_case_id,
+            record_type="open_question",
+        )
+        mapped_source_entry_ids = _remap_declared_ids(
+            raw_question.get("source_entry_ids", []),
+            judgement_id_map,
+            subject=f"open question {raw_question.get('id')} source_entry_ids",
+        )
+        mapped_raw_question = {
+            **dict(raw_question),
+            "source_entry_ids": mapped_source_entry_ids,
+        }
+        existing = question_origins.get(origin_key)
+        if existing is not None:
+            question_id_map[str(raw_question["id"])] = str(existing["id"])
+            if _question_compare_fields(existing) != _question_compare_fields(
+                mapped_raw_question
+            ):
+                added_conflict = _append_conflict_question(
+                    questions,
+                    origin_key=origin_key,
+                    record_type="open question",
+                    label=str(raw_question.get("question", raw_question["id"]))[:120],
+                    timestamp=timestamp,
+                )
+                conflicts += int(added_conflict)
+            else:
+                skipped += 1
+            continue
+        new_question_id = _next_id("q", [item["id"] for item in questions])
+        question = {
+            **mapped_raw_question,
+            "id": new_question_id,
+            "imported_at": timestamp,
+            "updated_at": timestamp,
+            "origin_key": origin_key,
+            "origin_case_id": source_case_id,
+            "origin_question_id": str(raw_question["id"]),
+            "exchange_id": exchange_id,
+        }
+        _validate_choice(str(question["status"]), OPEN_QUESTION_STATUSES, "status")
+        questions.append(question)
+        question_id_map[str(raw_question["id"])] = new_question_id
+        question_origins[origin_key] = question
+        imported_questions += 1
+
+    for raw_issue in update_payload.get("case_issues", []):
+        if not isinstance(raw_issue, Mapping):
+            continue
+        origin_key = _record_origin_key(
+            raw_issue,
+            source_case_id=source_case_id,
+            record_type="case_issue",
+        )
+        mapped_issue = {
+            **dict(raw_issue),
+            "evidence_for": _remap_declared_ids(
+                raw_issue.get("evidence_for", []),
+                judgement_id_map,
+                subject=f"case issue {raw_issue.get('id')} evidence_for",
+            ),
+            "evidence_against": _remap_declared_ids(
+                raw_issue.get("evidence_against", []),
+                judgement_id_map,
+                subject=f"case issue {raw_issue.get('id')} evidence_against",
+            ),
+            "claim_ids_for": _remap_declared_ids(
+                raw_issue.get("claim_ids_for", []),
+                claim_id_map,
+                subject=f"case issue {raw_issue.get('id')} claim_ids_for",
+            ),
+            "claim_ids_against": _remap_declared_ids(
+                raw_issue.get("claim_ids_against", []),
+                claim_id_map,
+                subject=f"case issue {raw_issue.get('id')} claim_ids_against",
+            ),
+            "open_tests": _remap_declared_ids(
+                raw_issue.get("open_tests", []),
+                question_id_map,
+                subject=f"case issue {raw_issue.get('id')} open_tests",
+            ),
+        }
+        existing = issue_origins.get(origin_key)
+        if existing is not None:
+            if _issue_compare_fields(existing) != _issue_compare_fields(mapped_issue):
+                added_conflict = _append_conflict_question(
+                    questions,
+                    origin_key=origin_key,
+                    record_type="case issue",
+                    label=str(raw_issue.get("title", raw_issue["id"]))[:120],
+                    timestamp=timestamp,
+                )
+                conflicts += int(added_conflict)
+            else:
+                skipped += 1
+            continue
+        issue = {
+            **mapped_issue,
+            "id": _next_id("issue", [item["id"] for item in issues]),
+            "imported_at": timestamp,
+            "updated_at": timestamp,
+            "origin_key": origin_key,
+            "origin_case_id": source_case_id,
+            "origin_issue_id": str(raw_issue["id"]),
+            "exchange_id": exchange_id,
+        }
+        _validate_choice(str(issue["status"]), ISSUE_STATUSES, "status")
+        issues.append(issue)
+        issue_origins[origin_key] = issue
+        imported_issues += 1
+
+    lineage_audit = validate_lineage_payloads(
+        case_dir,
+        evidence_payload,
+        claims_payload,
+        known_material_ids_override={
+            str(item.get("id"))
+            for item in materials
+            if isinstance(item, Mapping) and item.get("id")
+        },
+    )
+    if not lineage_audit["valid"]:
+        raise CaseWorkspaceError(
+            "imported advisory lineage is invalid: "
+            + "; ".join(lineage_audit["errors"])
+        )
+
+    _write_json(materials_path, material_payload)
+    _write_json(judgement_path, judgement_payload)
+    _write_json(questions_path, questions_payload)
+    _write_json(issues_path, issues_payload)
+    _write_json(evidence_path, evidence_payload)
+    _write_json(claims_path, claims_payload)
+    render_evidence_map(case_dir)
+    _touch_manifest(case_dir, timestamp)
+    counts = {
+        "imported_materials": imported_materials,
+        "imported_judgement_entries": imported_entries,
+        "imported_open_questions": imported_questions,
+        "imported_case_issues": imported_issues,
+        "imported_evidence_receipts": imported_evidence,
+        "imported_claims": imported_claims,
+        "updated_claims": updated_claims,
+        "skipped": skipped,
+        "conflicts": conflicts,
+    }
+    _append_exchange_log(
+        case_dir,
+        exchange_id=exchange_id,
+        source_case_id=source_case_id,
+        package_path=source_package_path or package_path,
+        timestamp=timestamp,
+        counts=counts,
+    )
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+    refresh_case_brief(case_dir, now=now)
+
+    return CaseExchangeImportResult(
+        exchange_id=exchange_id,
+        imported_material_count=imported_materials,
+        imported_judgement_count=imported_entries,
+        imported_open_question_count=imported_questions,
+        skipped_count=skipped,
+        conflict_count=conflicts,
+        imported_evidence_count=imported_evidence,
+        imported_claim_count=imported_claims,
+        imported_issue_count=imported_issues,
+        updated_claim_count=updated_claims,
+    )
+
+
+@case_operation
+def import_case_update(
+    case_dir: Path,
+    package_path: Path,
+    *,
+    now: datetime | None = None,
+) -> CaseExchangeImportResult:
+    """Import a case update atomically across JSON records and extracted files."""
+
+    # Copy once so replacing the caller's ZIP cannot change bytes after preflight.
+    with tempfile.TemporaryDirectory(prefix="clara-exchange-") as temporary_dir:
+        stable_path = Path(temporary_dir) / "case-update.zip"
+        with package_path.open("rb") as source, stable_path.open("xb") as destination:
+            total = 0
+            while block := source.read(1024 * 1024):
+                total += len(block)
+                if total > 1024 * 1024 * 1024:
+                    raise CaseWorkspaceError("case exchange exceeds archive size limit")
+                destination.write(block)
+        return _import_stable_case_update(
+            case_dir, stable_path, source_package_path=package_path, now=now
+        )
+
+
+def _import_stable_case_update(
+    case_dir: Path,
+    package_path: Path,
+    *,
+    source_package_path: Path,
+    now: datetime | None = None,
+) -> CaseExchangeImportResult:
+    update_payload = _load_case_update(package_path)
+    try:
+        exchange_root = validate_destinations(case_dir, update_payload)
+    except ValueError as exc:
+        raise CaseWorkspaceError(str(exc)) from exc
+    exchange_root_existed = exchange_root.exists()
+    mutation_paths = [
+        *(_case_path(case_dir, key) for key in CASE_FILES),
+        case_dir / EVIDENCE_REGISTER_FILENAME,
+        case_dir / CLAIM_REGISTER_FILENAME,
+        case_dir / "advisory_evidence_map.md",
+        case_dir / "exchange_log.json",
+        case_dir / CASE_BRIEF_FILENAME,
+    ]
+    snapshot = _snapshot_files(mutation_paths)
+    completed = False
+    try:
+        result = _import_case_update_unprotected(
+            case_dir,
+            package_path,
+            source_package_path=source_package_path,
+            now=now,
+        )
+        completed = True
+        return result
+    finally:
+        if not completed:
+            _restore_files(snapshot)
+            if not exchange_root_existed and exchange_root.exists():
+                shutil.rmtree(exchange_root)
+
+
+def _entry_source_suffix(
+    entry: Mapping[str, Any],
+    material_labels: Mapping[str, str],
+    *,
+    source_label: str = "Sources",
+) -> str:
+    source_ids = entry.get("source_material_ids", [])
+    labels = [
+        material_labels[source_id]
+        for source_id in source_ids
+        if source_id in material_labels
+    ]
+    if labels:
+        return f" {source_label}: {', '.join(labels)}."
+    return ""
+
+
+def _brief_entry_line(
+    entry: Mapping[str, Any],
+    material_labels: Mapping[str, str],
+    *,
+    include_kind: bool = False,
+    source_label: str = "Sources",
+    kind_labels: Mapping[str, str] | None = None,
+) -> str:
+    prefix = ""
+    if include_kind:
+        kind = str(entry["kind"])
+        kind_label = (kind_labels or {}).get(kind, kind.replace("_", " "))
+        prefix += f"[{kind_label}] "
+    return (
+        f"- {prefix}{str(entry['text']).strip()}"
+        f"{_entry_source_suffix(entry, material_labels, source_label=source_label)}"
+    )
+
+
+def _brief_lines_for_entries(
+    entries: Sequence[Mapping[str, Any]],
+    material_labels: Mapping[str, str],
+    *,
+    empty_text: str,
+    include_kind: bool = False,
+    source_label: str = "Sources",
+    kind_labels: Mapping[str, str] | None = None,
+) -> list[str]:
+    if not entries:
+        return [f"- {empty_text}"]
+    return [
+        _brief_entry_line(
+            entry,
+            material_labels,
+            include_kind=include_kind,
+            source_label=source_label,
+            kind_labels=kind_labels,
+        )
+        for entry in entries
+    ]
+
+
+def _brief_material_lines(
+    materials: Sequence[Mapping[str, Any]],
+    *,
+    no_materials: str = "No materials indexed.",
+) -> list[str]:
+    if not materials:
+        return [f"- {no_materials}"]
+    lines = []
+    for item in materials:
+        summary = str(item.get("summary", "")).strip()
+        summary_suffix = f" - {summary}" if summary else ""
+        lines.append(
+            f"- {item['title']} [{item['material_type']}, {item['status']}]"
+            f"{summary_suffix}"
+        )
+    return lines
+
+
+def _brief_question_lines(
+    questions: Sequence[Mapping[str, Any]],
+    *,
+    no_questions: str = "No open questions registered.",
+    why_label: str = "Why it matters",
+) -> list[str]:
+    open_items = [item for item in questions if item.get("status") == "open"]
+    if not open_items:
+        return [f"- {no_questions}"]
+    return [
+        f"- {item['question']} {why_label}: {item['why_it_matters']}"
+        for item in open_items
+    ]
+
+
+def _brief_issue_lines(
+    issues: Sequence[Mapping[str, Any]],
+    *,
+    no_issues: str = "No active case issues registered.",
+    evidence_label: str = "Evidence links",
+    supporting_label: str = "supporting",
+    opposing_label: str = "opposing",
+    open_test_label: str = "open test",
+) -> list[str]:
+    active_issues = [item for item in issues if item.get("status") != "resolved"]
+    if not active_issues:
+        return [f"- {no_issues}"]
+    lines: list[str] = []
+    for issue in active_issues:
+        synthesis = str(issue.get("current_synthesis", "")).strip()
+        synthesis_suffix = f" - {synthesis}" if synthesis else ""
+        lines.append(
+            f"- {issue['title']} [{issue['status']}, "
+            f"{issue.get('decision_area', '')}]{synthesis_suffix}"
+        )
+        evidence_for = len(issue.get("evidence_for", []))
+        evidence_against = len(issue.get("evidence_against", []))
+        open_tests = len(issue.get("open_tests", []))
+        lines.append(
+            f"  {evidence_label}: {evidence_for} {supporting_label}, "
+            f"{evidence_against} {opposing_label}, {open_tests} {open_test_label}."
+        )
+    return lines
+
+
+def _case_brief_copy(manifest: Mapping[str, Any]) -> dict[str, Any]:
+    if _ui_language(manifest) == "es":
+        return {
+            "title": "Resumen del caso",
+            "derived": (
+                "Resumen de trabajo derivado. La fuente de referencia sigue siendo "
+                "el conjunto de archivos JSON del caso."
+            ),
+            "pending_gate": (
+                "Los elementos pendientes sirven únicamente para revisión y no "
+                "pueden alimentar el paquete de decisión del cliente hasta que se "
+                "marquen como listos para dicho paquete."
+            ),
+            "generated": "Generado",
+            "updated": "Caso actualizado",
+            "snapshot": "Resumen del caso",
+            "project": "Proyecto",
+            "objective": "Objetivo",
+            "audience": "Destinatario",
+            "status": "Estado",
+            "output_language": "Idioma de salida",
+            "materials_indexed": "Materiales indexados",
+            "approved_count": "Elementos de juicio listos para el paquete de decisión",
+            "pending_count": "Elementos de juicio pendientes",
+            "rejected_count": "Elementos de juicio rechazados",
+            "active_issues_count": "Cuestiones activas del caso",
+            "current": "Comprensión actual (lista para el paquete de decisión)",
+            "facts": "Hechos",
+            "advisor": "Juicio consultivo",
+            "inferences": "Inferencias de Codex",
+            "decisions": "Implicaciones para la decisión",
+            "no_facts": "Aún no hay hechos listos para el paquete de decisión.",
+            "no_advisor": (
+                "Aún no hay juicios consultivos listos para el paquete de decisión."
+            ),
+            "no_inferences": (
+                "Aún no hay inferencias de Codex listas para el paquete de decisión."
+            ),
+            "no_decisions": (
+                "Aún no hay implicaciones listas para el paquete de decisión."
+            ),
+            "candidate_review": (
+                "Revisión de candidatos (no listos para el paquete de decisión)"
+            ),
+            "candidate_note": (
+                "Estos elementos se han registrado para su revisión. No constituyen "
+                "asesoramiento final."
+            ),
+            "no_pending": "No hay elementos de juicio pendientes.",
+            "questions": "Preguntas abiertas",
+            "no_questions": "No se han registrado preguntas abiertas.",
+            "why": "Por qué es importante",
+            "issues": "Cuestiones del caso",
+            "no_issues": "No se han registrado cuestiones activas del caso.",
+            "evidence": "Vínculos de evidencia",
+            "supporting": "a favor",
+            "opposing": "en contra",
+            "open_test": "prueba abierta",
+            "mandate": "Mandato de Clara",
+            "current_understanding": "Comprensión actual",
+            "partner_orientation": "Orientación del socio",
+            "not_recorded": "Aún no registrado.",
+            "clarifications": "Aclaraciones imprescindibles",
+            "no_clarifications": "Aún no se han registrado aclaraciones de Clara.",
+            "next_steps": "Próximos pasos de Clara",
+            "no_next_steps": "Aún no se han registrado próximos pasos de Clara.",
+            "materials": "Materiales",
+            "no_materials": "No hay materiales indexados.",
+            "control": "Notas de control",
+            "control_brief": (
+                "`case_brief.md` se deriva de `case_manifest.json`, "
+                "`material_registry.json`, `judgement_log.json`, "
+                "`open_questions.json`, `case_issues.json` y `clara_mandate.json`."
+            ),
+            "control_pack": (
+                "`decision_pack.md` y `decision_pack.docx` utilizan únicamente "
+                "juicios listos para el paquete de decisión."
+            ),
+            "control_rebuild": (
+                "Vuelve a generar este resumen con `scripts/build_case_brief.py` si "
+                "se han realizado cambios externos en los archivos JSON."
+            ),
+            "sources": "Fuentes",
+            "kind_labels": {
+                "fact": "hecho",
+                "advisor_judgement": "juicio consultivo",
+                "codex_inference": "inferencia de Codex",
+                "decision_implication": "implicación para la decisión",
+            },
+        }
+    return {
+        "title": "Case Brief",
+        "derived": "Derived working brief. The source of truth remains the JSON case files.",
+        "pending_gate": (
+            "Pending items are review material only and cannot feed the client "
+            "decision pack until marked decision-pack ready."
+        ),
+        "generated": "Generated",
+        "updated": "Case updated",
+        "snapshot": "Case Snapshot",
+        "project": "Project",
+        "objective": "Objective",
+        "audience": "Audience",
+        "status": "Status",
+        "output_language": "Output language",
+        "materials_indexed": "Materials indexed",
+        "approved_count": "Decision-pack-ready judgement entries",
+        "pending_count": "Pending judgement entries",
+        "rejected_count": "Rejected judgement entries",
+        "active_issues_count": "Active case issues",
+        "current": "Current Understanding (decision-pack ready)",
+        "facts": "Facts",
+        "advisor": "Consultant Judgement",
+        "inferences": "Codex Inferences",
+        "decisions": "Decision Implications",
+        "no_facts": "No decision-pack-ready facts yet.",
+        "no_advisor": "No decision-pack-ready consultant judgement yet.",
+        "no_inferences": "No decision-pack-ready Codex inferences yet.",
+        "no_decisions": "No decision-pack-ready decision implications yet.",
+        "candidate_review": "Candidate Review (not decision-pack ready)",
+        "candidate_note": "These items are captured for review. They are not final advice.",
+        "no_pending": "No pending judgement entries.",
+        "questions": "Open Questions",
+        "no_questions": "No open questions registered.",
+        "why": "Why it matters",
+        "issues": "Case Issues",
+        "no_issues": "No active case issues registered.",
+        "evidence": "Evidence links",
+        "supporting": "supporting",
+        "opposing": "opposing",
+        "open_test": "open test",
+        "mandate": "Clara Mandate",
+        "current_understanding": "Current understanding",
+        "partner_orientation": "Partner orientation",
+        "not_recorded": "Not recorded yet.",
+        "clarifications": "Essential Clarifications",
+        "no_clarifications": "No Clara clarifications recorded yet.",
+        "next_steps": "Clara Next Steps",
+        "no_next_steps": "No Clara next steps recorded yet.",
+        "materials": "Materials",
+        "no_materials": "No materials indexed.",
+        "control": "Control Notes",
+        "control_brief": (
+            "`case_brief.md` is derived from `case_manifest.json`, "
+            "`material_registry.json`, `judgement_log.json`, "
+            "`open_questions.json`, `case_issues.json`, and `clara_mandate.json`."
+        ),
+        "control_pack": (
+            "`decision_pack.md` and `decision_pack.docx` use decision-pack-ready "
+            "judgement only."
+        ),
+        "control_rebuild": (
+            "Rebuild this brief with `scripts/build_case_brief.py` if external "
+            "edits were made to the JSON files."
+        ),
+        "sources": "Sources",
+        "kind_labels": {},
+    }
+
+
+def _render_case_brief(
+    *,
+    manifest: Mapping[str, Any],
+    materials: Sequence[Mapping[str, Any]],
+    entries: Sequence[Mapping[str, Any]],
+    open_questions: Sequence[Mapping[str, Any]],
+    issues: Sequence[Mapping[str, Any]],
+    clara_mandate: Mapping[str, Any],
+    generated_at: str,
+) -> str:
+    copy = _case_brief_copy(manifest)
+    grouped = _group_approved_entries(entries)
+    material_labels = _material_label_by_id(materials)
+    pending_entries = [entry for entry in entries if entry["status"] == "pending"]
+    rejected_count = sum(1 for entry in entries if entry["status"] == "rejected")
+    approved_count = sum(1 for entry in entries if entry["status"] == "approved")
+    mandate_body = clara_mandate.get("mandate", {})
+    mandate_status = str(clara_mandate.get("status", "not_started"))
+    clarification_lines = [
+        f"- {item}"
+        for item in _clean_string_list(mandate_body.get("essential_clarifications", []))
+    ] or [f"- {copy['no_clarifications']}"]
+    next_step_lines = [
+        f"- {item}" for item in _clean_string_list(mandate_body.get("next_steps", []))
+    ] or [f"- {copy['no_next_steps']}"]
+
+    lines = [
+        f"# {copy['title']} - {manifest['client']}",
+        "",
+        copy["derived"],
+        copy["pending_gate"],
+        "",
+        f"{copy['generated']}: {generated_at}",
+        f"{copy['updated']}: {manifest.get('updated_at', '')}",
+        "",
+        f"## {copy['snapshot']}",
+        "",
+        f"- {copy['project']}: {manifest['project']}",
+        f"- {copy['objective']}: {manifest['objective']}",
+        f"- {copy['audience']}: {manifest['audience']}",
+        f"- {copy['status']}: {manifest['status']}",
+        f"- {copy['output_language']}: {manifest['output_language']}",
+        f"- {copy['materials_indexed']}: {len(materials)}",
+        f"- {copy['approved_count']}: {approved_count}",
+        f"- {copy['pending_count']}: {len(pending_entries)}",
+        f"- {copy['rejected_count']}: {rejected_count}",
+        f"- {copy['active_issues_count']}: {sum(1 for issue in issues if issue.get('status') == 'active')}",
+        "",
+        f"## {copy['current']}",
+        "",
+        f"### {copy['facts']}",
+        "",
+        *_brief_lines_for_entries(
+            grouped["fact"],
+            material_labels,
+            empty_text=copy["no_facts"],
+            source_label=copy["sources"],
+        ),
+        "",
+        f"### {copy['advisor']}",
+        "",
+        *_brief_lines_for_entries(
+            grouped["advisor_judgement"],
+            material_labels,
+            empty_text=copy["no_advisor"],
+            source_label=copy["sources"],
+        ),
+        "",
+        f"### {copy['inferences']}",
+        "",
+        *_brief_lines_for_entries(
+            grouped["codex_inference"],
+            material_labels,
+            empty_text=copy["no_inferences"],
+            source_label=copy["sources"],
+        ),
+        "",
+        f"### {copy['decisions']}",
+        "",
+        *_brief_lines_for_entries(
+            grouped["decision_implication"],
+            material_labels,
+            empty_text=copy["no_decisions"],
+            source_label=copy["sources"],
+        ),
+        "",
+        f"## {copy['candidate_review']}",
+        "",
+        copy["candidate_note"],
+        "",
+        *_brief_lines_for_entries(
+            pending_entries,
+            material_labels,
+            empty_text=copy["no_pending"],
+            include_kind=True,
+            source_label=copy["sources"],
+            kind_labels=copy["kind_labels"],
+        ),
+        "",
+        f"## {copy['questions']}",
+        "",
+        *_brief_question_lines(
+            open_questions,
+            no_questions=copy["no_questions"],
+            why_label=copy["why"],
+        ),
+        "",
+        f"## {copy['issues']}",
+        "",
+        *_brief_issue_lines(
+            issues,
+            no_issues=copy["no_issues"],
+            evidence_label=copy["evidence"],
+            supporting_label=copy["supporting"],
+            opposing_label=copy["opposing"],
+            open_test_label=copy["open_test"],
+        ),
+        "",
+        f"## {copy['mandate']}",
+        "",
+        f"- {copy['status']}: {mandate_status}",
+        f"- {copy['current_understanding']}: {str(mandate_body.get('clara_understanding', '')).strip() or copy['not_recorded']}",
+        f"- {copy['partner_orientation']}: {str(mandate_body.get('partner_starting_orientation', '')).strip() or copy['not_recorded']}",
+        "",
+        f"### {copy['clarifications']}",
+        "",
+        *clarification_lines,
+        "",
+        f"### {copy['next_steps']}",
+        "",
+        *next_step_lines,
+        "",
+        f"## {copy['materials']}",
+        "",
+        *_brief_material_lines(materials, no_materials=copy["no_materials"]),
+        "",
+        f"## {copy['control']}",
+        "",
+        f"- {copy['control_brief']}",
+        f"- {copy['control_pack']}",
+        f"- {copy['control_rebuild']}",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+@case_operation
+def refresh_case_brief(
+    case_dir: Path,
+    *,
+    now: datetime | None = None,
+) -> CaseBriefResult:
+    """Deterministically rebuild the readable brief from canonical case JSON.
+
+    The brief is a convenience view, not a semantic source of truth. It uses
+    fixed formatting so inclusion counts and pending gates remain auditable.
+    """
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+
+    generated_at = _now_iso(now)
+    manifest = _read_json(_case_path(case_dir, "manifest"))
+    materials = _read_json(_case_path(case_dir, "materials"))["materials"]
+    entries = _read_json(_case_path(case_dir, "judgement"))["entries"]
+    questions = _read_json(_case_path(case_dir, "open_questions"))["questions"]
+    issues = _read_json(_case_path(case_dir, "issues"))["issues"]
+    clara_mandate = _read_json(_case_path(case_dir, "clara_mandate"))
+    brief_path = case_dir / CASE_BRIEF_FILENAME
+    brief_text = _render_case_brief(
+        manifest=manifest,
+        materials=materials,
+        entries=entries,
+        open_questions=questions,
+        issues=issues,
+        clara_mandate=clara_mandate,
+        generated_at=generated_at,
+    )
+    atomic_text(brief_path, brief_text, encoding="utf-8")
+
+    return CaseBriefResult(
+        brief_path=brief_path,
+        approved_count=sum(1 for entry in entries if entry["status"] == "approved"),
+        pending_count=sum(1 for entry in entries if entry["status"] == "pending"),
+        rejected_count=sum(1 for entry in entries if entry["status"] == "rejected"),
+        open_question_count=sum(
+            1 for question in questions if question["status"] == "open"
+        ),
+        issue_count=sum(1 for issue in issues if issue["status"] == "active"),
+    )
+
+
+def _review_status_entries(
+    entries: Sequence[Mapping[str, Any]],
+    status: str,
+) -> list[Mapping[str, Any]]:
+    return [entry for entry in entries if entry["status"] == status]
+
+
+def _review_source_text(
+    entry: Mapping[str, Any],
+    material_labels: Mapping[str, str],
+) -> str:
+    source_ids = entry.get("source_material_ids", [])
+    labels = [
+        material_labels.get(str(source_id), str(source_id))
+        for source_id in source_ids
+        if str(source_id).strip()
+    ]
+    if not labels:
+        return "None recorded"
+    return ", ".join(labels)
+
+
+def _slugify_bundle_id(value: str, *, fallback: str) -> str:
+    slug = re.sub(r"[^a-zA-Z0-9]+", "-", value.strip().lower()).strip("-")
+    return slug or fallback
+
+
+def _inclusion_bundles_path(case_dir: Path) -> Path:
+    return case_dir / INCLUSION_BUNDLES_FILENAME
+
+
+def _read_inclusion_bundles(case_dir: Path) -> list[dict[str, Any]]:
+    path = _inclusion_bundles_path(case_dir)
+    if not path.exists():
+        return []
+    payload = _read_json(path)
+    if payload.get("schema_version") != SCHEMA_VERSION:
+        raise CaseWorkspaceError(
+            f"{INCLUSION_BUNDLES_FILENAME}: unsupported schema_version"
+        )
+    bundles = payload.get("bundles")
+    if not isinstance(bundles, list):
+        raise CaseWorkspaceError(
+            f"{INCLUSION_BUNDLES_FILENAME}: bundles must be a list"
+        )
+    return [bundle for bundle in bundles if isinstance(bundle, dict)]
+
+
+@case_operation
+def apply_inclusion_bundles(
+    case_dir: Path,
+    bundles: Sequence[Mapping[str, Any]],
+    *,
+    now: datetime | None = None,
+) -> InclusionBundleApplyResult:
+    """Persist semantic inclusion-review bundles supplied by Codex/Clara.
+
+    Bundle themes are semantic judgement, so this helper does not infer them.
+    It only validates entry IDs, de-duplicates mechanical identifiers, and writes
+    the review plan that later approval commands can apply audibly.
+    """
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+    judgement = _read_json(_case_path(case_dir, "judgement"))
+    known_entries = {
+        str(entry["id"]): entry
+        for entry in judgement.get("entries", [])
+        if entry.get("id")
+    }
+    cleaned_bundles: list[dict[str, Any]] = []
+    used_bundle_ids: set[str] = set()
+    used_entry_ids: dict[str, str] = {}
+
+    for index, raw_bundle in enumerate(bundles, start=1):
+        title = str(raw_bundle.get("title", "")).strip()
+        if not title:
+            raise CaseWorkspaceError(f"inclusion bundle {index}: title is required")
+        bundle_id = _slugify_bundle_id(
+            str(raw_bundle.get("id", "")).strip() or title,
+            fallback=f"bundle-{index}",
+        )
+        if bundle_id in used_bundle_ids:
+            raise CaseWorkspaceError(f"inclusion bundle id is duplicated: {bundle_id}")
+        used_bundle_ids.add(bundle_id)
+        entry_ids = _dedupe_preserve_order(
+            str(value).strip() for value in raw_bundle.get("entry_ids", [])
+        )
+        if not entry_ids:
+            raise CaseWorkspaceError(
+                f"inclusion bundle {title!r}: at least one entry_id is required"
+            )
+        missing_ids = [
+            entry_id for entry_id in entry_ids if entry_id not in known_entries
+        ]
+        if missing_ids:
+            raise CaseWorkspaceError(
+                f"inclusion bundle {title!r}: unknown entry_ids "
+                + ", ".join(missing_ids)
+            )
+        duplicate_entries = [
+            entry_id for entry_id in entry_ids if entry_id in used_entry_ids
+        ]
+        if duplicate_entries:
+            duplicate_text = ", ".join(
+                f"{entry_id} already in {used_entry_ids[entry_id]}"
+                for entry_id in duplicate_entries
+            )
+            raise CaseWorkspaceError(
+                f"inclusion bundle {title!r}: duplicate entry assignment: "
+                + duplicate_text
+            )
+        for entry_id in entry_ids:
+            used_entry_ids[entry_id] = bundle_id
+        cleaned_bundles.append(
+            {
+                "id": bundle_id,
+                "title": title,
+                "description": str(raw_bundle.get("description", "")).strip(),
+                "entry_ids": entry_ids,
+            }
+        )
+
+    timestamp = _now_iso(now)
+    payload = {
+        "schema_version": SCHEMA_VERSION,
+        "updated_at": timestamp,
+        "bundles": cleaned_bundles,
+    }
+    bundles_path = _inclusion_bundles_path(case_dir)
+    _write_json(bundles_path, payload)
+    _touch_manifest(case_dir, timestamp)
+    return InclusionBundleApplyResult(
+        bundles_path=bundles_path,
+        bundle_count=len(cleaned_bundles),
+        bundled_entry_count=sum(len(bundle["entry_ids"]) for bundle in cleaned_bundles),
+    )
+
+
+def _pending_inclusion_bundle_groups(
+    case_dir: Path,
+    pending_entries: Sequence[Mapping[str, Any]],
+) -> list[dict[str, Any]]:
+    pending_by_id = {str(entry["id"]): entry for entry in pending_entries}
+    groups: list[dict[str, Any]] = []
+    for bundle in _read_inclusion_bundles(case_dir):
+        entry_ids = [
+            str(entry_id)
+            for entry_id in bundle.get("entry_ids", [])
+            if str(entry_id) in pending_by_id
+        ]
+        if not entry_ids:
+            continue
+        groups.append(
+            {
+                "id": str(bundle.get("id", "")).strip(),
+                "title": str(bundle.get("title", "")).strip(),
+                "description": str(bundle.get("description", "")).strip(),
+                "entries": [pending_by_id[entry_id] for entry_id in entry_ids],
+            }
+        )
+    return groups
+
+
+def _compact_review_text(value: str, *, limit: int = 150) -> str:
+    text = re.sub(r"\s+", " ", value).strip()
+    if len(text) <= limit:
+        return text
+    return f"{text[:limit].rstrip()}..."
+
+
+def _inclusion_bundle_lines(
+    groups: Sequence[Mapping[str, Any]],
+    pending_item_numbers: Mapping[str, int],
+    *,
+    copy: Mapping[str, str],
+) -> list[str]:
+    if not groups:
+        return [copy["no_bundles"], ""]
+
+    lines: list[str] = []
+    for index, group in enumerate(groups, start=1):
+        entries = [
+            entry
+            for entry in group.get("entries", [])
+            if isinstance(entry, Mapping)
+            and str(entry.get("id", "")) in pending_item_numbers
+        ]
+        item_numbers = [
+            str(pending_item_numbers[str(entry["id"])]) for entry in entries
+        ]
+        lines.extend(
+            [
+                f"### {copy['bundle']} {index}: {group['title']}",
+                "",
+                f"- {copy['bundle_items']}: {', '.join(item_numbers)}",
+            ]
+        )
+        description = str(group.get("description", "")).strip()
+        if description:
+            lines.append(f"- {copy['bundle_description']}: {description}")
+        lines.append(
+            f"- {copy['bundle_action'].format(index=index, bundle_id=group['id'])}"
+        )
+        for entry in entries:
+            item_number = pending_item_numbers[str(entry["id"])]
+            kind_label = str(entry["kind"]).replace("_", " ")
+            lines.append(
+                f"  - {copy['item']} {item_number} [{kind_label}]: "
+                f"{_compact_review_text(str(entry['text']))}"
+            )
+        lines.append("")
+    return lines
+
+
+def _inclusion_entry_lines(
+    entries: Sequence[Mapping[str, Any]],
+    material_labels: Mapping[str, str],
+    *,
+    include_actions: bool,
+    copy: Mapping[str, str],
+) -> list[str]:
+    if not entries:
+        return [copy["no_entries"], ""]
+
+    lines: list[str] = []
+    for index, entry in enumerate(entries, start=1):
+        kind_label = str(entry["kind"]).replace("_", " ")
+        lines.extend(
+            [
+                f"### {index}. {kind_label}",
+                "",
+                str(entry["text"]).strip(),
+                "",
+                f"- {copy['sources']}: {_review_source_text(entry, material_labels)}",
+            ]
+        )
+        rationale = str(entry.get("rationale", "")).strip()
+        if rationale:
+            lines.append(f"- {copy['rationale']}: {rationale}")
+        reviewer = str(entry.get("reviewer", "") or "").strip()
+        if reviewer:
+            lines.append(f"- {copy['recorded_by']}: {reviewer}")
+        review_note = str(entry.get("review_note", "") or "").strip()
+        if review_note:
+            lines.append(f"- {copy['review_note']}: {review_note}")
+        if include_actions:
+            lines.append(f"- {copy['entry_action'].format(index=index)}")
+        lines.append("")
+    return lines
+
+
+def _inclusion_review_copy(language: str) -> dict[str, str]:
+    if language == "it":
+        return {
+            "already_approved": "Voci gia' pronte per il pack cliente",
+            "already_approved_count": "Voci gia' pronte per il pack cliente",
+            "ask_evidence": "Chiedi evidenza",
+            "bundle": "Pacchetto",
+            "bundle_action": (
+                "Risposta: includi pacchetto {index}, escludi pacchetto {index}, "
+                "oppure mostrami evidenza sul pacchetto {index}. ID: `{bundle_id}`."
+            ),
+            "bundle_description": "Nota",
+            "bundle_items": "Voci",
+            "bundles": "Pacchetti pending",
+            "bundles_count": "Pacchetti pending disponibili",
+            "control_heading": "Note di controllo",
+            "control_pending": (
+                "Le voci pending e rejected non devono alimentare "
+                "`decision_pack.md` o `decision_pack.docx`."
+            ),
+            "control_regenerated": (
+                "Questo file deriva dai JSON canonici del caso e puo' essere rigenerato."
+            ),
+            "create_bundles": (
+                "Per revisioni lunghe, Clara/Codex puo' creare "
+                "`inclusion_bundles.json` con pacchetti tematici e rigenerare "
+                "questa checklist."
+            ),
+            "correct_one": "Correggi una voce",
+            "correct_one_example": "correggi voce 9: ...",
+            "excluded": "Voci escluse",
+            "excluded_count": "Voci gia' escluse dal pack cliente",
+            "exclude_one": "Escludi una voce",
+            "exclude_one_example": "escludi voce 7",
+            "entry_action": (
+                "Risposta: includi voce {index}, escludi voce {index}, "
+                "correggi voce {index}, oppure mostrami evidenza sulla voce {index}."
+            ),
+            "generated": "Generato",
+            "how_to_respond": "Come rispondere",
+            "include_all": "Includi tutto",
+            "include_all_example": "includi tutte le voci pending",
+            "include_bundle": "Includi un pacchetto",
+            "include_bundle_example": "includi pacchetto 1",
+            "include_one": "Includi una voce",
+            "include_one_example": "includi voce 4",
+            "intro": (
+                "Checklist di lavoro per decidere quali voci strutturate del caso "
+                "sono pronte per il pack cliente."
+            ),
+            "intro_gate": (
+                "Questo file non cambia lo stato delle voci. Il partner indica "
+                "cosa includere, escludere, correggere o approfondire; la "
+                "decisione viene registrata meccanicamente dopo conferma."
+            ),
+            "no_entries": "Nessuna voce in questo stato.",
+            "no_bundles": "Nessun pacchetto tematico configurato.",
+            "pending": "Voci pending",
+            "pending_count": "Voci pending che richiedono decisione del partner",
+            "item": "Voce",
+            "project": "Progetto",
+            "audience": "Destinatario",
+            "rationale": "Motivo",
+            "recorded_by": "Registrato da",
+            "review_note": "Nota di revisione",
+            "show_more_example": "mostrami evidenza sulla voce 3",
+            "sources": "Fonti",
+            "status_counts": "Conteggi",
+            "title": "Revisione inclusione",
+        }
+    if language == "es":
+        return {
+            "already_approved": "Elementos ya listos para el paquete del cliente",
+            "already_approved_count": (
+                "Elementos ya marcados como listos para el paquete del cliente"
+            ),
+            "ask_evidence": "Pedir evidencia",
+            "bundle": "Paquete",
+            "bundle_action": (
+                "Respuesta: incluye el paquete {index}, excluye el paquete {index} "
+                "o muestra más sobre el paquete {index}. ID: `{bundle_id}`."
+            ),
+            "bundle_description": "Nota",
+            "bundle_items": "Elementos",
+            "bundles": "Paquetes pendientes",
+            "bundles_count": "Paquetes pendientes disponibles",
+            "control_heading": "Notas de control",
+            "control_pending": (
+                "Los elementos pendientes y rechazados no deben alimentar "
+                "`decision_pack.md` ni `decision_pack.docx`."
+            ),
+            "control_regenerated": (
+                "Este archivo deriva de los JSON canónicos del caso y puede "
+                "regenerarse de forma segura."
+            ),
+            "create_bundles": (
+                "Para revisiones largas, Clara/Codex puede crear "
+                "`inclusion_bundles.json` con paquetes temáticos y regenerar "
+                "esta lista."
+            ),
+            "correct_one": "Corregir un elemento",
+            "correct_one_example": "corrige el elemento 9: ...",
+            "excluded": "Elementos excluidos",
+            "excluded_count": "Elementos ya excluidos del paquete del cliente",
+            "exclude_one": "Excluir un elemento",
+            "exclude_one_example": "excluye el elemento 7",
+            "entry_action": (
+                "Respuesta: incluye el elemento {index}, excluye el elemento "
+                "{index}, corrige el elemento {index} o muestra más sobre el "
+                "elemento {index}."
+            ),
+            "generated": "Generado",
+            "how_to_respond": "Cómo responder",
+            "include_all": "Incluir todo",
+            "include_all_example": "incluye todos los elementos pendientes",
+            "include_bundle": "Incluir un paquete",
+            "include_bundle_example": "incluye el paquete 1",
+            "include_one": "Incluir un elemento",
+            "include_one_example": "incluye el elemento 4",
+            "intro": (
+                "Lista de trabajo para decidir qué elementos estructurados del "
+                "caso están listos para el paquete del cliente."
+            ),
+            "intro_gate": (
+                "Este documento no cambia el estado de los juicios. Indica qué "
+                "elementos incluir, excluir, corregir o ampliar; la decisión se "
+                "registra de forma mecánica tras la confirmación."
+            ),
+            "no_entries": "No hay elementos en este estado.",
+            "no_bundles": "No hay paquetes temáticos configurados.",
+            "pending": "Elementos pendientes",
+            "pending_count": "Elementos pendientes que requieren decisión del socio",
+            "item": "Elemento",
+            "project": "Proyecto",
+            "audience": "Destinatario",
+            "rationale": "Motivo",
+            "recorded_by": "Registrado por",
+            "review_note": "Nota de revisión",
+            "show_more_example": "muestra más sobre el elemento 3",
+            "sources": "Fuentes",
+            "status_counts": "Recuento por estado",
+            "title": "Revisión de inclusión",
+        }
+    return {
+        "already_approved": "Already Ready For Client Pack",
+        "already_approved_count": "Already marked ready for client pack",
+        "ask_evidence": "Ask for evidence",
+        "bundle": "Bundle",
+        "bundle_action": (
+            "Response: include bundle {index}, exclude bundle {index}, "
+            "or show more on bundle {index}. ID: `{bundle_id}`."
+        ),
+        "bundle_description": "Note",
+        "bundle_items": "Items",
+        "bundles": "Pending Approval Bundles",
+        "bundles_count": "Pending approval bundles available",
+        "control_heading": "Control Notes",
+        "control_pending": (
+            "Pending and rejected entries must not feed `decision_pack.md` "
+            "or `decision_pack.docx`."
+        ),
+        "control_regenerated": (
+            "This file is derived from canonical JSON case files and can be regenerated safely."
+        ),
+        "create_bundles": (
+            "For long reviews, Clara/Codex can create `inclusion_bundles.json` "
+            "with thematic bundles and regenerate this checklist."
+        ),
+        "correct_one": "Correct one item",
+        "correct_one_example": "correct item 9: ...",
+        "excluded": "Excluded Entries",
+        "excluded_count": "Already excluded from client pack",
+        "exclude_one": "Exclude one item",
+        "exclude_one_example": "exclude item 7",
+        "entry_action": (
+            "Response: include item {index}, exclude item {index}, "
+            "correct item {index}, or show more on item {index}."
+        ),
+        "generated": "Generated",
+        "how_to_respond": "How To Respond",
+        "include_all": "Include everything",
+        "include_all_example": "include all pending items",
+        "include_bundle": "Include one bundle",
+        "include_bundle_example": "include bundle 1",
+        "include_one": "Include one item",
+        "include_one_example": "include item 4",
+        "intro": (
+            "Read-only checklist for deciding which structured case entries "
+            "are ready for the client pack."
+        ),
+        "intro_gate": (
+            "This artifact does not change judgement status. Indicate which "
+            "items to include, exclude, correct, or expand; the decision is "
+            "recorded mechanically after confirmation."
+        ),
+        "no_entries": "No entries in this status.",
+        "no_bundles": "No thematic bundles configured.",
+        "pending": "Pending Entries",
+        "pending_count": "Pending entries requiring advisor decision",
+        "item": "Item",
+        "project": "Project",
+        "audience": "Audience",
+        "rationale": "Rationale",
+        "recorded_by": "Recorded by",
+        "review_note": "Review note",
+        "show_more_example": "show more on item 3",
+        "sources": "Sources",
+        "status_counts": "Status Counts",
+        "title": "Inclusion Review",
+    }
+
+
+def _render_inclusion_review(
+    case_dir: Path,
+    manifest: Mapping[str, Any],
+    materials: Sequence[Mapping[str, Any]],
+    entries: Sequence[Mapping[str, Any]],
+    *,
+    generated_at: str,
+) -> str:
+    """Render a mechanical status checklist without changing inclusion state."""
+
+    material_labels = _material_label_by_id(materials)
+    copy = _inclusion_review_copy(_ui_language(manifest))
+    pending_entries = _review_status_entries(entries, "pending")
+    approved_entries = _review_status_entries(entries, "approved")
+    rejected_entries = _review_status_entries(entries, "rejected")
+    pending_item_numbers = {
+        str(entry["id"]): index for index, entry in enumerate(pending_entries, start=1)
+    }
+    pending_bundles = _pending_inclusion_bundle_groups(case_dir, pending_entries)
+    lines = [
+        f"# {copy['title']} - {manifest['client']}",
+        "",
+        copy["intro"],
+        copy["intro_gate"],
+        "",
+        f"{copy['generated']}: {generated_at}",
+        f"{copy['project']}: {manifest['project']}",
+        f"{copy['audience']}: {manifest['audience']}",
+        "",
+        f"## {copy['status_counts']}",
+        "",
+        f"- {copy['pending_count']}: {len(pending_entries)}",
+        f"- {copy['bundles_count']}: {len(pending_bundles)}",
+        f"- {copy['already_approved_count']}: {len(approved_entries)}",
+        f"- {copy['excluded_count']}: {len(rejected_entries)}",
+        "",
+        f"## {copy['how_to_respond']}",
+        "",
+        f"- {copy['include_all']}: `{copy['include_all_example']}`.",
+        f"- {copy['include_bundle']}: `{copy['include_bundle_example']}`.",
+        f"- {copy['include_one']}: `{copy['include_one_example']}`.",
+        f"- {copy['exclude_one']}: `{copy['exclude_one_example']}`.",
+        f"- {copy['correct_one']}: `{copy['correct_one_example']}`.",
+        f"- {copy['ask_evidence']}: `{copy['show_more_example']}`.",
+        "",
+        f"## {copy['bundles']}",
+        "",
+        *_inclusion_bundle_lines(
+            pending_bundles,
+            pending_item_numbers,
+            copy=copy,
+        ),
+        f"## {copy['pending']}",
+        "",
+        *_inclusion_entry_lines(
+            pending_entries,
+            material_labels,
+            include_actions=True,
+            copy=copy,
+        ),
+        f"## {copy['already_approved']}",
+        "",
+        *_inclusion_entry_lines(
+            approved_entries,
+            material_labels,
+            include_actions=False,
+            copy=copy,
+        ),
+        f"## {copy['excluded']}",
+        "",
+        *_inclusion_entry_lines(
+            rejected_entries,
+            material_labels,
+            include_actions=False,
+            copy=copy,
+        ),
+        f"## {copy['control_heading']}",
+        "",
+        f"- {copy['control_pending']}",
+        f"- {copy['control_regenerated']}",
+        f"- {copy['create_bundles']}",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+@case_operation
+def build_inclusion_review(
+    case_dir: Path,
+    *,
+    output_path: Path | None = None,
+    now: datetime | None = None,
+) -> InclusionReviewResult:
+    """Write a deterministic inclusion checklist without mutating case status.
+
+    The inclusion gate is audit-sensitive mechanical work: this renderer only
+    mirrors canonical JSON state and records actionable item numbers.
+    """
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+
+    manifest = _read_json(_case_path(case_dir, "manifest"))
+    materials = _read_json(_case_path(case_dir, "materials"))["materials"]
+    entries = _read_json(_case_path(case_dir, "judgement"))["entries"]
+    review_path = output_path or case_dir / INCLUSION_REVIEW_FILENAME
+    review_path.parent.mkdir(parents=True, exist_ok=True)
+    review_text = _render_inclusion_review(
+        case_dir,
+        manifest=manifest,
+        materials=materials,
+        entries=entries,
+        generated_at=_now_iso(now),
+    )
+    _assert_human_visible_document_quality(review_text, label=INCLUSION_REVIEW_FILENAME)
+    atomic_text(review_path, review_text, encoding="utf-8")
+
+    return InclusionReviewResult(
+        review_path=review_path,
+        approved_count=sum(1 for entry in entries if entry["status"] == "approved"),
+        pending_count=sum(1 for entry in entries if entry["status"] == "pending"),
+        rejected_count=sum(1 for entry in entries if entry["status"] == "rejected"),
+    )
+
+
+def _group_approved_entries(
+    entries: Sequence[Mapping[str, Any]],
+) -> dict[str, list[Mapping[str, Any]]]:
+    grouped = {kind: [] for kind in sorted(JUDGEMENT_KINDS)}
+    for entry in entries:
+        if entry["status"] == "approved":
+            grouped[entry["kind"]].append(entry)
+    return grouped
+
+
+def _material_label_by_id(materials: Sequence[Mapping[str, Any]]) -> dict[str, str]:
+    return {item["id"]: str(item["title"]) for item in materials}
+
+
+def _entry_line(
+    entry: Mapping[str, Any],
+    material_labels: Mapping[str, str],
+    *,
+    include_sources: bool = True,
+    sources_label: str = "sources",
+) -> str:
+    text = str(entry["text"]).strip()
+    source_ids = entry.get("source_material_ids", [])
+    labels = [
+        material_labels[source_id]
+        for source_id in source_ids
+        if source_id in material_labels
+    ]
+    if include_sources and labels:
+        return f"{text} ({sources_label}: {', '.join(labels)})"
+    return text
+
+
+def _markdown_section(
+    title: str,
+    entries: Sequence[Mapping[str, Any]],
+    material_labels: Mapping[str, str],
+    *,
+    no_items: str = "No decision-pack-ready items.",
+    sources_label: str = "sources",
+) -> list[str]:
+    lines = [f"## {title}", ""]
+    if not entries:
+        lines.extend([no_items, ""])
+        return lines
+    lines.extend(
+        f"- {_entry_line(entry, material_labels, sources_label=sources_label)}"
+        for entry in entries
+    )
+    lines.append("")
+    return lines
+
+
+LANGUAGE_COPY = {
+    "en": {
+        "title": "Decision Pack",
+        "project": "Project",
+        "objective": "Objective",
+        "audience": "Audience",
+        "status": "Draft Status",
+        "ready_note": "This draft uses only judgement marked ready for the client pack.",
+        "not_ready": "The client pack is not ready yet. Review the candidate judgement entries before sharing this output.",
+        "facts": "Facts",
+        "storyline": "Executive Storyline",
+        "advisor": "Consultant Readout",
+        "inferences": "Analytical Implications",
+        "decisions": "Decision Implications",
+        "questions": "Open Questions To Resolve",
+        "no_items": "No reviewed items yet.",
+        "why": "Why it matters",
+        "workpaper_note": "Detailed provenance and inclusion control are in decision_pack_workpaper.md.",
+        "workpaper_title": "Decision Pack Workpaper",
+        "materials": "Materials Indexed",
+        "control": "Inclusion Control",
+        "used": "Decision-pack-ready judgement entries used",
+        "pending": "Pending judgement entries excluded",
+        "rejected": "Rejected judgement entries excluded",
+    },
+    "it": {
+        "title": "Decision Pack",
+        "project": "Progetto",
+        "objective": "Obiettivo",
+        "audience": "Destinatario",
+        "status": "Stato della bozza",
+        "ready_note": "Questa bozza usa solo giudizi segnati come pronti per il pack cliente.",
+        "not_ready": "Il pack cliente non e' ancora pronto. Rivedere le voci candidate prima di condividere questo output.",
+        "facts": "Fatti acquisiti",
+        "storyline": "Traccia esecutiva",
+        "advisor": "Lettura consulenziale",
+        "inferences": "Implicazioni analitiche",
+        "decisions": "Implicazioni per la decisione",
+        "questions": "Questioni aperte da risolvere",
+        "no_items": "Nessuna voce rivista.",
+        "why": "Perche conta",
+        "workpaper_note": "Provenienza dettagliata e controlli di inclusione sono in decision_pack_workpaper.md.",
+        "workpaper_title": "Workpaper del decision pack",
+        "materials": "Materiali indicizzati",
+        "control": "Controllo inclusione",
+        "used": "Voci giudizio pronte usate",
+        "pending": "Voci pending escluse",
+        "rejected": "Voci escluse",
+    },
+    "fr": {
+        "title": "Decision Pack",
+        "project": "Projet",
+        "objective": "Objectif",
+        "audience": "Audience",
+        "status": "Statut du brouillon",
+        "ready_note": "Ce brouillon utilise uniquement les jugements marques comme prets pour le client.",
+        "not_ready": "Le pack client n'est pas encore pret. Revoyez les elements candidats avant partage.",
+        "facts": "Faits etablis",
+        "storyline": "Fil conducteur executif",
+        "advisor": "Lecture conseil",
+        "inferences": "Implications analytiques",
+        "decisions": "Implications pour la decision",
+        "questions": "Questions ouvertes",
+        "no_items": "Aucun element revu.",
+        "why": "Pourquoi c'est important",
+        "workpaper_note": "La provenance detaillee et le controle d'inclusion sont dans decision_pack_workpaper.md.",
+        "workpaper_title": "Workpaper du decision pack",
+        "materials": "Documents indexes",
+        "control": "Controle d'inclusion",
+        "used": "Jugements prets utilises",
+        "pending": "Jugements en attente exclus",
+        "rejected": "Jugements rejetes exclus",
+    },
+    "de": {
+        "title": "Decision Pack",
+        "project": "Projekt",
+        "objective": "Ziel",
+        "audience": "Zielgruppe",
+        "status": "Entwurfsstatus",
+        "ready_note": "Dieser Entwurf nutzt nur fuer den Client-Pack freigegebene Einschaetzungen.",
+        "not_ready": "Der Client-Pack ist noch nicht bereit. Pruefen Sie die Kandidaten vor der Weitergabe.",
+        "facts": "Gesicherte Fakten",
+        "storyline": "Executive Storyline",
+        "advisor": "Beraterliche Einordnung",
+        "inferences": "Analytische Implikationen",
+        "decisions": "Entscheidungsimplikationen",
+        "questions": "Offene Fragen",
+        "no_items": "Noch keine geprueften Punkte.",
+        "why": "Warum es wichtig ist",
+        "workpaper_note": "Detaillierte Herkunft und Inklusionskontrolle stehen in decision_pack_workpaper.md.",
+        "workpaper_title": "Decision-Pack-Workpaper",
+        "materials": "Indexierte Materialien",
+        "control": "Inklusionskontrolle",
+        "used": "Verwendete freigegebene Einschaetzungen",
+        "pending": "Ausgeschlossene pending Einschaetzungen",
+        "rejected": "Ausgeschlossene abgelehnte Einschaetzungen",
+    },
+    "es": {
+        "title": "Paquete de decisión",
+        "project": "Proyecto",
+        "objective": "Objetivo",
+        "audience": "Destinatario",
+        "status": "Estado del borrador",
+        "ready_note": (
+            "Este borrador utiliza únicamente juicios marcados como listos para "
+            "el paquete del cliente."
+        ),
+        "not_ready": (
+            "El paquete del cliente aún no está listo. Revisa los elementos "
+            "candidatos antes de compartir este entregable."
+        ),
+        "facts": "Hechos",
+        "storyline": "Línea argumental ejecutiva",
+        "advisor": "Lectura consultiva",
+        "inferences": "Implicaciones analíticas",
+        "decisions": "Implicaciones para la decisión",
+        "questions": "Preguntas abiertas que resolver",
+        "no_items": "Aún no hay elementos revisados.",
+        "why": "Por qué es importante",
+        "workpaper_note": (
+            "La procedencia detallada y el control de inclusión están en "
+            "decision_pack_workpaper.md."
+        ),
+        "workpaper_title": "Documento de trabajo del paquete de decisión",
+        "materials": "Materiales indexados",
+        "control": "Control de inclusión",
+        "used": "Elementos de juicio listos utilizados",
+        "pending": "Elementos de juicio pendientes excluidos",
+        "rejected": "Elementos de juicio rechazados excluidos",
+    },
+}
+
+
+def _copy(manifest: Mapping[str, Any], key: str) -> str:
+    language = str(manifest.get("output_language") or "en")
+    return LANGUAGE_COPY.get(language, LANGUAGE_COPY["en"])[key]
+
+
+def _workpaper_output_copy(manifest: Mapping[str, Any]) -> dict[str, str]:
+    if _ui_language(manifest) == "es":
+        return {
+            "explanation": (
+                "Este documento de trabajo incluye las rutas de las fuentes y el "
+                "control de inclusión. No está destinado al cliente."
+            ),
+            "no_materials": "No hay materiales indexados.",
+            "no_questions": "No se han registrado preguntas abiertas.",
+            "no_items": "No hay elementos listos para el paquete de decisión.",
+            "sources": "fuentes",
+            "title_header": "Título",
+            "type_header": "Tipo",
+            "status_header": "Estado",
+        }
+    return {
+        "explanation": (
+            "This workpaper includes source paths and inclusion control. It is not "
+            "client-facing."
+        ),
+        "no_materials": "No materials indexed.",
+        "no_questions": "No open questions registered.",
+        "no_items": "No decision-pack-ready items.",
+        "sources": "sources",
+        "title_header": "Title",
+        "type_header": "Type",
+        "status_header": "Status",
+    }
+
+
+def _client_section(
+    title: str,
+    entries: Sequence[Mapping[str, Any]],
+    material_labels: Mapping[str, str],
+    manifest: Mapping[str, Any],
+) -> list[str]:
+    lines = [f"## {title}", ""]
+    if not entries:
+        lines.extend([_copy(manifest, "no_items"), ""])
+        return lines
+    lines.extend(
+        f"- {_entry_line(entry, material_labels, include_sources=False)}"
+        for entry in entries
+    )
+    lines.append("")
+    return lines
+
+
+def _render_markdown(
+    manifest: Mapping[str, Any],
+    materials: Sequence[Mapping[str, Any]],
+    entries: Sequence[Mapping[str, Any]],
+    open_questions: Sequence[Mapping[str, Any]],
+    *,
+    narrative: Sequence[str] = (),
+) -> str:
+    grouped = _group_approved_entries(entries)
+    material_labels = _material_label_by_id(materials)
+    pending_count = sum(1 for entry in entries if entry["status"] == "pending")
+    rejected_count = sum(1 for entry in entries if entry["status"] == "rejected")
+    approved_count = sum(1 for entry in entries if entry["status"] == "approved")
+
+    lines = [
+        f"# {manifest['client']} - {_copy(manifest, 'title')}",
+        "",
+        f"**{_copy(manifest, 'project')}:** {manifest['project']}",
+        f"**{_copy(manifest, 'objective')}:** {manifest['objective']}",
+        f"**{_copy(manifest, 'audience')}:** {manifest['audience']}",
+        "",
+        f"## {_copy(manifest, 'status')}",
+        "",
+        _copy(manifest, "ready_note"),
+        "",
+    ]
+    if approved_count == 0:
+        lines.extend([_copy(manifest, "not_ready"), ""])
+
+    storyline = narrative
+    if storyline:
+        lines.extend([f"## {_copy(manifest, 'storyline')}", ""])
+        for paragraph in storyline:
+            lines.extend([paragraph, ""])
+
+    sections = [
+        (_copy(manifest, "facts"), grouped["fact"]),
+        (_copy(manifest, "advisor"), grouped["advisor_judgement"]),
+        (_copy(manifest, "inferences"), grouped["codex_inference"]),
+        (_copy(manifest, "decisions"), grouped["decision_implication"]),
+    ]
+    for title, section_entries in sections:
+        lines.extend(_client_section(title, section_entries, material_labels, manifest))
+
+    lines.extend([f"## {_copy(manifest, 'questions')}", ""])
+    open_items = [item for item in open_questions if item["status"] == "open"]
+    if open_items:
+        lines.extend(
+            f"- {item['question']} ({_copy(manifest, 'why')}: {item['why_it_matters']})"
+            for item in open_items
+        )
+    else:
+        lines.append(_copy(manifest, "no_items"))
+    lines.extend(
+        [
+            "",
+            f"_{_copy(manifest, 'workpaper_note')}_",
+            "",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def _render_workpaper_markdown(
+    manifest: Mapping[str, Any],
+    materials: Sequence[Mapping[str, Any]],
+    entries: Sequence[Mapping[str, Any]],
+    open_questions: Sequence[Mapping[str, Any]],
+) -> str:
+    workpaper_copy = _workpaper_output_copy(manifest)
+    grouped = _group_approved_entries(entries)
+    material_labels = _material_label_by_id(materials)
+    pending_count = sum(1 for entry in entries if entry["status"] == "pending")
+    rejected_count = sum(1 for entry in entries if entry["status"] == "rejected")
+    approved_count = sum(1 for entry in entries if entry["status"] == "approved")
+
+    lines = [
+        f"# {_copy(manifest, 'workpaper_title')} - {manifest['client']}",
+        "",
+        f"{_copy(manifest, 'project')}: {manifest['project']}",
+        f"{_copy(manifest, 'objective')}: {manifest['objective']}",
+        f"{_copy(manifest, 'audience')}: {manifest['audience']}",
+        "",
+        workpaper_copy["explanation"],
+        "",
+        f"## {_copy(manifest, 'materials')}",
+        "",
+    ]
+    if materials:
+        lines.extend(
+            f"- {item['title']} [{item['material_type']}, {item['status']}] - {item['path']}"
+            for item in materials
+        )
+    else:
+        lines.append(workpaper_copy["no_materials"])
+    lines.append("")
+
+    sections = [
+        (_copy(manifest, "facts"), grouped["fact"]),
+        (_copy(manifest, "advisor"), grouped["advisor_judgement"]),
+        (_copy(manifest, "inferences"), grouped["codex_inference"]),
+        (_copy(manifest, "decisions"), grouped["decision_implication"]),
+    ]
+    for title, section_entries in sections:
+        lines.extend(
+            _markdown_section(
+                title,
+                section_entries,
+                material_labels,
+                no_items=workpaper_copy["no_items"],
+                sources_label=workpaper_copy["sources"],
+            )
+        )
+
+    lines.extend([f"## {_copy(manifest, 'questions')}", ""])
+    open_items = [item for item in open_questions if item["status"] == "open"]
+    if open_items:
+        lines.extend(
+            f"- {item['question']} {_copy(manifest, 'why')}: {item['why_it_matters']}"
+            for item in open_items
+        )
+    else:
+        lines.append(workpaper_copy["no_questions"])
+    lines.extend(
+        [
+            "",
+            f"## {_copy(manifest, 'control')}",
+            "",
+            f"- {_copy(manifest, 'used')}: {approved_count}",
+            f"- {_copy(manifest, 'pending')}: {pending_count}",
+            f"- {_copy(manifest, 'rejected')}: {rejected_count}",
+            "",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def _add_docx_bullets(
+    document: Any,
+    items: Sequence[str],
+    *,
+    empty_text: str = "No decision-pack-ready items.",
+) -> None:
+    if not items:
+        document.add_paragraph(empty_text)
+        return
+    for item in items:
+        document.add_paragraph(item, style="List Bullet")
+
+
+def _render_docx(
+    path: Path,
+    manifest: Mapping[str, Any],
+    materials: Sequence[Mapping[str, Any]],
+    entries: Sequence[Mapping[str, Any]],
+    open_questions: Sequence[Mapping[str, Any]],
+    *,
+    narrative: Sequence[str] = (),
+) -> None:
+    try:
+        from docx import Document
+        from docx.enum.text import WD_ALIGN_PARAGRAPH
+        from docx.shared import Pt, RGBColor
+    except ImportError as exc:
+        raise CaseWorkspaceError(
+            "python-docx is required to render decision_pack.docx"
+        ) from exc
+
+    grouped = _group_approved_entries(entries)
+    workpaper_copy = _workpaper_output_copy(manifest)
+    material_labels = _material_label_by_id(materials)
+    approved_count = sum(1 for entry in entries if entry["status"] == "approved")
+    document = Document()
+    styles = document.styles
+    styles["Normal"].font.name = "Arial"
+    styles["Normal"].font.size = Pt(10.5)
+    styles["Title"].font.color.rgb = RGBColor(49, 95, 85)
+
+    title = document.add_paragraph()
+    title.style = styles["Title"]
+    title.alignment = WD_ALIGN_PARAGRAPH.LEFT
+    title.add_run(f"{manifest['client']} - {_copy(manifest, 'title')}")
+
+    for label, value in (
+        (_copy(manifest, "project"), manifest["project"]),
+        (_copy(manifest, "objective"), manifest["objective"]),
+        (_copy(manifest, "audience"), manifest["audience"]),
+    ):
+        paragraph = document.add_paragraph()
+        paragraph.add_run(f"{label}: ").bold = True
+        paragraph.add_run(str(value))
+
+    document.add_heading(_copy(manifest, "status"), level=1)
+    document.add_paragraph(_copy(manifest, "ready_note"))
+    if approved_count == 0:
+        document.add_paragraph(_copy(manifest, "not_ready"))
+
+    storyline = narrative
+    if storyline:
+        document.add_heading(_copy(manifest, "storyline"), level=1)
+        for paragraph_text in storyline:
+            document.add_paragraph(paragraph_text)
+
+    for title_text, section_entries in (
+        (_copy(manifest, "facts"), grouped["fact"]),
+        (_copy(manifest, "advisor"), grouped["advisor_judgement"]),
+        (_copy(manifest, "inferences"), grouped["codex_inference"]),
+        (_copy(manifest, "decisions"), grouped["decision_implication"]),
+    ):
+        document.add_heading(title_text, level=1)
+        _add_docx_bullets(
+            document,
+            [
+                _entry_line(entry, material_labels, include_sources=False)
+                for entry in section_entries
+            ],
+            empty_text=workpaper_copy["no_items"],
+        )
+
+    document.add_heading(_copy(manifest, "questions"), level=1)
+    open_items = [item for item in open_questions if item["status"] == "open"]
+    _add_docx_bullets(
+        document,
+        [
+            f"{item['question']} ({_copy(manifest, 'why')}: {item['why_it_matters']})"
+            for item in open_items
+        ],
+        empty_text=workpaper_copy["no_questions"],
+    )
+    document.add_paragraph(_copy(manifest, "workpaper_note"))
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    document.save(path)
+
+
+def _render_workpaper_docx(
+    path: Path,
+    manifest: Mapping[str, Any],
+    materials: Sequence[Mapping[str, Any]],
+    entries: Sequence[Mapping[str, Any]],
+    open_questions: Sequence[Mapping[str, Any]],
+) -> None:
+    try:
+        from docx import Document
+        from docx.enum.text import WD_ALIGN_PARAGRAPH
+        from docx.shared import Pt, RGBColor
+    except ImportError as exc:
+        raise CaseWorkspaceError(
+            "python-docx is required to render decision_pack_workpaper.docx"
+        ) from exc
+
+    grouped = _group_approved_entries(entries)
+    workpaper_copy = _workpaper_output_copy(manifest)
+    material_labels = _material_label_by_id(materials)
+    document = Document()
+    styles = document.styles
+    styles["Normal"].font.name = "Arial"
+    styles["Normal"].font.size = Pt(10.5)
+    styles["Title"].font.color.rgb = RGBColor(49, 95, 85)
+
+    title = document.add_paragraph()
+    title.style = styles["Title"]
+    title.alignment = WD_ALIGN_PARAGRAPH.LEFT
+    title.add_run(f"{_copy(manifest, 'workpaper_title')} - {manifest['client']}")
+
+    for label, value in (
+        (_copy(manifest, "project"), manifest["project"]),
+        (_copy(manifest, "objective"), manifest["objective"]),
+        (_copy(manifest, "audience"), manifest["audience"]),
+    ):
+        paragraph = document.add_paragraph()
+        paragraph.add_run(f"{label}: ").bold = True
+        paragraph.add_run(str(value))
+
+    document.add_paragraph(workpaper_copy["explanation"])
+    document.add_heading(_copy(manifest, "materials"), level=1)
+    if materials:
+        table = document.add_table(rows=1, cols=3)
+        table.style = "Table Grid"
+        header = table.rows[0].cells
+        header[0].text = workpaper_copy["title_header"]
+        header[1].text = workpaper_copy["type_header"]
+        header[2].text = workpaper_copy["status_header"]
+        for item in materials:
+            row = table.add_row().cells
+            row[0].text = str(item["title"])
+            row[1].text = str(item["material_type"])
+            row[2].text = str(item["status"])
+    else:
+        document.add_paragraph(workpaper_copy["no_materials"])
+
+    for title_text, section_entries in (
+        (_copy(manifest, "facts"), grouped["fact"]),
+        (_copy(manifest, "advisor"), grouped["advisor_judgement"]),
+        (_copy(manifest, "inferences"), grouped["codex_inference"]),
+        (_copy(manifest, "decisions"), grouped["decision_implication"]),
+    ):
+        document.add_heading(title_text, level=1)
+        _add_docx_bullets(
+            document,
+            [
+                _entry_line(
+                    entry,
+                    material_labels,
+                    sources_label=workpaper_copy["sources"],
+                )
+                for entry in section_entries
+            ],
+            empty_text=workpaper_copy["no_items"],
+        )
+
+    document.add_heading(_copy(manifest, "questions"), level=1)
+    open_items = [item for item in open_questions if item["status"] == "open"]
+    _add_docx_bullets(
+        document,
+        [
+            f"{item['question']} {_copy(manifest, 'why')}: {item['why_it_matters']}"
+            for item in open_items
+        ],
+        empty_text=workpaper_copy["no_questions"],
+    )
+
+    pending_count = sum(1 for entry in entries if entry["status"] == "pending")
+    rejected_count = sum(1 for entry in entries if entry["status"] == "rejected")
+    approved_count = sum(1 for entry in entries if entry["status"] == "approved")
+    document.add_heading(_copy(manifest, "control"), level=1)
+    _add_docx_bullets(
+        document,
+        [
+            f"{_copy(manifest, 'used')}: {approved_count}",
+            f"{_copy(manifest, 'pending')}: {pending_count}",
+            f"{_copy(manifest, 'rejected')}: {rejected_count}",
+        ],
+    )
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    document.save(path)
+
+
+def _decision_narrative_basis(
+    case_dir: Path, approved_claim_ids: set[str]
+) -> dict[str, Any] | None:
+    checkpoint_path = case_dir / ADVISORY_WORKPAPER_CHECKPOINT_FILENAME
+    workpaper = case_dir / ADVISORY_WORKPAPER_FILENAME
+    if not checkpoint_path.is_file() or not workpaper.is_file():
+        return None
+    checkpoint = _read_json(checkpoint_path)
+    workpaper_hash = _file_sha256(workpaper)
+    semantic_hash = _semantic_claim_register_sha256(
+        _read_json(case_dir / CLAIM_REGISTER_FILENAME)
+    )
+    evidence_hash = _file_sha256(case_dir / EVIDENCE_REGISTER_FILENAME)
+    if (
+        checkpoint["workpaper"]["sha256"] != workpaper_hash
+        or checkpoint["lineage"]["claim_semantic_sha256"] != semantic_hash
+        or checkpoint["lineage"]["evidence_register_sha256"] != evidence_hash
+    ):
+        return None
+    return {
+        "workpaper_sha256": workpaper_hash,
+        "claim_semantic_sha256": semantic_hash,
+        "evidence_register_sha256": evidence_hash,
+        "approved_claim_ids": sorted(approved_claim_ids),
+        "materials_sha256": _file_sha256(_case_path(case_dir, "materials")),
+        "questions_sha256": _file_sha256(_case_path(case_dir, "open_questions")),
+        "judgements_sha256": sha256(
+            json.dumps(
+                sorted(
+                    _read_json(_case_path(case_dir, "judgement"))["entries"],
+                    key=lambda entry: entry["id"],
+                ),
+                sort_keys=True,
+                ensure_ascii=False,
+            ).encode("utf-8")
+        ).hexdigest(),
+    }
+
+
+@case_operation
+def commit_decision_narrative(case_dir: Path, authored_narrative: Path) -> Path:
+    """Commit reviewed, model-authored lead paragraphs against current approved claims."""
+    entries = _read_json(_case_path(case_dir, "judgement"))["entries"]
+    approved = {
+        str(entry["advisory_claim_id"])
+        for entry in entries
+        if entry["status"] == "approved"
+    }
+    basis = _decision_narrative_basis(case_dir, approved)
+    if basis is None:
+        raise CaseWorkspaceError(
+            "Commit the current advisory workpaper before its decision narrative"
+        )
+    try:
+        return commit_narrative(
+            case_dir, authored_narrative, basis=basis, approved_claim_ids=approved
+        )
+    except ValueError as exc:
+        raise CaseWorkspaceError(str(exc)) from exc
+
+
+@case_operation
+def build_decision_pack(
+    case_dir: Path,
+    *,
+    output_dir: Path | None = None,
+) -> DecisionPackResult:
+    """Render Markdown and Word packs using client-pack-ready judgement only."""
+
+    errors = validate_case_workspace(case_dir)
+    if errors:
+        raise CaseWorkspaceError("; ".join(errors))
+    refresh_case_brief(case_dir)
+
+    manifest = _read_json(_case_path(case_dir, "manifest"))
+    materials = _read_json(_case_path(case_dir, "materials"))["materials"]
+    entries = _read_json(_case_path(case_dir, "judgement"))["entries"]
+    questions = _read_json(_case_path(case_dir, "open_questions"))["questions"]
+    target_dir = (
+        output_dir
+        or case_dir.expanduser().resolve().parent / "output" / "clara" / case_dir.name
+    )
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    approved_entries = [entry for entry in entries if entry.get("status") == "approved"]
+    for entry in approved_entries:
+        _assert_judgement_claim_binding(
+            case_dir,
+            text=str(entry.get("text", "")),
+            advisory_claim_id=str(entry.get("advisory_claim_id", "")).strip(),
+            evidence_receipt_ids=entry.get("evidence_receipt_ids", []),
+        )
+
+    approved_claim_ids = {str(entry["advisory_claim_id"]) for entry in approved_entries}
+    narrative_basis = _decision_narrative_basis(case_dir, approved_claim_ids)
+    try:
+        narrative = load_narrative(
+            case_dir, basis=narrative_basis, approved_claim_ids=approved_claim_ids
+        )
+    except ValueError as exc:
+        raise CaseWorkspaceError(str(exc)) from exc
+
+    markdown_path = target_dir / "decision_pack.md"
+    docx_path = target_dir / "decision_pack.docx"
+    workpaper_markdown_path = target_dir / "decision_pack_workpaper.md"
+    workpaper_docx_path = target_dir / "decision_pack_workpaper.docx"
+    output_paths = (
+        markdown_path,
+        docx_path,
+        workpaper_markdown_path,
+        workpaper_docx_path,
+    )
+    readiness_path = target_dir / "decision_pack_readiness.json"
+    snapshot = _snapshot_files(
+        [
+            readiness_path,
+            *output_paths,
+            case_dir / CLAIM_REGISTER_FILENAME,
+            case_dir / "advisory_evidence_map.md",
+        ]
+    )
+    completed = False
+    try:
+        markdown_text = _render_markdown(
+            manifest, materials, entries, questions, narrative=narrative
+        )
+        _assert_human_visible_document_quality(markdown_text, label="decision_pack.md")
+        atomic_text(markdown_path, markdown_text, encoding="utf-8")
+        atomic_text(
+            workpaper_markdown_path,
+            _render_workpaper_markdown(manifest, materials, entries, questions),
+            encoding="utf-8",
+        )
+        _render_docx(
+            docx_path, manifest, materials, entries, questions, narrative=narrative
+        )
+        _render_workpaper_docx(
+            workpaper_docx_path,
+            manifest,
+            materials,
+            entries,
+            questions,
+        )
+        claim_locations = [
+            {
+                "claim_id": str(entry["advisory_claim_id"]),
+                "locator": f"Decision-pack statement: {entry['text']}",
+            }
+            for entry in approved_entries
+        ]
+        narrative_locations = []
+        if narrative:
+            authored = _read_json(case_dir / NARRATIVE_FILENAME)
+            narrative_locations = [
+                {
+                    "claim_id": claim,
+                    "locator": f"Executive narrative: {paragraph['text']}",
+                }
+                for paragraph in authored["paragraphs"]
+                for claim in paragraph["claim_ids"]
+            ]
+        for artifact_path in output_paths:
+            locations = claim_locations + (
+                narrative_locations
+                if artifact_path in (markdown_path, docx_path)
+                else []
+            )
+            if locations:
+                bind_claim_appearances(case_dir, artifact_path, locations)
+        atomic_text(
+            readiness_path,
+            json.dumps(
+                {
+                    "schema_version": 1,
+                    "status": (
+                        "requires_final_deliverable_review"
+                        if narrative
+                        else "missing_reviewed_narrative"
+                    ),
+                    "ready_for_delivery": False,
+                    "basis": narrative_basis,
+                    "narrative_sha256": (
+                        _file_sha256(case_dir / NARRATIVE_FILENAME)
+                        if narrative
+                        else None
+                    ),
+                    "outputs": {path.name: _file_sha256(path) for path in output_paths},
+                    "boundary": "Identity and approved references checked; final semantic and visual validation remains required.",
+                },
+                indent=2,
+            )
+            + "\n",
+        )
+        completed = True
+    finally:
+        if not completed:
+            _restore_files(snapshot)
+
+    return DecisionPackResult(
+        markdown_path=markdown_path,
+        docx_path=docx_path,
+        workpaper_markdown_path=workpaper_markdown_path,
+        workpaper_docx_path=workpaper_docx_path,
+        approved_count=sum(1 for entry in entries if entry["status"] == "approved"),
+        pending_count=sum(1 for entry in entries if entry["status"] == "pending"),
+        rejected_count=sum(1 for entry in entries if entry["status"] == "rejected"),
+    )
+
+
+@case_reader
+def verify_decision_pack(case_dir: Path, *, output_dir: Path) -> dict[str, Any]:
+    """Check current source/output identity without asserting semantic readiness."""
+    receipt = _read_json(output_dir / "decision_pack_readiness.json")
+    entries = _read_json(_case_path(case_dir, "judgement"))["entries"]
+    approved = {
+        str(entry["advisory_claim_id"])
+        for entry in entries
+        if entry["status"] == "approved"
+    }
+    basis = _decision_narrative_basis(case_dir, approved)
+    if basis is None or receipt.get("basis") != basis:
+        raise CaseWorkspaceError("Decision pack is stale against current case evidence")
+    try:
+        narrative = load_narrative(case_dir, basis=basis, approved_claim_ids=approved)
+    except ValueError as exc:
+        raise CaseWorkspaceError(str(exc)) from exc
+    if not narrative or receipt.get("narrative_sha256") != _file_sha256(
+        case_dir / NARRATIVE_FILENAME
+    ):
+        raise CaseWorkspaceError("Decision pack narrative is missing or changed")
+    expected = {
+        "decision_pack.md",
+        "decision_pack.docx",
+        "decision_pack_workpaper.md",
+        "decision_pack_workpaper.docx",
+    }
+    outputs = receipt.get("outputs")
+    if not isinstance(outputs, dict) or set(outputs) != expected:
+        raise CaseWorkspaceError("Decision pack receipt has an incomplete output set")
+    for name, digest in outputs.items():
+        path = output_dir / name
+        if not path.is_file() or path.is_symlink() or _file_sha256(path) != digest:
+            raise CaseWorkspaceError(
+                f"Decision pack output is missing or changed: {name}"
+            )
+    return {
+        **receipt,
+        "status": "requires_final_deliverable_review",
+        "ready_for_delivery": False,
+        "current_identity_verified": True,
+    }

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

scripts/advisor_case_core.py

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

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

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

added /files/LEGGIMI_INSTALLAZIONE.txt

removed /files/LICENSE

added /files/README.md

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

changed /files/components.json/sha256

changed /files/components.json/size

removed /files/distribution.json

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

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

added /files/evals~1html_deck_benchmark_protocol.md

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

added /files/evals~1html_deck_capability_benchmarks.json

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

added /files/evals~1trigger_fixtures.json

changed /files/execution-files.json/sha256

changed /files/execution-files.json/size

added /files/marketplace_skill_instructions.json

added /files/mcp-catalog.json

added /files/mcp-services.json

removed /files/modules~1README.md

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

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

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

added `/files/LEGGIMI_INSTALLAZIONE.txt`

removed `/files/LICENSE`

added `/files/README.md`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

changed `/files/components.json/sha256`

changed `/files/components.json/size`

removed `/files/distribution.json`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

added `/files/marketplace_skill_instructions.json`

added `/files/mcp-catalog.json`

added `/files/mcp-services.json`

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

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

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

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

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

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

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

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

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

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