feat(migrator): DP Migrator beta — rebuild a prospect's Tableau dashboard (or a picture of it) as the demo

Ketan's "built-in legacy migrator" and Nick's ask (2026-10-28): the SE sends the
prospect's website plus a .twb/.twbx or a dashboard screenshot; the demo's data
speaks the dashboard's measure and dimension names and the liveboard copies its
sheets (chart types, titles, arrangement; a dual axis as a combo chart) instead
of the golden layout. DP Web unchanged.

- demoprep_app/migration/: MirrorSpec contract, source-grammar -> ThoughtSpot
chart-type mapping, deterministic Tableau .twb parser (defusedxml; paths,
hosts and users stripped; blends, relationships, parameters, table calcs and
LOD noted), one-vision-call picture reader, the blueprint statement that
binds the vocabulary, one liveboard question per sheet in the model's column
names, and the argument loader (.twbx -> its .twb only; the payload log keeps
kind, size and hash, never content).
- liveboards/mirror_layout.py + enhance_mcp_liveboard(layout_strategy="mirror"):
retype/retitle from the source before classification; no groups, KPI/donut
conversions, Muze, title rewriting or guide tile; one tab named after the
dashboard, tiles from the source zones or a KPI-first grid.
- create_liveboard_from_model_mcp(explicit_questions), deploy_all(mirror),
ChatDemoInterface.mirror_spec, deployment_completion["mirror"].
- mcp_server: source_dashboard / source_dashboard_image on build_demo_from_brief
(workbook parsed before a slot is taken; picture read on the build thread),
the inspect_dashboard tool, mirror block on the result and recent_builds.
- docs: agent_q_flags.md (ISS-31), agentspot_dp_migrator_agent.md (the
dedicated agent's instructions), sprint doc ISS-31.
- tests: tableau parser (26, on Nick's workbook with the user path scrubbed),
mirror layout (incl. enhance end to end with a fake cluster), questions /
statement / loader / picture JSON; signature-mirroring tests updated.

Verified live on secloud 2026-10-29: board 395e7f14 (Sales as columns, Target
and Sales V Target as lines, monthly; data API 200). Run 1 found the column
matcher taking "Total Sales V Target" for "Target" (fixed, regression test).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

chat_interface.py

@@ -447,6 +447,10 @@ class ChatDemoInterface:
         # The prospect's brand colours (ISS-19) as BrandTheme.to_dict(). Set only by
         # the MCP build when the caller asked for branding; None = default palette.
         self.brand_theme = None
+        # DP Migrator (boone 2026-10-28): the prospect's dashboard as a MirrorSpec
+        # dict, set by the MCP build only. It binds the blueprint's vocabulary and
+        # switches the liveboard to the mirror layout. None = an ordinary demo.
+        self.mirror_spec = None
         # Custom MCP demo (GitHub issues → Spotter) Demo Pack section: OFF unless a
         # caller turns it on for a run, because it costs an extra LLM call. Only the
         # MCP path sets it (build_demo_from_brief custom_mcp_demo=true); the App and
@@ -582,6 +586,9 @@ class ChatDemoInterface:
             "ts_username": results.get("ts_username") or "",
             "liveboard_creation_path": results.get("liveboard_creation_path") or ("spotter_tml_backup" if backup else "mcp" if liveboard_url else "none"),
             "fallback_reason": results.get("fallback_reason") or "",
+            # DP Migrator: the tiles asked from the source dashboard and the sheets
+            # dropped, when the build mirrored one (thoughtspot_deployer.deploy_all).
+            "mirror": results.get("mirror"),
             "model_url": model_url,
             "liveboard_url": liveboard_url,
             "model_guid": model_guid,
@@ -3375,6 +3382,13 @@ To change settings, use:
 
             row_count_guidance = int(self.settings.get("fact_table_size", 5000) or 5000)
             company_name = self.demo_builder.extract_company_name()
+            _user_request = getattr(self, "generic_use_case_context", "") or self.demo_builder.use_case
+            if getattr(self, "mirror_spec", None):
+                # DP Migrator: the prospect's dashboard vocabulary, as a request the
+                # blueprint author honours (measure/dimension names, date, charts).
+                from demoprep_app.migration.spec import MirrorSpec
+                from demoprep_app.migration.statement import statement_from_spec
+                _user_request = f"{_user_request}\n\n{statement_from_spec(MirrorSpec.from_dict(self.mirror_spec))}"
             build = build_demo(
                 company_name=company_name,
                 company_url=self.demo_builder.company_url,
@@ -3389,7 +3403,7 @@ To change settings, use:
                     ]
                     if part
                 ),
-                user_request=getattr(self, "generic_use_case_context", "") or self.demo_builder.use_case,
+                user_request=_user_request,
                 llm_model=self.settings.get("model", DEFAULT_LLM_MODEL),
                 progress_callback=self.log_feedback,
                 prompt_logger=self._prompt_logger,
@@ -4809,6 +4823,7 @@ This chat will update when complete."""
                         progress_callback=progress_callback,
                         session_logger=_slog,
                         brand_theme=self.brand_theme,
+                        mirror=getattr(self, 'mirror_spec', None),
                     )
                 except Exception as e:
                     ts_result["error"] = str(e)

demoprep_app/liveboards/mirror_layout.py

@@ -0,0 +1,358 @@
+"""Mirror layout: the board looks like the prospect's dashboard, not like ours.
+
+Used by enhance_mcp_liveboard(layout_strategy="mirror", mirror=...). The
+golden layout regroups a board into executive/manager/showcase tabs, promotes
+KPIs, lets the Muze engine retype charts and rewrites titles. None of that is
+wanted when the SE sent the prospect's own dashboard: the tiles keep the
+source sheets' chart types, titles and arrangement (boone, 2026-10-28:
+"recreate the liveboard as much like theirs as we can").
+
+Two passes, called at different points of the enhance step:
+  retype_for_mirror     right after the MCP board is exported, before any
+                        classification: match each viz to its source tile,
+                        set the source chart type (the combo config for a
+                        dual axis), the source title.
+  apply_mirror_layout   at layout time: one tab named after the dashboard,
+                        tiles placed from the source zones (or a plain grid
+                        when the source had no dashboard), no groups.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Tuple
+
+from demoprep_app.liveboards.golden_layout import (
+    CHART_ROW_H, KPI_ROW_H, _advanced_chart_config, _answer_column_names,
+    _chart_column_names, _combo_chart_config, _load_chart_client_state,
+    json_dumps_compact,
+)
+
+COMBO = "ADVANCED_LINE_COLUMN"
+TABLE_TYPES = {"TABLE", "PIVOT_TABLE"}
+#: Rows per column of width on a ThoughtSpot board: a 6-wide, 8-tall chart tile
+#: reads roughly square, so one row unit is about 0.6 of one column unit.
+ROW_UNITS_PER_COLUMN_UNIT = 1.6
+GRID_COLUMNS = 12
+MIN_TILE_W = 2
+MIN_TILE_H = 3
+
+
+# --------------------------------------------------------------------------
+# pass 1: chart types and titles
+# --------------------------------------------------------------------------
+def retype_for_mirror(visualizations: List[Dict[str, Any]], tiles: List[Dict[str, Any]]
+                      ) -> Tuple[List[str], Dict[str, Dict[str, Any]]]:
+    """Set each matched viz's chart type and title from its source tile.
+    Returns (changes, mapping viz_id -> tile)."""
+    changes: List[str] = []
+    data_vizs = [v for v in visualizations if "note_tile" not in v and v.get("id")]
+    mapping = match_tiles(data_vizs, tiles)
+    retyped = 0
+    titled = 0
+    seen_titles: Dict[str, int] = {}
+    for viz in data_vizs:
+        tile = mapping.get(viz["id"])
+        if not tile:
+            continue
+        answer = viz.setdefault("answer", {})
+        title = _unique_title(tile.get("title") or answer.get("name") or viz["id"], seen_titles)
+        if answer.get("name") != title:
+            answer["name"] = title
+            titled += 1
+        if _set_chart_type(answer, tile):
+            retyped += 1
+    unmatched = [v["id"] for v in data_vizs if v["id"] not in mapping]
+    if mapping:
+        changes.append(f"Mirror: matched {len(mapping)} of {len(tiles)} source tile(s) to board answers")
+    if retyped:
+        changes.append(f"Mirror: set {retyped} chart type(s) from the source sheets")
+    if titled:
+        changes.append(f"Mirror: kept {titled} source title(s)")
+    if unmatched:
+        changes.append(f"Mirror: {len(unmatched)} answer(s) had no source tile and keep their own type: "
+                       + ", ".join(unmatched[:6]))
+    missing = [t.get("title") for t in tiles if not any(m is t for m in mapping.values())]
+    if missing:
+        changes.append("Mirror: no answer came back for " + ", ".join(repr(m) for m in missing[:6]))
+    return changes, mapping
+
+
+def match_tiles(vizs: List[Dict[str, Any]], tiles: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+    """viz_id -> tile. Each answer takes the unused tile whose measures,
+    dimensions and date its name, query and columns mention best; position
+    (the MCP board keeps the answers in the order the questions were asked)
+    only breaks ties. A tile is used once; an answer that mentions none of a
+    tile's words stays unmatched."""
+    mapping: Dict[str, Dict[str, Any]] = {}
+    used: set = set()
+    for idx, viz in enumerate(vizs):
+        best, best_key = None, (0.0, 0.0)
+        for j, tile in enumerate(tiles):
+            if id(tile) in used:
+                continue
+            key = (_overlap(viz, tile), -abs(j - idx))
+            if key > best_key:
+                best, best_key = tile, key
+        if best is not None:
+            mapping[viz["id"]] = best
+            used.add(id(best))
+    return mapping
+
+
+#: Words that say how a column is aggregated or bucketed, not which column.
+_FILLER = {"total", "sum", "average", "avg", "count", "unique", "min", "max", "median",
+           "monthly", "weekly", "daily", "quarterly", "yearly", "by", "and", "of", "the"}
+
+
+def _overlap(viz: Dict[str, Any], tile: Dict[str, Any]) -> float:
+    """How well an answer fits a tile: mostly whether the tile's fields are
+    all mentioned (recall), partly whether the answer's columns are only those
+    fields (precision), so a KPI answer does not take a combo tile that
+    wanted one more measure."""
+    answer = viz.get("answer") or {}
+    columns = _answer_column_names(answer) or []
+    have_cols = _words(" ".join(columns)) - _FILLER
+    have = (_words(" ".join([str(answer.get("name") or ""), str(answer.get("search_query") or "")]))
+            | have_cols) - _FILLER
+    want = set()
+    for key in ("measures", "dimensions"):
+        for name in tile.get(key) or []:
+            want |= _words(name)
+    if tile.get("date"):
+        want |= _words(tile["date"])
+    want -= _FILLER
+    if not want:
+        return 0.0
+    recall = len(have & want) / len(want)
+    if recall == 0:
+        return 0.0
+    precision = (len(have_cols & want) / len(have_cols)) if have_cols else recall
+    return 0.7 * recall + 0.3 * precision
+
+
+def _words(text: str) -> set:
+    return {w for w in re.split(r"[^a-z0-9]+", (text or "").lower()) if len(w) > 1}
+
+
+def _unique_title(title: str, seen: Dict[str, int]) -> str:
+    n = seen.get(title, 0) + 1
+    seen[title] = n
+    return title if n == 1 else f"{title} ({n})"
+
+
+def _set_chart_type(answer: Dict[str, Any], tile: Dict[str, Any]) -> bool:
+    """The source chart type on the answer, with axes that match it. Returns
+    True when the answer changed."""
+    want = str(tile.get("chart_type") or "").upper()
+    if not want:
+        return False
+    chart = answer.get("chart") or {}
+    current = str(chart.get("type") or "").upper()
+    if want in TABLE_TYPES:
+        changed = answer.get("display_mode") != "TABLE_MODE" or bool(answer.get("chart"))
+        answer["display_mode"] = "TABLE_MODE"
+        answer.pop("chart", None)
+        return changed
+    columns = _answer_column_names(answer) or _chart_column_names(chart)
+    measures = _ordered(columns, tile.get("measures") or [])
+    dims = _ordered(columns, tile.get("dimensions") or [])
+    date = _first(columns, tile.get("date"))
+    x = [date] if date else dims[:1]
+    color = [d for d in dims if d not in x][:1]
+    answer["display_mode"] = "CHART_MODE"
+    chart = answer.setdefault("chart", {})
+    chart["type"] = want
+    chart.pop("axis_configs", None)
+    chart.pop("custom_chart_config", None)
+    if want == "KPI" or not x or not measures:
+        # A KPI declares nothing; a chart whose columns we cannot see keeps
+        # whatever ThoughtSpot infers (the enhance step's output-column pass
+        # will declare them from the answer later).
+        return current != want
+    if want == COMBO:
+        chart["custom_chart_config"] = _combo_chart_config(x, measures)
+    elif want.startswith("ADVANCED_"):
+        chart["custom_chart_config"] = _advanced_chart_config(x, measures, color, want)
+    else:
+        axis = {"x": x, "y": measures}
+        if color:
+            axis["color"] = color
+        chart["axis_configs"] = [axis]
+    state = _load_chart_client_state(chart)
+    state["axisProperties"] = [
+        {"id": "y-measures", "properties": {"axisType": "Y", "linkedColumns": measures, "isOpposite": False}},
+        {"id": "x-dim", "properties": {"axisType": "X", "linkedColumns": x}},
+    ]
+    chart["client_state_v2"] = json_dumps_compact(state)
+    return True
+
+
+def _ordered(columns: List[str], wanted: List[str]) -> List[str]:
+    """The answer's columns that correspond to `wanted`, in `wanted` order."""
+    out: List[str] = []
+    for name in wanted:
+        hit = _first(columns, name)
+        if hit and hit not in out:
+            out.append(hit)
+    return out
+
+
+def _first(columns: List[str], name: str | None) -> str | None:
+    """The answer column for a tile field. Exact once normalised, else the
+    column whose words (aggregation words aside) cover the field's with the
+    FEWEST extra words: "Target" takes "Total Target", not "Total Sales V
+    Target" (the live board of 2026-10-29 lost its target line to that)."""
+    if not name:
+        return None
+    key = _norm(name)
+    for c in columns:
+        if _norm(c) == key:
+            return c
+    want = _words(name) - _FILLER
+    if not want:
+        return None
+    best, best_extra = None, None
+    for c in columns:
+        have = _words(c) - _FILLER
+        if want <= have:
+            extra = len(have - want)
+            if best is None or extra < best_extra:
+                best, best_extra = c, extra
+    if best is not None:
+        return best
+    for c in columns:
+        have = _words(c) - _FILLER
+        if have and len(want & have) / len(want | have) >= 0.5:
+            return c
+    return None
+
+
+def _norm(name: str) -> str:
+    return re.sub(r"[^a-z0-9]", "", (name or "").lower())
+
+
+# --------------------------------------------------------------------------
+# pass 2: one tab, tiles where the source put them
+# --------------------------------------------------------------------------
+def apply_mirror_layout(liveboard_tml: Dict[str, Any], mirror: Dict[str, Any],
+                        tiles: List[Dict[str, Any]], mapping: Dict[str, Dict[str, Any]]
+                        ) -> Tuple[Dict[str, Any], List[str]]:
+    """Lay the board out like the source dashboard. Mutates and returns the
+    same TML tree (callers keep their reference), plus the change notes."""
+    liveboard = liveboard_tml.setdefault("liveboard", {})
+    vizs = [v for v in liveboard.get("visualizations", []) if "note_tile" not in v and v.get("id")]
+    liveboard["visualizations"] = [v for v in liveboard.get("visualizations", []) if "note_tile" not in v]
+    liveboard.pop("groups", None)
+
+    zones = _zones_by_sheet(mirror)
+    size = _dashboard_size(mirror)
+    placed: List[Dict[str, Any]] = []
+    from_zones = 0
+    for viz in vizs:
+        tile = mapping.get(viz["id"])
+        zone = zones.get(tile.get("sheet")) if tile else None
+        if zone:
+            placed.append({"viz": viz, "tile": tile, **_zone_to_grid(zone, size)})
+            from_zones += 1
+    if from_zones != len(vizs):
+        # No usable dashboard: a grid in tile order, KPIs first in one row.
+        placed = _grid(vizs, mapping)
+        source = "grid (no source dashboard layout)"
+    else:
+        placed.sort(key=lambda p: (p["y"], p["x"]))
+        _resolve_overlaps(placed)
+        source = "source dashboard zones"
+
+    tab_name = _tab_name(mirror)
+    liveboard["layout"] = {"tabs": [{
+        "name": tab_name,
+        "description": f"Rebuilt from the prospect's dashboard ({mirror.get('source_kind', 'source')})",
+        "tiles": [{"visualization_id": p["viz"]["id"], "x": p["x"], "y": p["y"],
+                   "height": p["h"], "width": p["w"]} for p in placed],
+    }]}
+    return liveboard_tml, [f"Mirror layout: 1 tab '{tab_name}', {len(placed)} tile(s) from {source}"]
+
+
+def _tab_name(mirror: Dict[str, Any]) -> str:
+    name = str(mirror.get("mirrored_dashboard") or mirror.get("name") or "Dashboard").strip()
+    return name[:60] or "Dashboard"
+
+
+def _zones_by_sheet(mirror: Dict[str, Any]) -> Dict[str, Dict[str, Any]]:
+    out: Dict[str, Dict[str, Any]] = {}
+    for dash in mirror.get("dashboards") or []:
+        sheet_zones = [z for z in (dash.get("zones") or []) if z.get("kind", "sheet") == "sheet"]
+        if not sheet_zones:
+            continue
+        for z in sheet_zones:
+            out.setdefault(z["sheet"], z)
+        break   # the first dashboard with sheets is the one mirrored
+    return out
+
+
+def _dashboard_size(mirror: Dict[str, Any]) -> Tuple[int, int]:
+    for dash in mirror.get("dashboards") or []:
+        if any(z.get("kind", "sheet") == "sheet" for z in (dash.get("zones") or [])):
+            return int(dash.get("width") or 0), int(dash.get("height") or 0)
+    return 0, 0
+
+
+def _zone_to_grid(zone: Dict[str, Any], size: Tuple[int, int]) -> Dict[str, int]:
+    width, height = size
+    aspect = (height / width) if width and height else 9 / 16
+    rows = max(GRID_COLUMNS, round(GRID_COLUMNS * ROW_UNITS_PER_COLUMN_UNIT * aspect))
+    x = max(0, min(GRID_COLUMNS - MIN_TILE_W, round(float(zone["x"]) * GRID_COLUMNS)))
+    w = max(MIN_TILE_W, round(float(zone["w"]) * GRID_COLUMNS))
+    w = min(w, GRID_COLUMNS - x)
+    y = max(0, round(float(zone["y"]) * rows))
+    h = max(MIN_TILE_H, round(float(zone["h"]) * rows))
+    return {"x": x, "y": y, "w": w, "h": h}
+
+
+def _resolve_overlaps(placed: List[Dict[str, Any]]) -> None:
+    """Push a tile down until it overlaps nothing placed before it."""
+    done: List[Dict[str, Any]] = []
+    for p in placed:
+        while any(_overlaps(p, q) for q in done):
+            p["y"] += 1
+        done.append(p)
+
+
+def _overlaps(a: Dict[str, Any], b: Dict[str, Any]) -> bool:
+    return not (a["x"] + a["w"] <= b["x"] or b["x"] + b["w"] <= a["x"]
+                or a["y"] + a["h"] <= b["y"] or b["y"] + b["h"] <= a["y"])
+
+
+def _grid(vizs: List[Dict[str, Any]], mapping: Dict[str, Dict[str, Any]]) -> List[Dict[str, Any]]:
+    kpis = [v for v in vizs if _type_of(v, mapping) == "KPI"]
+    rest = [v for v in vizs if v not in kpis]
+    placed: List[Dict[str, Any]] = []
+    y = 0
+    if kpis:
+        w = max(2, min(6, GRID_COLUMNS // max(1, min(len(kpis), 6))))
+        per_row = GRID_COLUMNS // w
+        for i, v in enumerate(kpis):
+            placed.append({"viz": v, "tile": mapping.get(v["id"]), "x": (i % per_row) * w,
+                           "y": y + (i // per_row) * KPI_ROW_H, "w": w, "h": KPI_ROW_H})
+        y += ((len(kpis) - 1) // per_row + 1) * KPI_ROW_H
+    x = 0
+    for v in rest:
+        full = _type_of(v, mapping) in TABLE_TYPES or len(rest) == 1
+        w = GRID_COLUMNS if full else GRID_COLUMNS // 2
+        if x + w > GRID_COLUMNS:
+            x, y = 0, y + CHART_ROW_H
+        placed.append({"viz": v, "tile": mapping.get(v["id"]), "x": x, "y": y, "w": w, "h": CHART_ROW_H})
+        x += w
+        if x >= GRID_COLUMNS:
+            x, y = 0, y + CHART_ROW_H
+    return placed
+
+
+def _type_of(viz: Dict[str, Any], mapping: Dict[str, Dict[str, Any]]) -> str:
+    tile = mapping.get(viz.get("id"))
+    if tile and tile.get("chart_type"):
+        return str(tile["chart_type"]).upper()
+    answer = viz.get("answer") or {}
+    if answer.get("display_mode") == "TABLE_MODE":
+        return "TABLE"
+    return str((answer.get("chart") or {}).get("type") or "").upper()

demoprep_app/migration/__init__.py

@@ -0,0 +1,18 @@
+"""DP Migrator: rebuild a prospect's existing dashboard as a DemoPrep demo.
+
+The SE hands Agent Q the prospect's Tableau workbook (.twb, or a .twbx whose
+.twb is read and nothing else) or a screenshot of the dashboard. Either becomes
+one MirrorSpec (spec.py): the fields, tables, joins and sheets the dashboard is
+made of. The spec then does two things in the normal build:
+
+  1. It seeds the blueprint: a custom statement (statement.py) that binds the
+     measure and dimension names so the synthetic data speaks the prospect's
+     vocabulary. The story (planted insights, Spotter questions) is still
+     authored as for any demo.
+  2. It drives the liveboard: one question per source sheet (questions.py) and
+     a mirror layout (demoprep_app/liveboards/mirror_layout.py) that keeps the
+     source chart types, titles and arrangement instead of the golden layout.
+
+No customer data is ever read: a .twbx's extracts are ignored, and connection
+details (server, file path, user) are stripped by the parser.
+"""

demoprep_app/migration/image_spec.py

@@ -0,0 +1,238 @@
+"""A MirrorSpec read off a picture of the dashboard.
+
+One vision call: the image plus a prompt that asks for the same facts the
+Tableau parser reads from a workbook, as JSON. The result is lower confidence
+by construction (a picture carries titles, chart types, axis labels and legend
+values, but no data types, joins or formulas) and the spec says so: every
+sheet's confidence comes from the model, the spec's confidence is their mean,
+and the summary the SE sees lists what was inferred.
+
+The call goes through MultiLLMResearcher (main_research.py), the same client
+every other LLM stage uses, on an Anthropic model: its messages are passed to
+the API as given, so an image block works.
+"""
+from __future__ import annotations
+
+import base64
+import json
+import re
+from statistics import fmean
+from typing import Any
+
+from demoprep_app.migration.mapping import chart_type_for
+from demoprep_app.migration.spec import (
+    CHART_TYPES, FIDELITY_APPROXIMATED, GRAINS, MirrorError, MirrorSpec,
+    ROLE_DATE, ROLE_DIMENSION, ROLE_MEASURE, SOURCE_IMAGE, ShelfField,
+    SourceDashboard, SourceField, SourceSheet, Zone, source_fingerprint,
+)
+
+IMAGE_MAX_TOKENS = 6000
+_TEMPERATURE = 0.1
+
+PROMPT = """You are reading a screenshot of a business intelligence dashboard (Tableau, Power BI, Looker or similar) so it can be rebuilt chart by chart on another platform.
+
+Return ONLY a JSON object (no markdown fences, no commentary) with this shape:
+{
+  "dashboard_name": "<the dashboard's title as shown, or a short descriptive name>",
+  "measures": [{"name": "<as labelled>", "aggregation": "sum|avg|count|count_distinct|min|max|median", "format": "currency|pct|int|float"}],
+  "dimensions": [{"name": "<as labelled>", "sample_values": ["<up to 6 values visible>"]}],
+  "dates": [{"name": "<date field as labelled, e.g. Order Date>", "grain": "day|week|month|quarter|year|"}],
+  "filters": ["<filter controls visible, by field name>"],
+  "sheets": [
+    {
+      "title": "<chart title as shown>",
+      "marks": ["<one or more of: Bar, Line, Area, Pie, Text, Circle, Square, Map>"],
+      "measures": [{"name": "<measure>", "aggregation": "sum|avg|count|count_distinct|min|max|median"}],
+      "x": "<the field on the horizontal axis, or empty>",
+      "y_dimension": "<a dimension on the vertical axis (horizontal bars), or empty>",
+      "color": "<field the marks are coloured/split by, or empty>",
+      "date": {"name": "<date field on an axis, or empty>", "grain": "day|week|month|quarter|year|"},
+      "dual_axis": true/false,
+      "position": {"x": 0.0, "y": 0.0, "w": 0.5, "h": 0.5},
+      "confidence": 0.0
+    }
+  ],
+  "confidence": 0.0,
+  "notes": ["<anything you could not read or had to assume>"]
+}
+
+Rules:
+- One entry in "sheets" per chart, KPI card or table on the dashboard, in reading order (top-left first).
+- A single big number with a label is a sheet with marks ["Text"], one measure, no x and no date.
+- "position" is the chart's bounding box as fractions of the whole dashboard image (0..1).
+- Use the labels exactly as printed. Do not invent fields that are not visible.
+- "confidence" is 0..1: how sure you are of that sheet's fields and type (1 = clearly labelled)."""
+
+
+def image_to_spec(image_arg: str, *, llm_model: str | None = None) -> MirrorSpec:
+    from demoprep_app.portal.login_clone.sources import ScreenshotError, load_screenshot
+
+    try:
+        data = load_screenshot(image_arg)
+    except ScreenshotError as exc:
+        raise MirrorError(f"source_dashboard_image: {exc}") from exc
+    media = _media_type(data)
+    if not media:
+        raise MirrorError("source_dashboard_image must be a png, jpeg or webp image")
+
+    raw = _ask_vision(data, media, llm_model)
+    parsed = _extract_json(raw)
+    if not isinstance(parsed, dict) or not parsed.get("sheets"):
+        raise MirrorError("could not read any chart from the image; send a clearer, larger screenshot "
+                          "of the dashboard (or the workbook file)")
+    spec = _spec_from_json(parsed)
+    spec.source_meta = {"format": "image", "media_type": media, **source_fingerprint(data)}
+    return spec
+
+
+def _ask_vision(data: bytes, media: str, llm_model: str | None) -> str:
+    from llm_config import DEFAULT_LLM_MODEL, map_llm_display_to_provider
+    from main_research import MultiLLMResearcher
+
+    provider, model = map_llm_display_to_provider(llm_model or DEFAULT_LLM_MODEL)
+    if provider != "anthropic":
+        # The image block below is the Anthropic shape; other providers would
+        # need their own. Use the default (Anthropic) model for this one call.
+        provider, model = map_llm_display_to_provider(DEFAULT_LLM_MODEL)
+        if provider != "anthropic":
+            raise MirrorError("reading a dashboard picture needs an Anthropic model; none is configured")
+    researcher = MultiLLMResearcher(provider=provider, model=model)
+    messages = [{"role": "user", "content": [
+        {"type": "image", "source": {"type": "base64", "media_type": media,
+                                     "data": base64.b64encode(data).decode("ascii")}},
+        {"type": "text", "text": PROMPT},
+    ]}]
+    text = researcher.make_request(messages, _TEMPERATURE, IMAGE_MAX_TOKENS, False)
+    if not text:
+        raise MirrorError("the vision model returned nothing for the dashboard picture")
+    return str(text)
+
+
+def _spec_from_json(d: dict[str, Any]) -> MirrorSpec:
+    fields: list[SourceField] = []
+    seen: set[str] = set()
+
+    def add(name: str, role: str, **kw) -> None:
+        name = (name or "").strip()
+        key = name.lower()
+        if name and key not in seen:
+            seen.add(key)
+            fields.append(SourceField(name=name, role=role, **kw))
+
+    for m in d.get("measures") or []:
+        if isinstance(m, dict):
+            add(m.get("name", ""), ROLE_MEASURE, datatype="real",
+                aggregation=_agg(m.get("aggregation")), notes=([f"format {m['format']}"] if m.get("format") else []))
+    for x in d.get("dimensions") or []:
+        if isinstance(x, dict):
+            add(x.get("name", ""), ROLE_DIMENSION,
+                notes=([f"values seen: {', '.join(str(v) for v in x['sample_values'][:6])}"]
+                       if x.get("sample_values") else []))
+    for dt in d.get("dates") or []:
+        if isinstance(dt, dict):
+            add(dt.get("name", ""), ROLE_DATE, datatype="date")
+
+    sheets: list[SourceSheet] = []
+    zones: list[Zone] = []
+    confidences: list[float] = []
+    for i, s in enumerate(d.get("sheets") or [], 1):
+        if not isinstance(s, dict):
+            continue
+        title = str(s.get("title") or f"Chart {i}").strip()
+        name = f"Sheet {i}"
+        measures = [ShelfField(str(m.get("name")).strip(), ROLE_MEASURE, _agg(m.get("aggregation")))
+                    for m in (s.get("measures") or []) if isinstance(m, dict) and m.get("name")]
+        for m in measures:
+            add(m.field, ROLE_MEASURE, datatype="real", aggregation=m.aggregation)
+        rows: list[ShelfField] = list(measures)
+        cols: list[ShelfField] = []
+        y_dim = str(s.get("y_dimension") or "").strip()
+        x_field = str(s.get("x") or "").strip()
+        date = s.get("date") if isinstance(s.get("date"), dict) else {}
+        date_name = str(date.get("name") or "").strip()
+        grain = str(date.get("grain") or "").strip().lower()
+        grain = grain if grain in GRAINS else ""
+        if date_name:
+            add(date_name, ROLE_DATE, datatype="date")
+            cols.append(ShelfField(date_name, ROLE_DATE, grain=grain))
+            if x_field.lower() == date_name.lower():
+                x_field = ""
+        if x_field:
+            add(x_field, ROLE_DIMENSION)
+            cols.append(ShelfField(x_field, ROLE_DIMENSION))
+        if y_dim:
+            # Horizontal bars: the dimension runs down the rows, measures across.
+            add(y_dim, ROLE_DIMENSION)
+            rows, cols = [ShelfField(y_dim, ROLE_DIMENSION)], cols + measures
+        color_name = str(s.get("color") or "").strip()
+        color = None
+        if color_name and color_name.lower() not in {f.field.lower() for f in rows + cols}:
+            add(color_name, ROLE_DIMENSION)
+            color = ShelfField(color_name, ROLE_DIMENSION)
+        marks = [str(m) for m in (s.get("marks") or []) if m]
+        dual = bool(s.get("dual_axis"))
+        chart_type, fidelity, notes = chart_type_for(marks, rows, cols, color, None, dual)
+        conf = _clamp(s.get("confidence"), 0.6)
+        confidences.append(conf)
+        sheet_notes = ["read from a picture: fields and types are inferred"] + notes
+        sheets.append(SourceSheet(
+            name=name, title=title, marks=marks, rows=rows, cols=cols, color=color,
+            dual_axis=dual, chart_type=chart_type, fidelity=FIDELITY_APPROXIMATED,
+            notes=sheet_notes, confidence=conf,
+        ))
+        pos = s.get("position") if isinstance(s.get("position"), dict) else None
+        if pos:
+            zones.append(Zone(sheet=name, x=_clamp(pos.get("x"), 0.0), y=_clamp(pos.get("y"), 0.0),
+                              w=_clamp(pos.get("w"), 0.5), h=_clamp(pos.get("h"), 0.3)))
+
+    dash_name = str(d.get("dashboard_name") or "Dashboard").strip()
+    dashboards = [SourceDashboard(name=dash_name, zones=zones)] if zones else []
+    notes = [str(n) for n in (d.get("notes") or []) if n]
+    filters = [str(f) for f in (d.get("filters") or []) if f]
+    for sh in sheets:
+        sh.filters = list(filters)
+    spec = MirrorSpec(
+        source_kind=SOURCE_IMAGE, name=dash_name, fields=fields, sheets=sheets,
+        dashboards=dashboards,
+        warnings=["read from a picture: no joins, data types or formulas; names as printed"] + notes,
+        confidence=round(fmean(confidences), 2) if confidences else _clamp(d.get("confidence"), 0.5),
+    )
+    return spec
+
+
+def _agg(value: Any) -> str:
+    v = str(value or "").strip().lower()
+    return v if v in {"sum", "avg", "count", "count_distinct", "min", "max", "median"} else "sum"
+
+
+def _clamp(value: Any, default: float) -> float:
+    try:
+        f = float(value)
+    except (TypeError, ValueError):
+        return default
+    return max(0.0, min(1.0, f))
+
+
+def _media_type(data: bytes) -> str:
+    if data[:8] == b"\x89PNG\r\n\x1a\n":
+        return "image/png"
+    if data[:3] == b"\xff\xd8\xff":
+        return "image/jpeg"
+    if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+        return "image/webp"
+    return ""
+
+
+def _extract_json(text: str) -> Any:
+    t = text.strip()
+    t = re.sub(r"\A```(?:json)?\s*|\s*```\Z", "", t, flags=re.I)
+    try:
+        return json.loads(t)
+    except json.JSONDecodeError:
+        start, end = t.find("{"), t.rfind("}")
+        if start >= 0 and end > start:
+            try:
+                return json.loads(t[start:end + 1])
+            except json.JSONDecodeError:
+                return None
+    return None

demoprep_app/migration/mapping.py

@@ -0,0 +1,135 @@
+"""Source chart grammar -> ThoughtSpot chart type.
+
+One function, used by both producers (the Tableau parser and the vision path),
+so a sheet is typed the same way whichever way it came in. The rule set is
+deliberately small and ranked: the first rule that fits wins.
+
+A dual axis is the case this started from (Nick's example, 2026-10-28): two
+measures on one shelf with different mark types (bar + area). ThoughtSpot draws
+that as its combo chart (ADVANCED_LINE_COLUMN: first measure as columns, the
+rest as lines), which golden_layout already knows how to configure so it
+renders. It is an approximation and the notes say so.
+"""
+from __future__ import annotations
+
+from demoprep_app.migration.spec import (
+    FIDELITY_APPROXIMATED, FIDELITY_DROPPED, FIDELITY_EXACT,
+    ROLE_DATE, ROLE_DIMENSION, ROLE_MEASURE, ShelfField,
+)
+
+#: Tableau mark classes, lower-cased, grouped by what they draw.
+_BAR_MARKS = {"bar", "automatic"}
+_LINE_MARKS = {"line"}
+_AREA_MARKS = {"area"}
+_POINT_MARKS = {"circle", "shape", "square"}
+_TEXT_MARKS = {"text"}
+_PIE_MARKS = {"pie"}
+_MAP_MARKS = {"map", "filled map", "filledmap"}
+_UNSUPPORTED_MARKS = {"gantt", "polygon", "density", "multipolygon", "line-polygon"}
+
+_GEO_WORDS = ("country", "state", "province", "city", "zip", "postal", "county", "region", "latitude", "longitude")
+
+
+def chart_type_for(
+    marks: list[str],
+    rows: list[ShelfField],
+    cols: list[ShelfField],
+    color: ShelfField | None = None,
+    size: ShelfField | None = None,
+    dual_axis: bool = False,
+) -> tuple[str, str, list[str]]:
+    """(chart_type, fidelity, notes) for one sheet."""
+    notes: list[str] = []
+    mark_set = {m.strip().lower() for m in marks if m}
+    shelf = list(rows) + list(cols)
+    measures = _unique([f for f in shelf if f.role == ROLE_MEASURE])
+    dims = _unique([f for f in shelf if f.role == ROLE_DIMENSION])
+    date = next((f for f in shelf if f.role == ROLE_DATE), None)
+    color_dim = color if (color and color.role == ROLE_DIMENSION) else None
+    color_measure = color if (color and color.role == ROLE_MEASURE) else None
+    row_measures = [f for f in rows if f.role == ROLE_MEASURE]
+    col_measures = [f for f in cols if f.role == ROLE_MEASURE]
+    row_dims = [f for f in rows if f.role in (ROLE_DIMENSION, ROLE_DATE)]
+    col_dims = [f for f in cols if f.role in (ROLE_DIMENSION, ROLE_DATE)]
+
+    if mark_set & _UNSUPPORTED_MARKS:
+        kind = ", ".join(sorted(mark_set & _UNSUPPORTED_MARKS))
+        notes.append(f"{kind} marks have no ThoughtSpot equivalent; shown as a table")
+        return "TABLE", FIDELITY_APPROXIMATED, notes
+
+    if not measures:
+        if not dims and not date:
+            notes.append("no fields on the sheet")
+            return "TABLE", FIDELITY_DROPPED, notes
+        notes.append("no measure on the sheet; shown as a table of its dimensions")
+        return "TABLE", FIDELITY_APPROXIMATED, notes
+
+    # A lone number: text mark or a bar with nothing to break it down by.
+    if not dims and not date and len(measures) == 1 and (mark_set <= (_TEXT_MARKS | _BAR_MARKS) or not mark_set):
+        return "KPI", FIDELITY_EXACT, notes
+
+    if mark_set & _TEXT_MARKS:
+        if row_dims and col_dims:
+            return "PIVOT_TABLE", FIDELITY_EXACT, notes
+        return "TABLE", FIDELITY_EXACT, notes
+
+    if mark_set & _PIE_MARKS:
+        if len(measures) > 1:
+            notes.append("pie shows the first measure only")
+            return "PIE", FIDELITY_APPROXIMATED, notes
+        return "PIE", FIDELITY_EXACT, notes
+
+    if mark_set & _MAP_MARKS or (not mark_set and _is_geo(dims)):
+        notes.append("map drawn on the model's geo columns; blank if the model has none tagged")
+        return ("GEO_BUBBLE" if size or "circle" in mark_set else "GEO_AREA"), FIDELITY_APPROXIMATED, notes
+
+    # Two measures on opposite shelves and point marks: a scatter.
+    if row_measures and col_measures and (mark_set & _POINT_MARKS or not mark_set) and not date:
+        if len(measures) > 2:
+            notes.append("scatter keeps the first two measures")
+            return "SCATTER", FIDELITY_APPROXIMATED, notes
+        return "SCATTER", FIDELITY_EXACT, notes
+
+    # Square marks coloured by a measure over two dimensions: a heatmap.
+    if "square" in mark_set and color_measure and len(dims) >= 2:
+        return "HEATMAP", FIDELITY_EXACT, notes
+
+    # Size-encoded squares with no axes: a treemap.
+    if size and size.role == ROLE_MEASURE and not row_dims and not col_dims and dims:
+        return "TREEMAP", FIDELITY_EXACT, notes
+
+    # Dual axis / mixed marks over several measures: the combo chart.
+    mixed = bool(mark_set & _BAR_MARKS) and bool(mark_set & (_LINE_MARKS | _AREA_MARKS))
+    if len(measures) >= 2 and (dual_axis or mixed):
+        notes.append("dual axis drawn as a combo chart: first measure as columns, the rest as lines")
+        if color_dim:
+            notes.append(f"colour by {color_dim.field} is not kept on a combo chart")
+        return "ADVANCED_LINE_COLUMN", FIDELITY_APPROXIMATED, notes
+
+    if mark_set & _LINE_MARKS or (date and not mark_set):
+        return "LINE", FIDELITY_EXACT, notes
+
+    if mark_set & _AREA_MARKS:
+        return ("STACKED_AREA" if color_dim else "AREA"), FIDELITY_EXACT, notes
+
+    # Bars: horizontal when the measure runs along the columns shelf and a
+    # dimension sits on rows; stacked when coloured by another dimension.
+    horizontal = bool(col_measures) and bool(row_dims) and not row_measures
+    stacked = color_dim is not None and color_dim.field not in {f.field for f in row_dims + col_dims}
+    if horizontal:
+        return ("STACKED_BAR" if stacked else "BAR"), FIDELITY_EXACT, notes
+    return ("STACKED_COLUMN" if stacked else "COLUMN"), FIDELITY_EXACT, notes
+
+
+def _unique(fields: list[ShelfField]) -> list[ShelfField]:
+    seen: set[str] = set()
+    out = []
+    for f in fields:
+        if f.field not in seen:
+            seen.add(f.field)
+            out.append(f)
+    return out
+
+
+def _is_geo(dims: list[ShelfField]) -> bool:
+    return any(any(w in f.field.lower() for w in _GEO_WORDS) for f in dims)

demoprep_app/migration/questions.py

@@ -0,0 +1,194 @@
+"""One liveboard question per source sheet.
+
+The MCP liveboard path (liveboard_creator.create_liveboard_from_model_mcp)
+asks ThoughtSpot a natural-language question per tile and keeps the answer.
+In mirror mode the questions are not authored by an LLM from the use case:
+each comes from a source sheet, phrased with the MODEL's column names, which
+is why this needs the model columns. A sheet whose measures the model does not
+have cannot render and is dropped, by name, so the SE sees it.
+
+The chart type is NOT in the question: Spotter picks a first type and
+liveboards/mirror_layout.py sets the source type afterwards.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from demoprep_app.migration.spec import (
+    AGG_WORDS, KPI_TYPES, MirrorSpec, ROLE_DATE, ShelfField, SourceSheet,
+)
+
+GRAIN_WORD = {"day": "daily", "week": "weekly", "month": "monthly",
+              "quarter": "quarterly", "year": "yearly"}
+_DATE_TYPES = {"DATE", "DATETIME", "DATE_TIME", "TIMESTAMP", "TIME"}
+_DATE_WORDS = ("date", "_dt", "day", "month", "timestamp", "time")
+
+#: Chart types on which a colour dimension is a real split. On the others
+#: (a plain column chart, a combo, a KPI, a scatter) adding it to the question
+#: would change the shape of the answer, so the colour field is left off.
+#: On a combo chart the first measure is drawn as columns and the rest as
+#: lines. A target-like measure reads as a line over the bars (Nick's example:
+#: Sales as bars, Target as the line), so it goes last whatever shelf order
+#: the source used.
+TARGET_WORDS = ("target", "goal", "budget", "plan", "quota", "forecast", "benchmark")
+#: A variance against a target ("Sales V Target", "Gap to Budget") is not a target.
+_COMPARISON_WORDS = frozenset({"v", "vs", "versus", "variance", "gap", "delta", "diff", "difference",
+                               "minus", "over", "under", "attainment", "pct", "percent", "ratio"})
+
+COLOUR_KEEPING_TYPES = frozenset({
+    "STACKED_COLUMN", "STACKED_BAR", "STACKED_AREA", "LINE", "AREA", "PIE",
+    "DONUT", "HEATMAP", "TREEMAP", "TABLE", "PIVOT_TABLE",
+})
+
+
+def questions_from_spec(spec: MirrorSpec, model_columns: list[dict[str, Any]]
+                        ) -> tuple[list[dict[str, Any]], list[str], list[str]]:
+    """(questions, dropped_sheets, warnings).
+
+    questions: [{question, source: "mirror", sheet, title, chart_type, fidelity,
+                 notes, measures, dimensions, date, grain}] in tile order.
+    model_columns: [{name, type, ...}] as the deployer has them."""
+    names = [str(c.get("name") or "") for c in (model_columns or []) if c.get("name")]
+    date_names = [n for n, c in zip(names, (model_columns or [])) if _is_date_column(c)]
+    questions: list[dict[str, Any]] = []
+    dropped: list[str] = []
+    warnings: list[str] = []
+
+    for sheet in spec.tiles():
+        measures = []
+        for f in sheet.measures:
+            hit = resolve_column(f.field, names)
+            if hit:
+                measures.append((hit, f))
+            else:
+                warnings.append(f'"{sheet.title}": the model has no column for measure {f.field!r}; left off that tile')
+        if not measures:
+            dropped.append(sheet.title)
+            warnings.append(f'"{sheet.title}" dropped: none of its measures are in the model')
+            continue
+        if sheet.chart_type == "ADVANCED_LINE_COLUMN":
+            measures = _columns_first(measures)
+        dims = []
+        for f in _question_dimensions(sheet):
+            hit = resolve_column(f.field, names)
+            if hit:
+                dims.append(hit)
+            else:
+                warnings.append(f'"{sheet.title}": the model has no column for {f.field!r}; left off that tile')
+        date_col, grain = _resolve_date(sheet, names, date_names)
+        if sheet.chart_type in KPI_TYPES and not date_col:
+            warnings.append(f'"{sheet.title}": no date column for the KPI trend; shown as a plain number')
+        questions.append({
+            "question": _phrase(sheet, measures, dims, date_col, grain),
+            "source": "mirror",
+            "sheet": sheet.name,
+            "title": sheet.title,
+            "chart_type": sheet.chart_type,
+            "fidelity": sheet.fidelity,
+            "notes": list(sheet.notes),
+            "measures": [m for m, _ in measures],
+            "dimensions": dims,
+            "date": date_col,
+            "grain": grain,
+        })
+    return questions, dropped, warnings
+
+
+def _columns_first(measures: list[tuple[str, ShelfField]]) -> list[tuple[str, ShelfField]]:
+    """Combo order: the measures that are not target-like first (columns),
+    target-like ones last (lines); otherwise the source order."""
+    plain = [m for m in measures if not _is_target(m[0])]
+    targets = [m for m in measures if _is_target(m[0])]
+    return plain + targets if plain else measures
+
+
+def _is_target(name: str) -> bool:
+    words = _tokens(name)
+    return any(w in words for w in TARGET_WORDS) and not (words & _COMPARISON_WORDS)
+
+
+def _question_dimensions(sheet: SourceSheet) -> list[ShelfField]:
+    dims = list(sheet.axis_dimensions)
+    c = sheet.color
+    if c and c.role != ROLE_DATE and sheet.chart_type in COLOUR_KEEPING_TYPES \
+            and c.field not in {f.field for f in dims}:
+        dims.append(c)
+    return dims
+
+
+def resolve_column(source_name: str, model_names: list[str]) -> str | None:
+    """The model column a source field maps to: an exact match once both are
+    normalised, else the column whose words best cover the source name (F1 over
+    word tokens, at least 0.5). "Sub-Category" finds "Product Sub Category"
+    over "Category"; "Net Sales" finds nothing in a model that only has
+    "Revenue", and the caller says so."""
+    key = _norm(source_name)
+    if not key:
+        return None
+    for n in model_names:
+        if _norm(n) == key:
+            return n
+    src = _tokens(source_name)
+    if not src:
+        return None
+    best, best_score = None, 0.0
+    for n in model_names:
+        t = _tokens(n)
+        if not t:
+            continue
+        hit = len(src & t)
+        if not hit:
+            continue
+        recall, precision = hit / len(src), hit / len(t)
+        score = 2 * recall * precision / (recall + precision)
+        if score > best_score:
+            best, best_score = n, score
+    return best if best_score >= 0.5 else None
+
+
+def _resolve_date(sheet: SourceSheet, names: list[str], date_names: list[str]) -> tuple[str | None, str]:
+    d = sheet.date
+    grain = GRAIN_WORD.get(d.grain, "") if d else ""
+    if d:
+        hit = resolve_column(d.field, names)
+        if hit:
+            return hit, grain or ("monthly" if sheet.chart_type in KPI_TYPES else "")
+    if sheet.chart_type in KPI_TYPES or (d and not d.field):
+        # A KPI wants a trend; any date on the model will do.
+        if date_names:
+            return date_names[0], grain or "monthly"
+    if d and date_names:
+        return date_names[0], grain
+    return None, ""
+
+
+def _phrase(sheet: SourceSheet, measures: list[tuple[str, ShelfField]], dims: list[str],
+            date_col: str | None, grain: str) -> str:
+    parts = [f"{AGG_WORDS.get(f.aggregation or 'sum', 'total')} {name}" for name, f in measures]
+    text = " and ".join(parts)
+    by: list[str] = list(dims)
+    if date_col:
+        by.append(f"{date_col} {grain}".strip())
+    if sheet.chart_type in KPI_TYPES:
+        # "total revenue monthly": the KPI tile's sparkline needs the grain.
+        return f"{text} {grain}".strip() if date_col else text
+    if by:
+        text += " by " + " and ".join(by)
+    return text
+
+
+def _is_date_column(col: dict[str, Any]) -> bool:
+    t = str(col.get("data_type") or col.get("type") or "").upper()
+    if t in _DATE_TYPES:
+        return True
+    n = str(col.get("name") or "").lower()
+    return any(w in n for w in _DATE_WORDS) and t not in {"MEASURE"}
+
+
+def _norm(name: str) -> str:
+    return re.sub(r"[^a-z0-9]", "", (name or "").lower())
+
+
+def _tokens(name: str) -> set[str]:
+    return {t for t in re.split(r"[^a-z0-9]+", (name or "").lower()) if t and t not in {"of", "the", "by"}}

demoprep_app/migration/sources.py

@@ -0,0 +1,132 @@
+"""Reading the SE's source-dashboard arguments into a MirrorSpec.
+
+Two arguments reach the server from Agent Q:
+  source_dashboard        the workbook: the .twb's XML text as is, or a .twbx
+                          (a zip) as a base64 data URI / bare base64. From a
+                          .twbx only the .twb member is read; extracts (.hyper,
+                          .tde, customer data) are never opened.
+  source_dashboard_image  a picture of the dashboard: an https image URL or a
+                          base64 data URI, exactly like homepage_screenshot.
+
+When both are sent the workbook wins (it is exact) and the image is ignored
+with a note. Neither sent: no mirror, the build is an ordinary demo.
+"""
+from __future__ import annotations
+
+import base64
+import binascii
+import io
+import re
+import zipfile
+from typing import Any
+
+from demoprep_app.migration.spec import MirrorError, MirrorSpec, source_fingerprint
+
+TWB_MAX_BYTES = 25_000_000
+TWBX_MAX_BYTES = 200_000_000     # the zip as sent; only its .twb member is read
+_DATA_URI = re.compile(r"\Adata:([\w.+-]+/[\w.+-]+)?(?:;[^,]*)?;base64,(.*)\Z", re.I | re.S)
+_XML_START = re.compile(r"\A\s*(<\?xml|<workbook\b)", re.I)
+
+
+def has_source(file_arg: str, image_arg: str) -> bool:
+    return bool((file_arg or "").strip()) or bool((image_arg or "").strip())
+
+
+def describe_source_arg(value: str) -> str:
+    """What the payload log keeps about `source_dashboard`: kind and size,
+    never the content (a workbook names the prospect's tables and fields)."""
+    v = (value or "").strip()
+    if not v:
+        return ""
+    if _XML_START.match(v):
+        fp = source_fingerprint(v.encode("utf-8", "replace"))
+        return f"<twb xml bytes={fp['bytes']} sha={fp['sha256_12']}>"
+    m = _DATA_URI.match(v)
+    if m:
+        return f"<data uri type={m.group(1) or 'unknown'} chars={len(v)}>"
+    return f"<text chars={len(v)}>"
+
+
+def load_source_dashboard(file_arg: str, image_arg: str, *, llm_model: str | None = None,
+                          ) -> tuple[MirrorSpec | None, list[str]]:
+    """(spec or None, notes). Raises MirrorError when something WAS sent and
+    could not be read: the build must not silently become a generic demo."""
+    notes: list[str] = []
+    file_arg = (file_arg or "").strip()
+    image_arg = (image_arg or "").strip()
+    if not file_arg and not image_arg:
+        return None, notes
+    if file_arg:
+        spec = load_workbook_arg(file_arg)
+        if image_arg:
+            notes.append("source_dashboard_image ignored: the workbook was sent too and is exact")
+        return spec, notes
+    from demoprep_app.migration.image_spec import image_to_spec
+    return image_to_spec(image_arg, llm_model=llm_model), notes
+
+
+def load_workbook_arg(value: str) -> MirrorSpec:
+    """A .twb's XML text, or a .twbx/.twb as a base64 data URI or bare base64."""
+    from demoprep_app.migration.tableau_twb import parse_twb
+
+    v = value.strip()
+    if _XML_START.match(v):
+        if len(v.encode("utf-8", "replace")) > TWB_MAX_BYTES:
+            raise MirrorError(f"the workbook is over {TWB_MAX_BYTES // 1_000_000} MB; send the .twb, not a packaged workbook")
+        return parse_twb(v)
+
+    raw = _decode_base64(v)
+    if raw is None:
+        raise MirrorError("source_dashboard must be the .twb file's XML text, or a .twbx/.twb as a base64 data URI")
+    if raw[:2] == b"PK":
+        return parse_twb(_twb_from_twbx(raw))
+    text = raw.decode("utf-8", "replace")
+    if _XML_START.match(text):
+        return parse_twb(text)
+    raise MirrorError("the decoded file is neither a Tableau workbook (.twb XML) nor a packaged workbook (.twbx zip)")
+
+
+def _decode_base64(v: str) -> bytes | None:
+    m = _DATA_URI.match(v)
+    payload = m.group(2) if m else v
+    payload = re.sub(r"\s+", "", payload)
+    if not payload or len(payload) > TWBX_MAX_BYTES * 4 // 3 + 4:
+        return None
+    try:
+        return base64.b64decode(payload, validate=True)
+    except (binascii.Error, ValueError):
+        return None
+
+
+def _twb_from_twbx(raw: bytes) -> str:
+    """The one .twb inside a .twbx. Nothing else in the archive is opened."""
+    try:
+        zf = zipfile.ZipFile(io.BytesIO(raw))
+    except zipfile.BadZipFile as exc:
+        raise MirrorError("the packaged workbook (.twbx) could not be opened as a zip") from exc
+    members = [i for i in zf.infolist() if i.filename.lower().endswith(".twb") and "/" not in i.filename.strip("/")]
+    if not members:
+        members = [i for i in zf.infolist() if i.filename.lower().endswith(".twb")]
+    if not members:
+        raise MirrorError("the packaged workbook (.twbx) has no .twb inside it")
+    info = members[0]
+    if info.file_size > TWB_MAX_BYTES:
+        raise MirrorError(f"the workbook inside the .twbx is over {TWB_MAX_BYTES // 1_000_000} MB")
+    with zf.open(info) as fh:
+        return fh.read(TWB_MAX_BYTES + 1).decode("utf-8", "replace")
+
+
+def spec_result(spec: MirrorSpec, *, tiles: list[dict[str, Any]] | None = None,
+                dropped: list[str] | None = None, extra_warnings: list[str] | None = None) -> dict[str, Any]:
+    """The `mirror` block of a build result / the inspect tool's answer."""
+    counts = spec.carried_counts()
+    out = spec.summary()
+    out["carried"] = counts
+    if tiles is not None:
+        out["tiles_built"] = [{"title": t["title"], "chart_type": t["chart_type"], "question": t["question"]}
+                              for t in tiles]
+    if dropped:
+        out["tiles_dropped"] = list(dropped)
+    if extra_warnings:
+        out["warnings"] = list(out.get("warnings") or []) + list(extra_warnings)
+    return out

demoprep_app/migration/spec.py

@@ -0,0 +1,351 @@
+"""The mirror spec: one shape for what a legacy dashboard says about its schema
+and its charts, whether it was read from a Tableau workbook or from a picture.
+
+Producers: migration/tableau_twb.py (deterministic, from the .twb XML) and
+migration/image_spec.py (a vision model, lower confidence).
+Consumers: migration/statement.py (blueprint seed), migration/questions.py
+(liveboard questions), liveboards/mirror_layout.py (chart types + layout), and
+the inspect tool (summary()).
+
+Fidelity vocabulary, per sheet:
+  exact        - the chart carries over as is (type, fields, grain)
+  approximated - it carries over with a substitution the notes name
+                 (dual axis drawn as a combo, a table calc left out, ...)
+  dropped      - it cannot carry over; the notes say why
+"""
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass, field, asdict
+from typing import Any
+
+SOURCE_TABLEAU = "tableau_twb"
+SOURCE_IMAGE = "image"
+
+FIDELITY_EXACT = "exact"
+FIDELITY_APPROXIMATED = "approximated"
+FIDELITY_DROPPED = "dropped"
+
+#: ThoughtSpot chart types a mirrored tile may take. Everything the parser or
+#: the vision model emits is checked against this set; anything else is a bug.
+CHART_TYPES = frozenset({
+    "KPI", "COLUMN", "BAR", "STACKED_COLUMN", "STACKED_BAR", "LINE", "AREA",
+    "STACKED_AREA", "PIE", "DONUT", "SCATTER", "HEATMAP", "TREEMAP", "TABLE",
+    "PIVOT_TABLE", "ADVANCED_LINE_COLUMN", "GEO_AREA", "GEO_BUBBLE",
+})
+
+#: Chart types whose tile is a single number: the question needs a time grain
+#: (KPI sparkline/comparison) and the tile goes in the KPI row of a grid.
+KPI_TYPES = frozenset({"KPI"})
+TABLE_TYPES = frozenset({"TABLE", "PIVOT_TABLE"})
+
+ROLE_MEASURE = "measure"
+ROLE_DIMENSION = "dimension"
+ROLE_DATE = "date"
+
+GRAINS = ("day", "week", "month", "quarter", "year")
+
+#: Aggregation words as ThoughtSpot search understands them.
+AGG_WORDS = {
+    "sum": "total", "avg": "average", "count": "count of",
+    "count_distinct": "unique count of", "min": "min", "max": "max",
+    "median": "median",
+}
+
+
+class MirrorError(ValueError):
+    """The source dashboard could not be read. The message is for the SE."""
+
+
+@dataclass(slots=True)
+class SourceField:
+    name: str                       # as the dashboard's user sees it (caption)
+    role: str = ROLE_DIMENSION      # measure | dimension | date
+    datatype: str = "string"        # string | integer | real | date | datetime | boolean
+    table: str = ""                 # source table, "" when unknown (image path)
+    aggregation: str = ""           # measures: sum | avg | count | count_distinct | min | max | median
+    formula: str = ""               # calculated fields: the source formula, verbatim
+    hidden: bool = False
+    notes: list[str] = field(default_factory=list)
+
+    @property
+    def is_calculated(self) -> bool:
+        return bool(self.formula)
+
+
+@dataclass(slots=True)
+class SourceTable:
+    name: str
+    columns: list[str] = field(default_factory=list)
+    kind: str = "table"             # table | custom_sql | union
+    connection: str = ""            # connection CLASS only (excel-direct, snowflake...), never a host or path
+
+
+@dataclass(slots=True)
+class SourceJoin:
+    left_table: str
+    right_table: str
+    left_field: str
+    right_field: str
+    kind: str = "inner"             # inner | left | right | full | blend
+
+
+@dataclass(slots=True)
+class ShelfField:
+    """A field as placed on a shelf or an encoding: with the aggregation or the
+    date grain the sheet applies to it."""
+    field: str
+    role: str = ROLE_DIMENSION
+    aggregation: str = ""           # measures only
+    grain: str = ""                 # dates only: day | week | month | quarter | year
+
+
+@dataclass(slots=True)
+class SourceSheet:
+    name: str
+    title: str = ""                 # shown title; falls back to name
+    marks: list[str] = field(default_factory=list)   # source mark types seen, e.g. ["Bar", "Area"]
+    rows: list[ShelfField] = field(default_factory=list)
+    cols: list[ShelfField] = field(default_factory=list)
+    color: ShelfField | None = None
+    size: ShelfField | None = None
+    detail: list[ShelfField] = field(default_factory=list)
+    filters: list[str] = field(default_factory=list)  # field names filtered on the sheet
+    dual_axis: bool = False
+    chart_type: str = "TABLE"       # one of CHART_TYPES
+    fidelity: str = FIDELITY_EXACT
+    notes: list[str] = field(default_factory=list)
+    confidence: float = 1.0
+
+    def __post_init__(self) -> None:
+        if self.chart_type not in CHART_TYPES:
+            raise ValueError(f"sheet {self.name!r}: unknown chart type {self.chart_type!r}")
+        if self.fidelity not in (FIDELITY_EXACT, FIDELITY_APPROXIMATED, FIDELITY_DROPPED):
+            raise ValueError(f"sheet {self.name!r}: unknown fidelity {self.fidelity!r}")
+        if not self.title:
+            self.title = self.name
+
+    @property
+    def shelf_fields(self) -> list[ShelfField]:
+        out = list(self.rows) + list(self.cols)
+        if self.color:
+            out.append(self.color)
+        if self.size:
+            out.append(self.size)
+        out.extend(self.detail)
+        return out
+
+    @property
+    def measures(self) -> list[ShelfField]:
+        seen: set[str] = set()
+        out = []
+        for f in self.shelf_fields:
+            if f.role == ROLE_MEASURE and f.field not in seen:
+                seen.add(f.field)
+                out.append(f)
+        return out
+
+    @property
+    def dimensions(self) -> list[ShelfField]:
+        seen: set[str] = set()
+        out = []
+        for f in self.shelf_fields:
+            if f.role == ROLE_DIMENSION and f.field not in seen:
+                seen.add(f.field)
+                out.append(f)
+        return out
+
+    @property
+    def axis_dimensions(self) -> list[ShelfField]:
+        """Dimensions on the rows/cols shelves only: what the chart breaks down
+        by, before colour, size or detail."""
+        seen: set[str] = set()
+        out = []
+        for f in list(self.rows) + list(self.cols):
+            if f.role == ROLE_DIMENSION and f.field not in seen:
+                seen.add(f.field)
+                out.append(f)
+        return out
+
+    @property
+    def date(self) -> ShelfField | None:
+        for f in self.shelf_fields:
+            if f.role == ROLE_DATE:
+                return f
+        return None
+
+
+@dataclass(slots=True)
+class Zone:
+    """Where a sheet sits on a dashboard, as fractions of the dashboard."""
+    sheet: str
+    x: float
+    y: float
+    w: float
+    h: float
+    kind: str = "sheet"             # sheet | text | filter | other
+
+
+@dataclass(slots=True)
+class SourceDashboard:
+    name: str
+    width: int = 0                  # px, 0 when unknown
+    height: int = 0
+    zones: list[Zone] = field(default_factory=list)
+
+    @property
+    def sheet_names(self) -> list[str]:
+        """Sheets on this dashboard, top-to-bottom then left-to-right."""
+        ordered = sorted((z for z in self.zones if z.kind == "sheet"), key=lambda z: (round(z.y, 2), z.x))
+        out: list[str] = []
+        for z in ordered:
+            if z.sheet not in out:
+                out.append(z.sheet)
+        return out
+
+
+@dataclass(slots=True)
+class MirrorSpec:
+    source_kind: str                # tableau_twb | image
+    name: str                       # workbook / dashboard title
+    tables: list[SourceTable] = field(default_factory=list)
+    joins: list[SourceJoin] = field(default_factory=list)
+    fields: list[SourceField] = field(default_factory=list)
+    sheets: list[SourceSheet] = field(default_factory=list)
+    dashboards: list[SourceDashboard] = field(default_factory=list)
+    parameters: list[str] = field(default_factory=list)   # names of parameters/sets not carried
+    warnings: list[str] = field(default_factory=list)
+    confidence: float = 1.0
+    source_meta: dict[str, Any] = field(default_factory=dict)   # version, bytes, sha (no content)
+
+    # ---- fields by role -------------------------------------------------
+    def measures(self) -> list[SourceField]:
+        return [f for f in self.fields if f.role == ROLE_MEASURE and not f.hidden]
+
+    def dimensions(self) -> list[SourceField]:
+        return [f for f in self.fields if f.role == ROLE_DIMENSION and not f.hidden]
+
+    def date_fields(self) -> list[SourceField]:
+        return [f for f in self.fields if f.role == ROLE_DATE and not f.hidden]
+
+    def field_named(self, name: str) -> SourceField | None:
+        key = _norm(name)
+        for f in self.fields:
+            if _norm(f.name) == key:
+                return f
+        return None
+
+    # ---- what becomes a tile ----------------------------------------------
+    def primary_dashboard(self) -> SourceDashboard | None:
+        """The dashboard that is mirrored: the first one with sheets on it."""
+        for d in self.dashboards:
+            if d.sheet_names:
+                return d
+        return None
+
+    def tiles(self) -> list[SourceSheet]:
+        """Sheets that become tiles, in reading order. The first dashboard's
+        sheets when there is one, else every sheet in workbook order. Dropped
+        sheets are left out (the summary still lists them)."""
+        by_name = {s.name: s for s in self.sheets}
+        dash = self.primary_dashboard()
+        names = dash.sheet_names if dash else [s.name for s in self.sheets]
+        out = []
+        for n in names:
+            s = by_name.get(n)
+            if s is not None and s.fidelity != FIDELITY_DROPPED:
+                out.append(s)
+        return out
+
+    def zone_for(self, sheet_name: str) -> Zone | None:
+        dash = self.primary_dashboard()
+        if not dash:
+            return None
+        for z in dash.zones:
+            if z.kind == "sheet" and z.sheet == sheet_name:
+                return z
+        return None
+
+    # ---- serialisation ------------------------------------------------------
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "MirrorSpec":
+        def shelf(d):
+            return ShelfField(**d) if d else None
+
+        sheets = []
+        for s in data.get("sheets") or []:
+            s = dict(s)
+            s["rows"] = [ShelfField(**x) for x in s.get("rows") or []]
+            s["cols"] = [ShelfField(**x) for x in s.get("cols") or []]
+            s["detail"] = [ShelfField(**x) for x in s.get("detail") or []]
+            s["color"] = shelf(s.get("color"))
+            s["size"] = shelf(s.get("size"))
+            sheets.append(SourceSheet(**s))
+        dashboards = []
+        for d in data.get("dashboards") or []:
+            d = dict(d)
+            d["zones"] = [Zone(**z) for z in d.get("zones") or []]
+            dashboards.append(SourceDashboard(**d))
+        return cls(
+            source_kind=data["source_kind"],
+            name=data.get("name") or "",
+            tables=[SourceTable(**t) for t in data.get("tables") or []],
+            joins=[SourceJoin(**j) for j in data.get("joins") or []],
+            fields=[SourceField(**f) for f in data.get("fields") or []],
+            sheets=sheets,
+            dashboards=dashboards,
+            parameters=list(data.get("parameters") or []),
+            warnings=list(data.get("warnings") or []),
+            confidence=float(data.get("confidence", 1.0)),
+            source_meta=dict(data.get("source_meta") or {}),
+        )
+
+    def summary(self) -> dict[str, Any]:
+        """What the inspect tool returns and the build result carries: enough
+        for the SE to see what carries over, nothing that could leak data."""
+        dash = self.primary_dashboard()
+        return {
+            "source_kind": self.source_kind,
+            "name": self.name,
+            "confidence": round(self.confidence, 2),
+            "tables": [{"name": t.name, "columns": len(t.columns), "kind": t.kind,
+                        "connection": t.connection} for t in self.tables],
+            "joins": [f"{j.left_table}.{j.left_field} {j.kind} {j.right_table}.{j.right_field}"
+                      for j in self.joins],
+            "measures": [{"name": f.name, "aggregation": f.aggregation or "sum",
+                          **({"formula": f.formula} if f.formula else {})} for f in self.measures()],
+            "dimensions": [f.name for f in self.dimensions()],
+            "dates": [f.name for f in self.date_fields()],
+            "dashboards": [d.name for d in self.dashboards],
+            "mirrored_dashboard": dash.name if dash else "",
+            "sheets": [{
+                "name": s.name, "title": s.title, "chart_type": s.chart_type,
+                "measures": [f.field for f in s.measures],
+                "dimensions": [f.field for f in s.dimensions],
+                "date": (s.date.field + (f" ({s.date.grain})" if s.date.grain else "")) if s.date else "",
+                "fidelity": s.fidelity, "notes": list(s.notes),
+            } for s in self.sheets],
+            "tiles": [s.name for s in self.tiles()],
+            "parameters_not_carried": list(self.parameters),
+            "warnings": list(self.warnings),
+            "source": dict(self.source_meta),
+        }
+
+    def carried_counts(self) -> dict[str, int]:
+        counts = {FIDELITY_EXACT: 0, FIDELITY_APPROXIMATED: 0, FIDELITY_DROPPED: 0}
+        for s in self.sheets:
+            counts[s.fidelity] += 1
+        return counts
+
+
+def _norm(name: str) -> str:
+    return "".join(ch for ch in (name or "").lower() if ch.isalnum())
+
+
+def source_fingerprint(data: bytes) -> dict[str, Any]:
+    """What the payload log and the summary keep about the file: size and a
+    short hash. Never the content."""
+    return {"bytes": len(data), "sha256_12": hashlib.sha256(data).hexdigest()[:12]}

demoprep_app/migration/statement.py

@@ -0,0 +1,164 @@
+"""The mirror spec as a custom request for the blueprint author.
+
+The blueprint LLM reads the SE's request verbatim (blueprint_author.py puts it
+under <user_request>). This renders the spec as that request: the measure and
+dimension names the prospect's users know, the date and its grain, the
+calculated fields to re-express, and the charts the board will recreate, so
+the synthetic data speaks the dashboard's vocabulary. The story (planted
+insights, Spotter questions) is still the author's job, as for any demo.
+
+Wording matters: directives.py reads "do not create/include/use/build/generate/
+add X" in a request as a binding prohibition, so this text never says it.
+"""
+from __future__ import annotations
+
+import re
+
+from demoprep_app.migration.spec import (
+    MirrorSpec, SOURCE_TABLEAU, SourceField, SourceSheet, AGG_WORDS,
+)
+
+HEADING = "## Source dashboard to mirror (DP Migrator)"
+
+#: Tableau bookkeeping fields that are not business columns.
+_SKIP_NAMES = {"number of records", "measure names", "measure values"}
+
+
+def statement_from_spec(spec: MirrorSpec) -> str:
+    """The request text appended to the SE's use case for the blueprint stage."""
+    origin = ("read from their Tableau workbook" if spec.source_kind == SOURCE_TABLEAU
+              else "read from a screenshot of it")
+    lines = [HEADING, (
+        f'This demo recreates the prospect\'s existing dashboard "{spec.name}" ({origin}). '
+        "Use ITS vocabulary: the measure and dimension names below are the names the "
+        "prospect's users already know. Keep each one as a column (same words; spaces "
+        "become underscores) so the rebuilt charts read like theirs. Add only what the "
+        "star schema needs around them (keys, a few descriptive attributes)."
+    )]
+
+    base = [f for f in spec.measures() if not f.is_calculated and _keep(f)]
+    calcs = [f for f in spec.measures() if f.is_calculated and _keep(f)]
+    dims = _business_dimensions(spec)
+    dates = [f for f in spec.date_fields() if _keep(f)]
+
+    if base:
+        lines.append("Measures, each a measure on the fact with this aggregation: "
+                     + "; ".join(f"{f.name} ({f.aggregation or 'sum'})" for f in base) + ".")
+    if calcs:
+        lines.append("Calculated measures: re-express each as a derived measure with an arithmetic "
+                     "formula over the base measures, as close as the data allows: "
+                     + "; ".join(f"{f.name} = {clean_formula(f.formula)}" for f in calcs) + ".")
+    if dims:
+        lines.append("Dimensions, each a dimension table or an attribute column of one: "
+                     + ", ".join(f.name for f in dims) + ". Group attributes that describe the same "
+                     "entity into one dimension (a product's category and sub-category; a customer's "
+                     "segment; a location's region, country, state and city).")
+    if dates:
+        grain = _dominant_grain(spec)
+        primary = dates[0].name
+        lines.append(f"Date: {primary} is the date on the charts"
+                     + (f" ({grain} grain)" if grain else "")
+                     + f"; the fact's date column is named {primary}. At least 24 months of history.")
+    if spec.tables:
+        lines.append("Source tables, for context only (model a clean star schema from them): "
+                     + "; ".join(_table_line(spec, t.name) for t in spec.tables) + ".")
+    tiles = spec.tiles()
+    if tiles:
+        lines.append("Charts the liveboard recreates (keep every measure and dimension they use): "
+                     + " ".join(f"{i}. {_sheet_line(s)}" for i, s in enumerate(tiles, 1)))
+    return "\n".join(lines)
+
+
+_SOURCE_ID = re.compile(r"\[federated\.[^\]]+\]\.")
+_TABLE_SUFFIX = re.compile(r"\s*\([^()]*\)\s*$")
+
+
+def clean_formula(formula: str) -> str:
+    """A source formula without Tableau's internal datasource ids:
+    SUM([federated.1lm8...].[Target]) -> SUM([Target])."""
+    return _SOURCE_ID.sub("", formula or "").strip()
+
+
+def _business_dimensions(spec: MirrorSpec) -> list[SourceField]:
+    """Dimensions worth naming: not join keys (the blueprint adds its own),
+    and not a table-qualified duplicate of another field ("Order ID
+    (OrderBreakdown)")."""
+    keys = {j.left_field.lower() for j in spec.joins} | {j.right_field.lower() for j in spec.joins}
+    names = {f.name.lower() for f in spec.fields}
+    out = []
+    for f in spec.dimensions():
+        if not _keep(f) or f.name.lower() in keys:
+            continue
+        base = _TABLE_SUFFIX.sub("", f.name)
+        if base != f.name and base.lower() in names:
+            continue
+        if base.lower() in keys:
+            continue
+        out.append(f)
+    return out
+
+
+def _keep(f: SourceField) -> bool:
+    if f.hidden:
+        return False
+    if f.name.strip().lower() in _SKIP_NAMES:
+        return False
+    if f.is_calculated and f.formula.strip() == "1":
+        return False
+    return True
+
+
+def _dominant_grain(spec: MirrorSpec) -> str:
+    """The grain most sheets use on their date, as a word ("monthly")."""
+    counts: dict[str, int] = {}
+    for sheet in spec.sheets:
+        d = sheet.date
+        if d and d.grain:
+            counts[d.grain] = counts.get(d.grain, 0) + 1
+    if not counts:
+        return ""
+    return _grain_word(max(counts.items(), key=lambda kv: kv[1])[0])
+
+
+def _grain_word(grain: str) -> str:
+    return {"day": "daily", "week": "weekly", "month": "monthly",
+            "quarter": "quarterly", "year": "yearly"}.get(grain, grain)
+
+
+def _table_line(spec: MirrorSpec, table: str) -> str:
+    t = next((x for x in spec.tables if x.name == table), None)
+    cols = f" ({len(t.columns)} columns)" if t and t.columns else ""
+    joins = [j for j in spec.joins if table in (j.left_table, j.right_table)]
+    if not joins:
+        return f"{table}{cols}"
+    parts = []
+    for j in joins:
+        other = j.right_table if j.left_table == table else j.left_table
+        how = "blended with" if j.kind == "blend" else f"{j.kind} join to"
+        on = f" on {j.left_field}" if j.left_field else ""
+        parts.append(f"{how} {other}{on}")
+    return f"{table}{cols}, " + ", ".join(parts)
+
+
+def _sheet_line(s: SourceSheet) -> str:
+    measures = ", ".join(f.field for f in s.measures) or "no measure"
+    by = [f.field for f in s.axis_dimensions]
+    if s.date:
+        by.append(s.date.field + (f" ({s.date.grain})" if s.date.grain else ""))
+    text = f'"{s.title}": {measures}'
+    if by:
+        text += " by " + ", ".join(by)
+    if s.color and s.color.field not in {f.field for f in s.axis_dimensions}:
+        text += f", colour by {s.color.field}"
+    return text + f" [{chart_words(s.chart_type)}]."
+
+
+_CHART_WORDS = {
+    "ADVANCED_LINE_COLUMN": "combo chart: columns and lines",
+    "KPI": "KPI card", "TABLE": "table", "PIVOT_TABLE": "pivot table",
+    "GEO_AREA": "filled map", "GEO_BUBBLE": "bubble map",
+}
+
+
+def chart_words(chart_type: str) -> str:
+    return _CHART_WORDS.get(chart_type, chart_type.lower().replace("_", " ") + " chart")

demoprep_app/migration/tableau_twb.py

@@ -0,0 +1,860 @@
+"""Tableau workbook (.twb XML) -> MirrorSpec, deterministically.
+
+The grammar this reads (verified on tests/fixtures/tableau_dual_axis_example.twb):
+
+  <workbook version source-build>
+    <datasources><datasource caption name>            one per data source; name='Parameters' holds parameters
+      <connection class='federated'>
+        <named-connections><named-connection><connection class=.../>   the class is all we keep
+        <relation type='join' join='inner'><clause><expression op='='>  legacy joins, nested relations
+          <relation type='table' name><columns><column datatype name/>  physical tables (also under
+                                                                        2020.2+ <object-graph>/<object>)
+        <relationships><relationship><expression op='='>...             2020.2+ logical layer
+        <metadata-records><metadata-record class='column'>              local-name, parent-name, local-type, aggregation
+      <column caption name role datatype hidden><calculation formula/>  display names, roles, calculated fields
+    <datasource-relationships>                                          blends: which data sources share columns
+    <worksheets><worksheet name><table><view>                           datasource-dependencies, <filter column>
+      <panes><pane y-axis-name><mark class/><encodings><color column/>
+      <rows>/<cols>  shelf text: [<datasource id>].[<prefix>:<Field>:<suffix>] tokens joined by ' + '
+    <dashboards><dashboard name><size/><zones><zone name type x y w h>   1/100000 units; <devicelayouts> skipped
+
+Shelf prefixes: sum/avg/cnt/ctd/min/max/mdn/usr are aggregations, yr/qr/mn/wk/dy (and the t* truncations)
+are date grains, none is a plain dimension. Nothing that identifies the file, host or user is kept:
+connection details are reduced to the class and Tableau's internal data-source ids never reach a name.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any, Iterator
+from xml.etree.ElementTree import Element
+
+from defusedxml import DefusedXmlException
+from defusedxml.ElementTree import ParseError, fromstring
+
+from demoprep_app.migration.mapping import chart_type_for
+from demoprep_app.migration.spec import (
+    FIDELITY_APPROXIMATED, FIDELITY_EXACT, MirrorError, MirrorSpec,
+    ROLE_DATE, ROLE_DIMENSION, ROLE_MEASURE, SOURCE_TABLEAU, ShelfField,
+    SourceDashboard, SourceField, SourceJoin, SourceSheet, SourceTable, Zone,
+    source_fingerprint,
+)
+
+MAX_BYTES = 25 * 1024 * 1024
+PARAMETERS_DATASOURCE = "Parameters"
+ZONE_UNITS = 100_000.0
+
+#: Shelf-token prefixes that aggregate a field -> the spec's aggregation word.
+_AGG_PREFIX = {
+    "sum": "sum", "avg": "avg", "cnt": "count", "ctd": "count_distinct",
+    "min": "min", "max": "max", "mdn": "median", "usr": "sum",
+}
+#: Shelf-token prefixes that derive a date part or truncation -> grain.
+_DATE_PREFIX = {
+    "yr": "year", "tyr": "year", "qr": "quarter", "tqr": "quarter",
+    "mn": "month", "tmn": "month", "my": "month", "tmy": "month",
+    "wk": "week", "twk": "week", "dy": "day", "tdy": "day", "mdy": "day", "tmdy": "day",
+    "hr": "", "thr": "", "mi": "", "tmi": "", "sc": "", "tsc": "",
+}
+#: metadata-record <aggregation> words -> the spec's aggregation word.
+_META_AGG = {
+    "sum": "sum", "average": "avg", "avg": "avg", "count": "count", "countd": "count_distinct",
+    "min": "min", "max": "max", "median": "median",
+}
+_JOIN_KINDS = {"inner", "left", "right", "full"}
+_DATE_TYPES = {"date", "datetime"}
+_NUMERIC_TYPES = {"integer", "real"}
+_OMIT_FIELDS = {"[number of records]", "[measure values]", "[multiple values]"}
+_LOD_MARKERS = ("{FIXED", "{INCLUDE", "{EXCLUDE")
+_TEXT_ZONES = {"text", "title"}
+_FILTER_ZONES = {"filter", "paramctrl", "legend", "color"}
+_CONTAINER_ZONES = {"layout-basic", "layout-flow"}
+
+_CALC_NAME = re.compile(r"^Calculation_\d+$")
+#: [<datasource id>].[<token>] or a bare [<token>]; ']]' escapes a ']' inside a name.
+_TOKEN = re.compile(r"(?:\[((?:[^\]]|\]\])*)\]\.)?\[((?:[^\]]|\]\])*)\]")
+_GROUP = re.compile(r"\(([^()]*)\)")
+
+
+# ---------------------------------------------------------------------------
+# public API
+# ---------------------------------------------------------------------------
+
+def parse_twb(xml_text: str) -> MirrorSpec:
+    """Read a Tableau workbook's XML into a MirrorSpec. Raises MirrorError when
+    the text is empty, too large, not XML, or not a workbook."""
+    root, data = _parse_root(xml_text)
+    warnings: list[str] = []
+
+    datasources, parameters = _read_datasources(root, warnings)
+    by_id = {ds.id: ds for ds in datasources}
+    if parameters:
+        _warn(warnings, f"{len(parameters)} parameter(s) are not carried: {', '.join(parameters)}")
+
+    fields = _merge_fields(datasources)
+    tables = _merge_tables(datasources)
+    joins = _merge_joins(datasources)
+
+    sheets: list[SourceSheet] = []
+    blends: list[tuple[str, ...]] = []
+    for ws in _worksheets(root):
+        sheet, dep_ids = _read_worksheet(ws, by_id, warnings)
+        if sheet is None:
+            continue
+        sheets.append(sheet)
+        if len(dep_ids) >= 2:
+            blends.append(tuple(dep_ids))
+    joins.extend(_read_blends(root, blends, by_id, warnings))
+
+    dashboards = _read_dashboards(root, {s.name for s in sheets}, warnings)
+
+    if dashboards:
+        name = dashboards[0].name
+    elif sheets:
+        name = sheets[0].name
+    else:
+        name = "Tableau workbook"
+
+    source_build = root.get("source-build", "")
+    confidence = 1.0
+    if not source_build and not fields:
+        confidence = 0.5
+        _warn(warnings, "No source build and no fields were found; this may not be a complete Tableau workbook")
+
+    meta: dict[str, Any] = {
+        "format": "twb",
+        "tableau_version": root.get("version", ""),
+        "source_build": source_build,
+        "worksheets": len(sheets),
+        "dashboards": len(dashboards),
+    }
+    meta.update(source_fingerprint(data))
+
+    return MirrorSpec(
+        source_kind=SOURCE_TABLEAU, name=name, tables=tables, joins=joins, fields=fields,
+        sheets=sheets, dashboards=dashboards, parameters=parameters, warnings=warnings,
+        confidence=confidence, source_meta=meta,
+    )
+
+
+# ---------------------------------------------------------------------------
+# input
+# ---------------------------------------------------------------------------
+
+def _parse_root(xml_text: str) -> tuple[Element, bytes]:
+    if not isinstance(xml_text, str) or not xml_text.strip():
+        raise MirrorError("The workbook is empty. Send the .twb file's contents (a .twbx must be unpacked first).")
+    text = xml_text.lstrip("")
+    data = text.encode("utf-8")
+    if len(data) > MAX_BYTES:
+        raise MirrorError(
+            f"The workbook is {len(data) / (1024 * 1024):.0f} MB; DP Migrator reads .twb files up to 25 MB. "
+            "A .twb that large usually carries embedded data: save it without extracts and send it again."
+        )
+    try:
+        root = fromstring(text)
+    except (ParseError, DefusedXmlException):
+        raise MirrorError(
+            "This file is not a Tableau workbook: it could not be read as XML. "
+            "Send the .twb itself (unpack a .twbx first), saved from Tableau Desktop."
+        ) from None
+    if root.tag != "workbook":
+        raise MirrorError(
+            f"This XML is not a Tableau workbook: its top element is <{root.tag}>, a .twb starts with <workbook>."
+        )
+    return root, data
+
+
+def _warn(warnings: list[str], message: str) -> None:
+    if message not in warnings:
+        warnings.append(message)
+
+
+# ---------------------------------------------------------------------------
+# data sources
+# ---------------------------------------------------------------------------
+
+@dataclass
+class _Datasource:
+    id: str
+    caption: str
+    fields: dict[str, SourceField] = field(default_factory=dict)   # by bracketed local name, in order
+    tables: list[SourceTable] = field(default_factory=list)
+    joins: list[SourceJoin] = field(default_factory=list)
+
+
+def _read_datasources(root: Element, warnings: list[str]) -> tuple[list[_Datasource], list[str]]:
+    container = root.find("datasources")
+    datasources: list[_Datasource] = []
+    parameters: list[str] = []
+    calc_counter = [0]
+    if container is None:
+        return datasources, parameters
+    for n, ds_el in enumerate(container.findall("datasource"), 1):
+        if ds_el.get("name") == PARAMETERS_DATASOURCE:
+            parameters.extend(_read_parameters(ds_el))
+            continue
+        ds = _Datasource(id=ds_el.get("name", ""), caption=ds_el.get("caption") or f"Data source {n}")
+        classes = _connection_classes(ds_el)
+        _read_tables(ds_el, ds, classes, warnings)
+        _read_legacy_joins(ds_el, ds, warnings)
+        _read_relationships(ds_el, ds, warnings)
+        _read_metadata_fields(ds_el, ds, warnings)
+        _read_column_fields(ds_el, ds, calc_counter, warnings)
+        datasources.append(ds)
+    return datasources, parameters
+
+
+def _read_parameters(ds_el: Element) -> list[str]:
+    out: list[str] = []
+    for col in ds_el.findall("column"):
+        name = col.get("caption") or _unbracket(col.get("name", ""))
+        if name and name not in out:
+            out.append(name)
+    return out
+
+
+def _connection_classes(ds_el: Element) -> dict[str, str]:
+    """named-connection name -> connection class; '' -> the class to use when a
+    relation names no connection. Only the class is read, never a host or path."""
+    classes: dict[str, str] = {}
+    conn = ds_el.find("connection")
+    if conn is None:
+        return classes
+    for named in conn.iter("named-connection"):
+        inner = named.find("connection")
+        if inner is not None and inner.get("class"):
+            classes[named.get("name", "")] = inner.get("class", "")
+    top = conn.get("class", "")
+    if top and top != "federated":
+        classes[""] = top
+    elif len(classes) == 1:
+        classes[""] = next(iter(classes.values()))
+    return classes
+
+
+def _read_tables(ds_el: Element, ds: _Datasource, classes: dict[str, str], warnings: list[str]) -> None:
+    for rel in ds_el.iter("relation"):
+        kind = rel.get("type", "")
+        if kind not in ("table", "text", "union"):
+            continue
+        name = rel.get("name") or ""
+        if not name:
+            _warn(warnings, f"A {kind} relation in {ds.caption} has no name; skipped")
+            continue
+        connection = classes.get(rel.get("connection", ""), classes.get("", ""))
+        columns: list[str] = []
+        if kind == "text":
+            _warn(warnings, f"Custom SQL ({name}) in {ds.caption} was not read; its columns are not listed")
+            table_kind = "custom_sql"
+        else:
+            table_kind = "union" if kind == "union" else "table"
+            cols = rel.find("columns")
+            if cols is not None:
+                columns = [c.get("name", "") for c in cols.findall("column") if c.get("name")]
+        existing = next((t for t in ds.tables if t.name == name), None)
+        if existing is None:
+            ds.tables.append(SourceTable(name=name, columns=columns, kind=table_kind, connection=connection))
+        elif columns and not existing.columns:
+            existing.columns = columns
+
+
+def _read_legacy_joins(ds_el: Element, ds: _Datasource, warnings: list[str]) -> None:
+    for rel in ds_el.iter("relation"):
+        if rel.get("type") != "join":
+            continue
+        kind = (rel.get("join") or "inner").lower()
+        if kind not in _JOIN_KINDS:
+            _warn(warnings, f"Join type {kind!r} in {ds.caption} is not understood; read as inner")
+            kind = "inner"
+        sides = [c.get("name", "") for c in rel.findall("relation") if c.get("type") == "table"]
+        for clause in rel.findall("clause"):
+            for expr in clause.findall("expression"):
+                join = _join_from_expression(expr, sides, kind, {}, ds.caption, warnings)
+                if join is not None:
+                    ds.joins.append(join)
+
+
+def _read_relationships(ds_el: Element, ds: _Datasource, warnings: list[str]) -> None:
+    objects = _object_names(ds_el)
+    count = 0
+    for rel in ds_el.iter("relationship"):
+        count += 1
+        ends = [e.get("object-id", "") for e in (rel.find("first-end-point"), rel.find("second-end-point"))
+                if e is not None]
+        sides = [objects.get(e, e) for e in ends]
+        found = False
+        for expr in rel.iter("expression"):
+            if expr.get("op") == "=" and len(expr.findall("expression")) == 2:
+                join = _join_from_expression(expr, sides, "inner", objects, ds.caption, warnings)
+                if join is not None:
+                    ds.joins.append(join)
+                    found = True
+        if not found:
+            _warn(warnings, f"A relationship in {ds.caption} has no readable equality condition; skipped")
+    if count:
+        _warn(warnings, f"{count} relationship(s) read as inner joins")
+
+
+def _object_names(ds_el: Element) -> dict[str, str]:
+    """2020.2+ object-model ids -> the physical table name (what the tables list
+    uses), else the object's caption."""
+    out: dict[str, str] = {}
+    for obj in ds_el.iter("object"):
+        obj_id = obj.get("id", "")
+        if not obj_id:
+            continue
+        table = next((r.get("name", "") for r in obj.iter("relation") if r.get("type") == "table"), "")
+        out[obj_id] = table or obj.get("caption") or obj_id
+    return out
+
+
+def _join_from_expression(expr: Element, sides: list[str], kind: str, objects: dict[str, str],
+                          ds_caption: str, warnings: list[str]) -> SourceJoin | None:
+    op = expr.get("op", "")
+    if op != "=":
+        _warn(warnings, f"A join in {ds_caption} uses the operator {op!r}; only equality joins are carried")
+        return None
+    refs = [e.get("op", "") for e in expr.findall("expression")]
+    if len(refs) != 2:
+        _warn(warnings, f"A join condition in {ds_caption} does not name two fields; skipped")
+        return None
+    (lt, lf), (rt, rf) = _split_ref(refs[0]), _split_ref(refs[1])
+    lt = objects.get(lt, lt) or (sides[0] if len(sides) > 0 else "")
+    rt = objects.get(rt, rt) or (sides[1] if len(sides) > 1 else "")
+    return SourceJoin(left_table=lt, right_table=rt, left_field=lf, right_field=rf, kind=kind)
+
+
+def _read_metadata_fields(ds_el: Element, ds: _Datasource, warnings: list[str]) -> None:
+    for rec in ds_el.iter("metadata-record"):
+        if rec.get("class") != "column":
+            continue
+        local = (rec.findtext("local-name") or "").strip()
+        if not local:
+            _warn(warnings, f"A column metadata-record in {ds.caption} has no local-name; skipped")
+            continue
+        if _omitted(local) or local in ds.fields:
+            continue
+        datatype = (rec.findtext("local-type") or "string").strip().lower()
+        agg = _META_AGG.get((rec.findtext("aggregation") or "").strip().lower(), "")
+        if datatype in _DATE_TYPES:
+            role, aggregation = ROLE_DATE, ""
+        elif datatype in _NUMERIC_TYPES:
+            role, aggregation = ROLE_MEASURE, agg or "sum"
+        else:
+            role, aggregation = ROLE_DIMENSION, ""
+        ds.fields[local] = SourceField(
+            name=_unbracket(local), role=role, datatype=datatype,
+            table=_unbracket((rec.findtext("parent-name") or "").strip()), aggregation=aggregation,
+        )
+
+
+def _read_column_fields(ds_el: Element, ds: _Datasource, calc_counter: list[int], warnings: list[str]) -> None:
+    for col in ds_el.findall("column"):
+        local = col.get("name", "")
+        if not local:
+            _warn(warnings, f"A column in {ds.caption} has no name; skipped")
+            continue
+        if _omitted(local):
+            continue
+        calc = col.find("calculation")
+        formula = calc.get("formula", "") if calc is not None else ""
+        existing = ds.fields.get(local)
+        datatype = (col.get("datatype") or (existing.datatype if existing else "string")).lower()
+        explicit_role = (col.get("role") or "").lower()
+        if datatype in _DATE_TYPES:
+            role = ROLE_DATE
+        elif explicit_role == "measure":
+            role = ROLE_MEASURE
+        elif explicit_role == "dimension":
+            role = ROLE_DIMENSION
+        else:
+            role = existing.role if existing else ROLE_DIMENSION
+        name = col.get("caption") or ""
+        if not name:
+            bare = _unbracket(local)
+            if _CALC_NAME.match(bare):
+                calc_counter[0] += 1
+                name = f"Calculated field {calc_counter[0]}"
+                _warn(warnings, f"A calculated field in {ds.caption} has no caption; shown as {name!r}")
+            else:
+                name = bare
+        aggregation = ""
+        if role == ROLE_MEASURE:
+            aggregation = (existing.aggregation if existing and existing.aggregation else "sum")
+        notes: list[str] = list(existing.notes) if existing else []
+        if formula and any(m in formula.upper() for m in _LOD_MARKERS):
+            notes.append("level-of-detail expression; re-expressed loosely")
+        ds.fields[local] = SourceField(
+            name=name, role=role, datatype=datatype,
+            table=existing.table if existing else "",
+            aggregation=aggregation, formula=formula,
+            hidden=(col.get("hidden", "").lower() == "true"), notes=notes,
+        )
+
+
+def _merge_fields(datasources: list[_Datasource]) -> list[SourceField]:
+    seen: set[str] = set()
+    out: list[SourceField] = []
+    for ds in datasources:
+        for f in ds.fields.values():
+            key = f.name.strip().lower()
+            if key in seen:
+                continue
+            seen.add(key)
+            out.append(f)
+    return out
+
+
+def _merge_tables(datasources: list[_Datasource]) -> list[SourceTable]:
+    out: list[SourceTable] = []
+    for ds in datasources:
+        for t in ds.tables:
+            if not any(x.name == t.name for x in out):
+                out.append(t)
+    return out
+
+
+def _merge_joins(datasources: list[_Datasource]) -> list[SourceJoin]:
+    out: list[SourceJoin] = []
+    for ds in datasources:
+        for j in ds.joins:
+            if j not in out:
+                out.append(j)
+    return out
+
+
+# ---------------------------------------------------------------------------
+# worksheets
+# ---------------------------------------------------------------------------
+
+@dataclass
+class _Dependencies:
+    """What one worksheet declares it uses from one data source."""
+    captions: dict[str, str] = field(default_factory=dict)      # bracketed name -> caption
+    roles: dict[str, str] = field(default_factory=dict)         # bracketed name -> measure|dimension
+    datatypes: dict[str, str] = field(default_factory=dict)
+    aggregations: dict[str, str] = field(default_factory=dict)  # bracketed name -> aggregation on an instance
+    table_calcs: list[str] = field(default_factory=list)        # bracketed names carrying a table calc
+
+
+class _ShelfReader:
+    """Turns shelf/encoding text into ShelfFields for one worksheet."""
+
+    def __init__(self, by_id: dict[str, _Datasource], deps: dict[str, _Dependencies], notes: list[str]):
+        self.by_id = by_id
+        self.deps = deps
+        self.notes = notes
+
+    def fields_in(self, text: str | None) -> list[ShelfField]:
+        out: list[ShelfField] = []
+        for m in _TOKEN.finditer(text or ""):
+            for sf in self.resolve(_unescape(m.group(1) or ""), _unescape(m.group(2))):
+                if not any(x.field == sf.field and x.role == sf.role for x in out):
+                    out.append(sf)
+        return out
+
+    def measure_token_count(self, text: str) -> int:
+        return sum(1 for sf in self.fields_in(text) if sf.role == ROLE_MEASURE)
+
+    def resolve(self, ds_id: str, token: str) -> list[ShelfField]:
+        if token == "Multiple Values":
+            return self._measure_values(ds_id)
+        if token.startswith(":"):
+            return []
+        prefix, name = _split_token(token)
+        local = f"[{name}]"
+        if _omitted(local):
+            return []
+        src = self._source_field(ds_id, local)
+        display = self._display(ds_id, local, src)
+        if prefix in _DATE_PREFIX:
+            return [ShelfField(field=display, role=ROLE_DATE, grain=_DATE_PREFIX[prefix])]
+        if prefix in _AGG_PREFIX:
+            return [ShelfField(field=display, role=ROLE_MEASURE, aggregation=_AGG_PREFIX[prefix])]
+        is_date = (src is not None and src.role == ROLE_DATE) or self._dep_datatype(ds_id, local) in _DATE_TYPES
+        if prefix in ("none", ""):
+            if is_date:
+                return [ShelfField(field=display, role=ROLE_DATE)]
+            return [ShelfField(field=display, role=ROLE_DIMENSION)]
+        if prefix != "attr":
+            self._note(f"shelf prefix {prefix!r} on {display} is not understood; carried by the field's own role")
+        if is_date:
+            return [ShelfField(field=display, role=ROLE_DATE)]
+        if src is not None and src.role == ROLE_MEASURE:
+            return [ShelfField(field=display, role=ROLE_MEASURE, aggregation=src.aggregation or "sum")]
+        return [ShelfField(field=display, role=ROLE_DIMENSION)]
+
+    def _measure_values(self, ds_id: str) -> list[ShelfField]:
+        ids = [ds_id] if ds_id else list(self.deps)
+        out: list[ShelfField] = []
+        for d in ids:
+            dep = self.deps.get(d)
+            if dep is None:
+                continue
+            for local, role in dep.roles.items():
+                if role != "measure" or _omitted(local):
+                    continue
+                src = self._source_field(d, local)
+                agg = dep.aggregations.get(local) or (src.aggregation if src else "") or "sum"
+                sf = ShelfField(field=self._display(d, local, src), role=ROLE_MEASURE, aggregation=agg)
+                if not any(x.field == sf.field for x in out):
+                    out.append(sf)
+        if out:
+            self._note("Measure Values expanded")
+        else:
+            self._note("Measure Values could not be expanded: the sheet lists no measures")
+        return out
+
+    def display_name(self, local: str) -> str:
+        """The caption for a bracketed field name, from any data source the sheet uses."""
+        return self._display("", local, self._source_field("", local))
+
+    def _source_field(self, ds_id: str, local: str) -> SourceField | None:
+        ds = self.by_id.get(ds_id)
+        if ds is not None and local in ds.fields:
+            return ds.fields[local]
+        for other in self.by_id.values():
+            if local in other.fields:
+                return other.fields[local]
+        return None
+
+    def _display(self, ds_id: str, local: str, src: SourceField | None) -> str:
+        if src is not None:
+            return src.name
+        dep = self.deps.get(ds_id)
+        if dep is not None and dep.captions.get(local):
+            return dep.captions[local]
+        for dep in self.deps.values():
+            if dep.captions.get(local):
+                return dep.captions[local]
+        bare = _unbracket(local)
+        if _CALC_NAME.match(bare):
+            return "Calculated field"
+        return bare
+
+    def _dep_datatype(self, ds_id: str, local: str) -> str:
+        dep = self.deps.get(ds_id)
+        return dep.datatypes.get(local, "") if dep is not None else ""
+
+    def _note(self, message: str) -> None:
+        if message not in self.notes:
+            self.notes.append(message)
+
+
+def _worksheets(root: Element) -> Iterator[Element]:
+    container = root.find("worksheets")
+    if container is None:
+        return
+    yield from container.findall("worksheet")
+
+
+def _read_worksheet(ws: Element, by_id: dict[str, _Datasource], warnings: list[str]
+                    ) -> tuple[SourceSheet | None, list[str]]:
+    name = ws.get("name") or ""
+    if not name:
+        _warn(warnings, "A worksheet has no name; skipped")
+        return None, []
+    table = ws.find("table")
+    if table is None:
+        _warn(warnings, f"Worksheet {name!r} has no table element; skipped")
+        return None, []
+    view = table.find("view")
+    notes: list[str] = []
+    deps, dep_ids = _read_dependencies(view, warnings, name)
+    reader = _ShelfReader(by_id, deps, notes)
+
+    rows = reader.fields_in(table.findtext("rows"))
+    cols = reader.fields_in(table.findtext("cols"))
+
+    panes = table.find("panes")
+    pane_list = panes.findall("pane") if panes is not None else []
+    marks = _marks(pane_list)
+    color = size = None
+    detail: list[ShelfField] = []
+    text_fields: list[ShelfField] = []
+    for pane in pane_list:
+        enc = pane.find("encodings")
+        if enc is None:
+            continue
+        for el in enc:
+            fields = reader.fields_in(el.get("column"))
+            if el.tag == "color" and color is None and fields:
+                color = fields[0]
+            elif el.tag == "size" and size is None and fields:
+                size = fields[0]
+            elif el.tag == "lod":
+                _extend_unique(detail, fields)
+            elif el.tag == "text":
+                _extend_unique(text_fields, fields)
+
+    filters: list[str] = []
+    if view is not None:
+        for flt in view.findall("filter"):
+            for sf in reader.fields_in(flt.get("column")):
+                if sf.field not in filters:
+                    filters.append(sf.field)
+
+    dual_axis = _dual_axis(table, pane_list, reader)
+
+    on_shelves = {f.field for f in rows + cols} | {f.field for f in (color, size) if f}
+    extra_text = [f for f in text_fields if f.field not in on_shelves]
+    _extend_unique(detail, extra_text)
+    if any(f.role == ROLE_MEASURE for f in extra_text) and not any(f.role == ROLE_MEASURE for f in rows + cols):
+        notes.append("measure read from the text (label) encoding")
+
+    chart_type, fidelity, mapping_notes = chart_type_for(
+        marks, rows + extra_text, cols, color, size, dual_axis)
+    for local in _table_calcs(deps):
+        notes.append(f"table calculation on {reader.display_name(local)} is not carried")
+        if fidelity == FIDELITY_EXACT:
+            fidelity = FIDELITY_APPROXIMATED
+
+    sheet = SourceSheet(
+        name=name, title=_title(ws, name), marks=marks, rows=rows, cols=cols, color=color, size=size,
+        detail=detail, filters=filters, dual_axis=dual_axis, chart_type=chart_type, fidelity=fidelity,
+        notes=mapping_notes + [n for n in notes if n not in mapping_notes],
+    )
+    return sheet, dep_ids
+
+
+def _read_dependencies(view: Element | None, warnings: list[str], sheet_name: str
+                       ) -> tuple[dict[str, _Dependencies], list[str]]:
+    deps: dict[str, _Dependencies] = {}
+    order: list[str] = []
+    if view is None:
+        _warn(warnings, f"Worksheet {sheet_name!r} has no view element; its fields could not be read")
+        return deps, order
+    for dd in view.findall("datasource-dependencies"):
+        ds_id = dd.get("datasource", "")
+        dep = deps.setdefault(ds_id, _Dependencies())
+        if ds_id not in order:
+            order.append(ds_id)
+        for col in dd.findall("column"):
+            local = col.get("name", "")
+            if not local:
+                continue
+            if col.get("caption"):
+                dep.captions[local] = col.get("caption", "")
+            dep.roles[local] = (col.get("role") or "").lower()
+            dep.datatypes[local] = (col.get("datatype") or "").lower()
+        for inst in dd.findall("column-instance"):
+            local = inst.get("column", "")
+            prefix, _ = _split_token(_unbracket(inst.get("name", "")))
+            if local and prefix in _AGG_PREFIX and local not in dep.aggregations:
+                dep.aggregations[local] = _AGG_PREFIX[prefix]
+            if local and inst.find("table-calc") is not None and local not in dep.table_calcs:
+                dep.table_calcs.append(local)
+    return deps, order
+
+
+def _table_calcs(deps: dict[str, _Dependencies]) -> list[str]:
+    out: list[str] = []
+    for dep in deps.values():
+        for local in dep.table_calcs:
+            if local not in out:
+                out.append(local)
+    return out
+
+
+def _marks(panes: list[Element]) -> list[str]:
+    named = [p for p in panes if p.get("y-axis-name") or p.get("x-axis-name")]
+    source = named if any(p.find("mark") is not None for p in named) else panes
+    out: list[str] = []
+    for pane in source:
+        mark = pane.find("mark")
+        cls = mark.get("class", "") if mark is not None else ""
+        if cls and cls not in out:
+            out.append(cls)
+    return out
+
+
+def _dual_axis(table: Element, panes: list[Element], reader: _ShelfReader) -> bool:
+    style = table.find("style")
+    if style is not None:
+        for enc in style.iter("encoding"):
+            if enc.get("attr") == "space" and enc.get("fold", "").lower() == "true":
+                return True
+    for shelf in ("rows", "cols"):
+        for group in _GROUP.finditer(table.findtext(shelf) or ""):
+            if reader.measure_token_count(group.group(1)) >= 2:
+                return True
+    axes: dict[str, str] = {}
+    for pane in panes:
+        axis = pane.get("y-axis-name") or pane.get("x-axis-name")
+        mark = pane.find("mark")
+        if axis and mark is not None and mark.get("class"):
+            axes.setdefault(axis, mark.get("class", ""))
+    return len(axes) > 1 and len(set(axes.values())) > 1
+
+
+def _title(ws: Element, name: str) -> str:
+    ft = ws.find("layout-options/title/formatted-text")
+    if ft is None:
+        return name
+    text = "".join((run.text or "") for run in ft.iter("run")).strip()
+    text = text.replace("<Sheet Name>", name).strip()
+    return text or name
+
+
+def _extend_unique(target: list[ShelfField], items: list[ShelfField]) -> None:
+    for sf in items:
+        if not any(x.field == sf.field and x.role == sf.role for x in target):
+            target.append(sf)
+
+
+# ---------------------------------------------------------------------------
+# blends
+# ---------------------------------------------------------------------------
+
+def _read_blends(root: Element, blends: list[tuple[str, ...]], by_id: dict[str, _Datasource],
+                 warnings: list[str]) -> list[SourceJoin]:
+    rel_el = root.find("datasource-relationships")
+    columns: dict[str, list[str]] = {}
+    if rel_el is not None:
+        for dd in rel_el.findall("datasource-dependencies"):
+            cols = columns.setdefault(dd.get("datasource", ""), [])
+            for inst in dd.findall("column-instance"):
+                if inst.get("column") and inst.get("column") not in cols:
+                    cols.append(inst.get("column", ""))
+            for col in dd.findall("column"):
+                if col.get("name") and col.get("name") not in cols:
+                    cols.append(col.get("name", ""))
+    out: list[SourceJoin] = []
+    seen: set[tuple[str, str]] = set()
+    for dep_ids in blends:
+        primary = dep_ids[0]
+        for secondary in dep_ids[1:]:
+            if (primary, secondary) in seen:
+                continue
+            seen.add((primary, secondary))
+            shared = next((c for c in columns.get(primary, []) if c in columns.get(secondary, [])), "")
+            shared = _unbracket(shared)
+            left, right = _caption(by_id, primary), _caption(by_id, secondary)
+            out.append(SourceJoin(left_table=left, right_table=right, left_field=shared,
+                                  right_field=shared, kind="blend"))
+            _warn(warnings, f"{right} is blended onto {left} on {shared or 'no shared field found'}; "
+                            "mirrored as one model")
+    return out
+
+
+def _caption(by_id: dict[str, _Datasource], ds_id: str) -> str:
+    ds = by_id.get(ds_id)
+    return ds.caption if ds is not None else "unnamed data source"
+
+
+# ---------------------------------------------------------------------------
+# dashboards
+# ---------------------------------------------------------------------------
+
+def _read_dashboards(root: Element, sheet_names: set[str], warnings: list[str]) -> list[SourceDashboard]:
+    container = root.find("dashboards")
+    out: list[SourceDashboard] = []
+    if container is None:
+        return out
+    for dash in container.findall("dashboard"):
+        name = dash.get("name") or ""
+        if not name:
+            _warn(warnings, "A dashboard has no name; skipped")
+            continue
+        width, height = _dashboard_size(dash, warnings)
+        zones: list[Zone] = []
+        for z in _zone_elements(dash):
+            zone = _zone(z, sheet_names, name, warnings)
+            if zone is not None:
+                zones.append(zone)
+        out.append(SourceDashboard(name=name, width=width, height=height, zones=zones))
+    return out
+
+
+def _dashboard_size(dash: Element, warnings: list[str]) -> tuple[int, int]:
+    """(width, height) in px from <size>: the max values, else the min ones, else 0."""
+    size = dash.find("size")
+    if size is None:
+        return 0, 0
+    values: dict[str, int] = {}
+    for attr in ("maxwidth", "maxheight", "minwidth", "minheight"):
+        raw = size.get(attr)
+        if not raw:
+            continue
+        try:
+            values[attr] = int(raw)
+        except ValueError:
+            _warn(warnings, f"Dashboard {dash.get('name')!r} has a size ({attr}) that could not be read; "
+                            "treated as unknown")
+    width = values.get("maxwidth") or values.get("minwidth") or 0
+    height = values.get("maxheight") or values.get("minheight") or 0
+    return width, height
+
+
+def _zone_elements(el: Element) -> Iterator[Element]:
+    for child in el:
+        if child.tag == "devicelayouts":
+            continue
+        if child.tag == "zone":
+            yield child
+        yield from _zone_elements(child)
+
+
+def _zone(z: Element, sheet_names: set[str], dashboard: str, warnings: list[str]) -> Zone | None:
+    ztype = (z.get("type") or "").lower()
+    name = z.get("name") or ""
+    if ztype in _CONTAINER_ZONES:
+        return None
+    if not ztype:
+        if name not in sheet_names:
+            return None
+        kind = "sheet"
+    elif ztype in _TEXT_ZONES:
+        kind = "text"
+    elif ztype in _FILTER_ZONES:
+        kind = "filter"
+    else:
+        kind = "other"
+    try:
+        x, y, w, h = (int(z.get(a, "0")) / ZONE_UNITS for a in ("x", "y", "w", "h"))
+    except ValueError:
+        _warn(warnings, f"A {kind} zone on dashboard {dashboard!r} has a position that could not be read; skipped")
+        return None
+    return Zone(sheet=name or ztype, x=x, y=y, w=w, h=h, kind=kind)
+
+
+# ---------------------------------------------------------------------------
+# small helpers
+# ---------------------------------------------------------------------------
+
+def _unbracket(name: str) -> str:
+    name = (name or "").strip()
+    if name.startswith("[") and name.endswith("]"):
+        name = name[1:-1]
+    return _unescape(name)
+
+
+def _unescape(name: str) -> str:
+    return name.replace("]]", "]")
+
+
+def _omitted(local: str) -> bool:
+    return local.lower() in _OMIT_FIELDS or local.startswith("[:")
+
+
+def _split_token(token: str) -> tuple[str, str]:
+    """'sum:Sales:qk' -> ('sum', 'Sales'); 'Category' -> ('none', 'Category')."""
+    parts = token.split(":")
+    if len(parts) >= 3:
+        return parts[0].lower(), ":".join(parts[1:-1])
+    if len(parts) == 2:
+        return parts[0].lower(), parts[1]
+    return "none", token
+
+
+def _split_ref(ref: str) -> tuple[str, str]:
+    """'[Table].[Field]' -> ('Table', 'Field'); '[Field]' -> ('', 'Field')."""
+    m = _TOKEN.fullmatch(ref.strip())
+    if m is None:
+        return "", _unbracket(ref)
+    return _unescape(m.group(1) or ""), _unescape(m.group(2))
+
+
+
+__all__ = ["parse_twb", "MAX_BYTES"]

docs/agent_q_flags.md

@@ -1,6 +1,6 @@
 # Agent Q → DemoPrep: what to send (flag registry)
 
-*Living document, owned by the release manager. Every change to the `build_demo_from_brief` arguments or the MCP tool list is recorded here first. Last updated 2026-10-22.*
+*Living document, owned by the release manager. Every change to the `build_demo_from_brief` arguments or the MCP tool list is recorded here first. Last updated 2026-10-28.*
 
 **Rule (boone, 2026-10-14 / 10-20):** every feature is **OFF unless Agent Q sends it**. If an argument is omitted, false or blank, the build is exactly what it was before the feature existed.
 
@@ -52,6 +52,7 @@ Status key:
 | `insight_tile=true` (boone: "tile=1") | no insight tile | ThoughtSpot insight (AI narrative) tile **to the left of the KPIs** on the first tab | BUILT (`619d0b1`); TML import works, the narrative render still needs a look | ISS-24 |
 | `logo_tile=true` (boone: "logo=1") | no logo tile | Card with the company logo (**linking to the TSE site**; the company website if there's no portal), the tab name, a tagline and a short description of the key measures; top-left of the first tab | BUILT (`619d0b1`) | ISS-25 |
 | Nick's homepage | — | details pending from boone | IDEA | ISS-21 |
+| `source_dashboard` (the prospect's Tableau .twb as XML text, or a .twbx/.twb as a base64 data URI) or `source_dashboard_image` (a picture of the dashboard: https image URL or base64 data URI) | an ordinary demo | **DP Migrator** (Ketan + Nick, 2026-10-28): the demo REBUILDS the prospect's dashboard. The data speaks its measure/dimension names (the spec seeds the blueprint); the liveboard copies its sheets — chart types, titles, arrangement, a dual axis as a combo chart — on one tab, instead of the golden layout. DP Web unchanged. Only the .twb inside a .twbx is read; extracts are never opened. An unreadable file is refused at once; an unreadable picture fails the build within seconds. The result carries `mirror` (sheets with fidelity exact / approximated / dropped, tiles built, sheets dropped). Call `inspect_dashboard` first. | BUILT (`claude/dashboard-migration-tse-5669ab`, off test `8528a7c`) | ISS-31 |
 
 Flag names: boone said "tile=1" / "logo=1". The arguments are named `insight_tile` / `logo_tile` so the tool schema is unambiguous to Agent Q. Both accept `true`/`1`/`"yes"` like the portal flags.
 
@@ -65,11 +66,13 @@ Flag names: boone said "tile=1" / "logo=1". The arguments are named `insight_til
 | `list_board_charts`, `inspect_board_data`, `adjust_chart_data` (preview by default, `apply=true` writes), `undo_chart_adjustment` | find and fix flat charts on a built board | TEST |
 | `deploy_existing_schema` | redeploy a built schema to ThoughtSpot | TEST |
 | `check_homepage(url)` | call BEFORE `build_demo_from_brief`: can DemoPrep get the prospect's home page by itself (live, else an Internet Archive copy)? Returns `ok`, `source` (`live` / `wayback (YYYY-MM-DD)` / `none`), `needs_screenshot`, `reason`, `message_for_se`. When `needs_screenshot` is true, relay `message_for_se` to the SE and pass their image as `homepage_screenshot`. Up to ~45 s, no build slot, no writes; a usable capture is reused by a build of the same URL within 30 min | BUILT (`feature/check-homepage-tool`) |
+| `inspect_dashboard(source_dashboard, source_dashboard_image)` | DP Migrator: read the prospect's Tableau workbook or dashboard picture and say what a build would carry over — `sheets` (title, ThoughtSpot `chart_type`, measures, dimensions, date, `fidelity` exact / approximated / dropped, notes), `tables`, `joins`, `measures`, `dimensions`, `carried` counts, `warnings`, `message_for_se`. Workbook < 1 s; picture = one vision call. No slot, no writes. Then pass the SAME argument to `build_demo_from_brief` | BUILT (`claude/dashboard-migration-tse-5669ab`) |
 
 ## 5. After any prod push
 AgentSpot caches the tool list. **Refresh the tools in Agent Q** after every push that changes this page, or new arguments are invisible and newly required ones fail.
 
 ## Change log
+- 2026-10-28: **DP Migrator** — `source_dashboard` / `source_dashboard_image` on `build_demo_from_brief` and the `inspect_dashboard` tool (Ketan's "built-in legacy migrator", Nick's ask). Beta: Tableau .twb/.twbx and pictures; one dashboard; zone layout or a grid; Power BI later.
 - 2026-10-22: `list_settings_fields` / `get_settings` / `set_settings` for the dpSettingsDB agent (settings in Supabase, read and written through the MCP server).
 - 2026-10-22: `settings` (one JSON document per SE, produced by the DP Settings agent) on `build_demo_from_brief`; replaces the SE's Supabase settings for that run. On TEST `0d02061`.
 - 2026-10-21: `check_homepage(url)` tool: the build's own live-then-Wayback home page capture, run on its own so Agent Q can ask the SE for a screenshot before building (`needs_screenshot`, `message_for_se`).

docs/agentspot_dp_migrator_agent.md

@@ -0,0 +1,119 @@
+# AgentSpot agent instructions — DP Migrator
+
+Paste into the agent's instructions. Keep it generic: AgentSpot agent
+instructions are **org-wide** on shared SE clusters, so no customer names,
+GUIDs or schemas belong here. The agent needs the DemoPrep MCP connector
+(the same connector Agent Q uses); it calls three of its tools.
+
+---
+
+## What you do
+
+You rebuild a prospect's existing dashboard as a ThoughtSpot Embedded demo.
+The SE gives you the prospect's website and either their Tableau workbook
+(a .twb or .twbx file) or a picture of the dashboard. DemoPrep reads it,
+builds a demo whose data uses the dashboard's own measure and dimension
+names, recreates the dashboard as a liveboard (same charts, same titles, same
+arrangement, one tab), and embeds it in a DP Web site that looks like the
+prospect's. Nothing from the prospect's data is used: the numbers are
+synthetic, the vocabulary and the layout are theirs.
+
+Be honest about what this is. It is a demo-grade rebuild, not a migration of
+their data: charts carry over as "exact", "approximated" (the notes say what
+changed, for example a dual axis drawn as a combo chart) or "dropped" (the
+notes say why).
+
+## What you need before you build
+
+1. **The prospect's website**, e.g. https://www.acme.com. The DP Web site is
+   cloned from its home page. Derive the company name from it unless the SE
+   gives one.
+2. **The dashboard**, one of:
+   - the Tableau workbook: a `.twb` (XML text; send its contents as is) or a
+     `.twbx` (send the file as a base64 data URI). Only the `.twb` inside a
+     `.twbx` is read; its extracts are never opened.
+   - a picture of the dashboard: a png, jpeg or webp up to 10 MB, as an https
+     image URL or a base64 data URI. The workbook is exact; a picture is read
+     by a vision model and gets lower confidence, so prefer the file when the
+     SE has it. If they send both, the workbook is used.
+3. **The SE's email** (`owner_email`): the demo is built under their
+   ThoughtSpot account.
+4. **The Salesforce opportunity id** (`salesforce_opportunity_id`) and the
+   **environment** (`environment`: "prod" or "staging"). Both are required on
+   every build; nothing is read from Salesforce.
+
+Ask for whatever is missing in one message; do not start without the website,
+the dashboard and the SE's email.
+
+## Tools
+
+**`inspect_dashboard(source_dashboard, source_dashboard_image)`** — reads the
+workbook or the picture and says what a build would carry over. Read-only,
+takes no build slot; a workbook returns in under a second, a picture takes a
+vision call (10-30 s). Returns `ok`, `name`, `source_kind`, `confidence`, the
+`measures`, `dimensions`, `dates`, `tables` and `joins` it read, `sheets`
+(one per chart: `title`, `chart_type`, `measures`, `dimensions`, `date`,
+`fidelity`, `notes`), `tiles` (the sheets that become tiles, in order),
+`carried` (counts of exact / approximated / dropped), `warnings`, and
+`message_for_se`. `ok` false means it could not be read; `error` says why.
+
+**`build_demo_from_brief(...)`** — the full build (data, model, liveboard,
+DP Web site). Returns at once with a `run_id`; the build takes 15-20 minutes
+in the background. For a rebuild pass, besides the usual arguments:
+
+- `source_dashboard` — the workbook, exactly the value you inspected, **or**
+- `source_dashboard_image` — the picture, exactly the value you inspected.
+- `brief` — two or three sentences you write: who the prospect is (from the
+  website), what the dashboard tracks (from the inspect result: its measures,
+  dimensions and date), and that they are evaluating ThoughtSpot Embedded.
+- `company_name`, `company_url`, `use_case` (name it after the dashboard, for
+  example "Sales vs Target"), `owner_email`, `salesforce_opportunity_id`,
+  `environment`.
+
+Leave every other argument at its default. An unreadable workbook is refused
+immediately (`status` "failed", the reason in `errors`); an unreadable picture
+fails the build within its first minute with the reason.
+
+**`status()`** — progress of running builds (`active_builds`, each with a
+`phase`) and the results of finished ones (`recent_builds`, by `run_id`).
+
+Optional: **`check_homepage(url)`** before building. If it says
+`needs_screenshot`, ask the SE for a screenshot of the home page and pass it
+as `homepage_screenshot`; the build still runs without one, on a template
+login page.
+
+## How to run a rebuild
+
+1. Collect the website, the dashboard and the SE's email (plus opportunity id
+   and environment).
+2. Call `inspect_dashboard`. Relay `message_for_se`, then show a short table of
+   the sheets: title, chart type it becomes, fidelity, notes. List `warnings`
+   (parameters and table calculations that do not carry over, blends read as
+   one model). If `ok` is false, relay `error` and ask for the `.twb` file or
+   a larger, clearer screenshot.
+3. Ask "Build it?" and wait for a yes.
+4. Call `build_demo_from_brief` with the same `source_dashboard` /
+   `source_dashboard_image` value and the arguments above. Tell the SE the
+   build is running and takes 15-20 minutes.
+5. Poll `status()` about once a minute. Report the phase when it changes
+   (dataset, tables, model, liveboard, portal). Do not call it in a tight loop.
+6. When the run leaves `active_builds`, read its entry in `recent_builds` and
+   report: `liveboard_url`, `portal_url` (the DP Web site), `model_url`, and
+   the `mirror` block — `tiles_built` (title, chart type, the question each
+   tile asks) and `tiles_dropped` — plus any `warnings`. A `status` of
+   "partial" means the data and model exist but the liveboard or site did
+   not; say which and relay the error.
+
+## Rules
+
+- Never paste the workbook's contents or the picture into the conversation;
+  they travel only as tool arguments. Summarise what was read instead.
+- One dashboard per build: the workbook's first dashboard with charts on it
+  (or every worksheet when it has no dashboard). Say so if the workbook has
+  several, and offer a second build for another.
+- Never promise exact fidelity. Use the fidelity and notes from
+  `inspect_dashboard` when you describe what the demo will show.
+- If `build_demo_from_brief` returns `status` "busy", wait a few minutes and
+  try again; do not start a second build for the same prospect meanwhile.
+- The build creates objects under the SE's account on the default cluster.
+  Pass `ts_url` only when the SE names a different instance.

liveboard_creator.py

@@ -3676,6 +3676,7 @@ def create_liveboard_from_model_mcp(
     model_columns: List[Dict] = None,
     prompt_logger=None,
     session_logger=None,
+    explicit_questions: Optional[List[Dict]] = None,
 ) -> Dict:
     """
     Create and deploy a Liveboard using ThoughtSpot's Model Context Protocol (MCP)
@@ -3697,6 +3698,9 @@ def create_liveboard_from_model_mcp(
         outliers: Optional list of demo outliers to create targeted visualizations
         llm_model: LLM model for AI question generation
         model_columns: List of column dicts with 'name' and 'type' from DDL
+        explicit_questions: Mirror mode (DP Migrator): [{question, source, ...}]
+            asked AS GIVEN, one per source sheet, instead of the AI-generated
+            set. None = generate as usual.
     
     Returns:
         Deployment result dictionary with structure:
@@ -3801,40 +3805,50 @@ def create_liveboard_from_model_mcp(
                                 model_guid=model_id,
                             )
 
-                    ai_result, _q_last_error = _generate_questions_with_retries(_q_generate, on_failure=_q_failed)
-                    if ai_result is None:
-                        # Still no skeleton board — but the caller (deploy_all) now
-                        # ships the model and schema with a loud no_liveboard
-                        # warning instead of aborting the run.
-                        return {
-                            'success': False,
-                            'error': (
-                                f'AI question generation failed {QUESTION_GENERATION_ATTEMPTS} times; '
-                                f'not shipping a skeleton board. Last error: {_q_last_error[:400]}'
-                            ),
-                        }
-
-                    questions_to_ask = []
-                    for q in ai_result.get('kpis', []):
-                        questions_to_ask.append({'question': q, 'source': 'kpi'})
-                        print(f"   📊 KPI: {q}", flush=True)
-                    for q in ai_result.get('visualizations', []):
-                        questions_to_ask.append({'question': q, 'source': 'viz'})
-                        print(f"   🧠 Viz: {q}", flush=True)
+                    if explicit_questions:
+                        # Mirror mode (DP Migrator, boone 2026-10-28): one question per source
+                        # sheet, authored from the prospect's dashboard, asked as given.
+                        questions_to_ask = [{'question': q['question'], 'source': q.get('source', 'mirror')}
+                                            for q in explicit_questions if q.get('question')]
+                        mode_label = "mirror"
+                        print(f"🪞 Mirror mode: {len(questions_to_ask)} question(s) from the source dashboard", flush=True)
+                        for q in questions_to_ask:
+                            print(f"   🪞 {q['question']}", flush=True)
+                    else:
+                        ai_result, _q_last_error = _generate_questions_with_retries(_q_generate, on_failure=_q_failed)
+                        if ai_result is None:
+                            # Still no skeleton board — but the caller (deploy_all) now
+                            # ships the model and schema with a loud no_liveboard
+                            # warning instead of aborting the run.
+                            return {
+                                'success': False,
+                                'error': (
+                                    f'AI question generation failed {QUESTION_GENERATION_ATTEMPTS} times; '
+                                    f'not shipping a skeleton board. Last error: {_q_last_error[:400]}'
+                                ),
+                            }
 
-                    # Fallback: if AI returned nothing, ask MCP directly
-                    if not questions_to_ask:
-                        print(f"⚠️  AI returned no questions, falling back to MCP getRelevantQuestions", flush=True)
-                        questions_result = await session.call_tool("getRelevantQuestions", {
-                            "query": use_case.lower(),
-                            "datasourceIds": [model_id]
-                        })
-                        questions_data = json.loads(questions_result.content[0].text)
-                        for q in questions_data.get('questions', [])[:num_visualizations + 4]:
-                            questions_to_ask.append({
-                                'question': q['question'],
-                                'source': 'mcp'
+                        questions_to_ask = []
+                        for q in ai_result.get('kpis', []):
+                            questions_to_ask.append({'question': q, 'source': 'kpi'})
+                            print(f"   📊 KPI: {q}", flush=True)
+                        for q in ai_result.get('visualizations', []):
+                            questions_to_ask.append({'question': q, 'source': 'viz'})
+                            print(f"   🧠 Viz: {q}", flush=True)
+
+                        # Fallback: if AI returned nothing, ask MCP directly
+                        if not questions_to_ask:
+                            print(f"⚠️  AI returned no questions, falling back to MCP getRelevantQuestions", flush=True)
+                            questions_result = await session.call_tool("getRelevantQuestions", {
+                                "query": use_case.lower(),
+                                "datasourceIds": [model_id]
                             })
+                            questions_data = json.loads(questions_result.content[0].text)
+                            for q in questions_data.get('questions', [])[:num_visualizations + 4]:
+                                questions_to_ask.append({
+                                    'question': q['question'],
+                                    'source': 'mcp'
+                                })
                     
                     if not questions_to_ask:
                         print(f"❌ No questions generated!", flush=True)
@@ -5643,7 +5657,8 @@ def enhance_mcp_liveboard(
     add_layout: bool = True,
     llm_model: str = None,
     layout_strategy: str = "single_tab",
-    model_id: str = None
+    model_id: str = None,
+    mirror: Optional[Dict] = None,
 ) -> Dict:
     """
     Enhance an MCP-created liveboard with TML post-processing (Golden Demo style).
@@ -5669,7 +5684,12 @@ def enhance_mcp_liveboard(
         apply_brand_colors: Whether to apply brand color styling
         add_layout: Whether to add proper tab/tile layout
         layout_strategy: "single_tab" preserves existing app behavior;
-            "golden_two_tab" applies the lab's golden-demo-inspired layout.
+            "golden_two_tab" applies the lab's golden-demo-inspired layout;
+            "mirror" copies the prospect's dashboard (DP Migrator): chart
+            types, titles and arrangement come from `mirror`, and the golden
+            regroup, KPI/donut conversions, Muze and title rewriting are off.
+        mirror: the MirrorSpec as a dict plus its 'tiles' (the questions asked,
+            from demoprep_app.migration.questions). Required for "mirror".
         model_id: GUID of the model the liveboard is built on — used to
             validate search queries (cross-fact dates, granularity).
             Validation is skipped if not provided.
@@ -5768,6 +5788,20 @@ def enhance_mcp_liveboard(
         else:
             print(f"  [OK] All measure aggregations valid", flush=True)
 
+        # Mirror mode (DP Migrator, boone 2026-10-28): the board copies the
+        # prospect's dashboard. Chart types and titles come from the source
+        # sheets and are set BEFORE classification, so every later pass (KPI
+        # fixes, colours, layout) sees the final types.
+        use_mirror = layout_strategy == "mirror" and bool(mirror)
+        mirror_tiles = list((mirror or {}).get("tiles") or []) if use_mirror else []
+        mirror_mapping: Dict = {}
+        if use_mirror:
+            from demoprep_app.liveboards.mirror_layout import retype_for_mirror
+            _mirror_changes, mirror_mapping = retype_for_mirror(visualizations, mirror_tiles)
+            for _c in _mirror_changes:
+                print(f"  [mirror] {_c}", flush=True)
+            enhancements_applied.extend(_mirror_changes)
+
         # Step 2: Classify visualizations by type and purpose
         kpi_vizs = []      # KPI charts (big numbers, sparklines)
         trend_vizs = []    # Line/area charts (time series)
@@ -5833,7 +5867,7 @@ def enhance_mcp_liveboard(
             print(f"  ⚠️  Only note tiles found ({len(note_vizs)}) — MCP may have returned no chart answers. Keeping note tiles to preserve liveboard content.", flush=True)
 
         # Step 3: Add Groups - simplified: just KPI section, rest ungrouped
-        if add_groups:
+        if add_groups and not use_mirror:
             print(f"  Adding Groups ({'golden two-tab later' if use_golden_two_tab else 'simplified'})...", flush=True)
             
             groups = []
@@ -5861,7 +5895,7 @@ def enhance_mcp_liveboard(
         # MCP/Spotter often returns LINE charts for questions like "revenue weekly",
         # and sometimes returns COLUMN/BAR. Single-metric time-grain charts are KPI
         # cards; dimensional breakdowns ("by X") stay as analysis charts.
-        if fix_kpis and len(kpi_vizs) == 0:
+        if fix_kpis and len(kpi_vizs) == 0 and not use_mirror:
             print(f"  Converting KPI-style time-grain charts to KPIs...", flush=True)
             converted_count = 0
             kpi_candidates = []
@@ -5908,7 +5942,7 @@ def enhance_mcp_liveboard(
 
         # If KPI conversion happened after the first grouping pass, ensure the
         # Key Metrics group exists before layout is built.
-        if add_groups and not use_golden_two_tab and kpi_vizs:
+        if add_groups and not use_golden_two_tab and not use_mirror and kpi_vizs:
             groups = liveboard_tml.get('liveboard', {}).setdefault('groups', [])
             key_metrics_group = next((g for g in groups if g.get('name') == 'Key Metrics'), None)
             if key_metrics_group:
@@ -5973,88 +6007,89 @@ def enhance_mcp_liveboard(
         
         # Step 4b: Convert single-dimension categorical breakdowns to donut charts with colors.
         # Multi-dimension breakdowns ("by X and Y") are converted to STACKED_COLUMN for variety.
-        print(f"  Converting categorical charts to donuts/stacked...", flush=True)
-        donuts_converted = 0
-        stacked_converted = 0
-
-        # Define vibrant donut colors (from Golden Demo)
-        DONUT_COLORS = [
-            '#40C1C0',  # Teal
-            '#9c6ade',  # Purple
-            '#FF8142',  # Orange
-            '#4CAF50',  # Green
-            '#2196F3',  # Blue
-            '#E91E63',  # Pink
-            '#FFC107',  # Amber
-            '#00BCD4',  # Cyan
-        ]
+        if not use_mirror:   # mirror keeps the source chart types
+            print(f"  Converting categorical charts to donuts/stacked...", flush=True)
+            donuts_converted = 0
+            stacked_converted = 0
+
+            # Define vibrant donut colors (from Golden Demo)
+            DONUT_COLORS = [
+                '#40C1C0',  # Teal
+                '#9c6ade',  # Purple
+                '#FF8142',  # Orange
+                '#4CAF50',  # Green
+                '#2196F3',  # Blue
+                '#E91E63',  # Pink
+                '#FFC107',  # Amber
+                '#00BCD4',  # Cyan
+            ]
 
-        # Single-dimension breakdown keywords (no "and" following them)
-        _SINGLE_DIM_KEYWORDS = [
-            'by channel', 'by category', 'by segment', 'by region', 'by type',
-            'by audience', 'by campaign', 'by product', 'by brand', 'by store',
-            'distribution', 'mix', 'split', 'breakdown',
-        ]
-        # Charts convertible to donut — include LINE because MCP often creates LINE for categorical breakdowns
-        _DONUT_CONVERTIBLE = {'PIE', 'BAR', 'COLUMN', 'STACKED_COLUMN', 'LINE', 'AREA'}
+            # Single-dimension breakdown keywords (no "and" following them)
+            _SINGLE_DIM_KEYWORDS = [
+                'by channel', 'by category', 'by segment', 'by region', 'by type',
+                'by audience', 'by campaign', 'by product', 'by brand', 'by store',
+                'distribution', 'mix', 'split', 'breakdown',
+            ]
+            # Charts convertible to donut — include LINE because MCP often creates LINE for categorical breakdowns
+            _DONUT_CONVERTIBLE = {'PIE', 'BAR', 'COLUMN', 'STACKED_COLUMN', 'LINE', 'AREA'}
 
-        for viz in visualizations:
-            viz_id = viz.get('id')
-            answer = viz.get('answer', {})
-            viz_name = answer.get('name', '').lower()
-            chart = answer.get('chart', {})
-            chart_type = chart.get('type', '').upper()
-
-            # Multi-dimension breakdown: "by X and Y" → STACKED_COLUMN for variety
-            has_multi_dim = (' by ' in viz_name and ' and ' in viz_name.split(' by ', 1)[-1])
-            if has_multi_dim and chart_type in {'BAR', 'COLUMN', 'LINE', 'AREA'}:
-                chart['type'] = 'STACKED_COLUMN'
-                stacked_converted += 1
-                print(f"    Converted '{answer.get('name', viz_id)}' to STACKED_COLUMN (multi-dim)", flush=True)
-                continue
+            for viz in visualizations:
+                viz_id = viz.get('id')
+                answer = viz.get('answer', {})
+                viz_name = answer.get('name', '').lower()
+                chart = answer.get('chart', {})
+                chart_type = chart.get('type', '').upper()
 
-            # Single-dimension breakdown → donut
-            is_single_breakdown = any(kw in viz_name for kw in _SINGLE_DIM_KEYWORDS)
-            # Exclude multi-dim cases (already handled above) and exclude pure time-series
-            has_time_suffix = viz_name.rstrip().endswith(('weekly', 'monthly', 'daily', 'quarterly', 'yearly'))
-            if is_single_breakdown and not has_multi_dim and not has_time_suffix and chart_type in _DONUT_CONVERTIBLE:
-                chart['type'] = 'PIE'
+                # Multi-dimension breakdown: "by X and Y" → STACKED_COLUMN for variety
+                has_multi_dim = (' by ' in viz_name and ' and ' in viz_name.split(' by ', 1)[-1])
+                if has_multi_dim and chart_type in {'BAR', 'COLUMN', 'LINE', 'AREA'}:
+                    chart['type'] = 'STACKED_COLUMN'
+                    stacked_converted += 1
+                    print(f"    Converted '{answer.get('name', viz_id)}' to STACKED_COLUMN (multi-dim)", flush=True)
+                    continue
 
-                client_state_str = chart.get('client_state_v2', '{}')
-                try:
-                    client_state = json.loads(client_state_str)
-                except Exception:
-                    client_state = {}
+                # Single-dimension breakdown → donut
+                is_single_breakdown = any(kw in viz_name for kw in _SINGLE_DIM_KEYWORDS)
+                # Exclude multi-dim cases (already handled above) and exclude pure time-series
+                has_time_suffix = viz_name.rstrip().endswith(('weekly', 'monthly', 'daily', 'quarterly', 'yearly'))
+                if is_single_breakdown and not has_multi_dim and not has_time_suffix and chart_type in _DONUT_CONVERTIBLE:
+                    chart['type'] = 'PIE'
 
-                client_state.setdefault('version', 'V4DOT2')
-                client_state.setdefault('chartProperties', {})
-                client_state['chartProperties']['chartSpecific'] = {
-                    'customProps': json.dumps({
-                        'pieStyle': 'RING',
-                        'showLabel': True,
-                        'showValue': True,
-                        'showPercent': True
-                    })
-                }
-                client_state['chartProperties']['chartLevelColorConfig'] = {
-                    'colorPalette': {'colors': DONUT_COLORS}
-                }
+                    client_state_str = chart.get('client_state_v2', '{}')
+                    try:
+                        client_state = json.loads(client_state_str)
+                    except Exception:
+                        client_state = {}
 
-                chart['client_state_v2'] = json.dumps(client_state)
-                donuts_converted += 1
-                print(f"    Converted '{answer.get('name', viz_id)}' to donut chart", flush=True)
-
-        if donuts_converted > 0:
-            enhancements_applied.append(f"Converted {donuts_converted} charts to donuts")
-            print(f"  [OK] Converted {donuts_converted} charts to donuts", flush=True)
-        if stacked_converted > 0:
-            enhancements_applied.append(f"Converted {stacked_converted} charts to stacked column")
-            print(f"  [OK] Converted {stacked_converted} charts to stacked column", flush=True)
-
-        palette_count = _apply_varied_chart_series_colors(visualizations)
-        if palette_count > 0:
-            enhancements_applied.append(f"Applied varied palettes to {palette_count} chart(s)")
-            print(f"  [OK] Applied varied palettes to {palette_count} chart(s)", flush=True)
+                    client_state.setdefault('version', 'V4DOT2')
+                    client_state.setdefault('chartProperties', {})
+                    client_state['chartProperties']['chartSpecific'] = {
+                        'customProps': json.dumps({
+                            'pieStyle': 'RING',
+                            'showLabel': True,
+                            'showValue': True,
+                            'showPercent': True
+                        })
+                    }
+                    client_state['chartProperties']['chartLevelColorConfig'] = {
+                        'colorPalette': {'colors': DONUT_COLORS}
+                    }
+
+                    chart['client_state_v2'] = json.dumps(client_state)
+                    donuts_converted += 1
+                    print(f"    Converted '{answer.get('name', viz_id)}' to donut chart", flush=True)
+
+            if donuts_converted > 0:
+                enhancements_applied.append(f"Converted {donuts_converted} charts to donuts")
+                print(f"  [OK] Converted {donuts_converted} charts to donuts", flush=True)
+            if stacked_converted > 0:
+                enhancements_applied.append(f"Converted {stacked_converted} charts to stacked column")
+                print(f"  [OK] Converted {stacked_converted} charts to stacked column", flush=True)
+
+            palette_count = _apply_varied_chart_series_colors(visualizations)
+            if palette_count > 0:
+                enhancements_applied.append(f"Applied varied palettes to {palette_count} chart(s)")
+                print(f"  [OK] Applied varied palettes to {palette_count} chart(s)", flush=True)
         
         # Step 5: Apply brand colors and styling (Golden Demo style)
         if apply_brand_colors:
@@ -6179,6 +6214,14 @@ def enhance_mcp_liveboard(
                 visualizations = liveboard_tml.get('liveboard', {}).get('visualizations', [])
                 enhancements_applied.extend(golden_changes)
                 print(f"  [OK] Applied golden two-tab layout", flush=True)
+            elif use_mirror:
+                from demoprep_app.liveboards.mirror_layout import apply_mirror_layout
+                liveboard_tml, _layout_changes = apply_mirror_layout(
+                    liveboard_tml, mirror, mirror_tiles, mirror_mapping)
+                visualizations = liveboard_tml.get('liveboard', {}).get('visualizations', [])
+                enhancements_applied.extend(_layout_changes)
+                for _c in _layout_changes:
+                    print(f"  [OK] {_c}", flush=True)
             else:
                 groups = liveboard_tml.get('liveboard', {}).get('groups', [])
                 all_viz_ids = kpi_vizs + trend_vizs + bar_vizs + geo_vizs + table_vizs + other_vizs
@@ -6270,7 +6313,7 @@ def enhance_mcp_liveboard(
             if name:
                 _viz_name_to_ids.setdefault(name, []).append(viz.get('id'))
 
-        if _viz_name_to_ids:
+        if _viz_name_to_ids and not use_mirror:   # mirror keeps the source titles
             _unique_names = list(_viz_name_to_ids.keys())
             _title_mapping = _humanize_viz_titles(
                 viz_names=_unique_names,
@@ -6299,7 +6342,7 @@ def enhance_mcp_liveboard(
             target_filter_count=4,
             # boone's ruling 2026-09-02 (closes ISS-5): the Demo Guide tile is
             # MOVED to the third page, not removed and not gated off.
-            include_demo_notes_tile=True,
+            include_demo_notes_tile=not use_mirror,   # one tab in mirror mode; no guide tile
             # Global filters must actually filter the board (ISS-13): a chip
             # stays when it reaches MIN_FILTER_TILE_COVERAGE of the measure
             # tiles. None when the model's join graph could not be read.

mcp_server.py

@@ -830,6 +830,7 @@ def _run_build(run_id: str, brief: str, company_name: str, use_case: str, compan
                brand: dict | None = None,
                custom_mcp_demo: bool | str = False,
                header_tiles: dict | None = None,
+               mirror: dict | None = None, mirror_image: str = "",
                *, schema_style: str, homepage_screenshot: str = "",
                build_settings: BuildSettings | None = None) -> dict:
     """Drive the controller headlessly (runs in a BACKGROUND THREAD; the caller has
@@ -847,6 +848,9 @@ def _run_build(run_id: str, brief: str, company_name: str, use_case: str, compan
     # blank = not asked = OFF, and an unreadable value stays OFF with a warning saying so.
     _custom_mcp_notes: list[str] = []
     custom_mcp_on = _read_yes_no(custom_mcp_demo, "custom_mcp_demo", False, _custom_mcp_notes)
+    # DP Migrator: what was read from the source dashboard (set below once the
+    # spec is known); result() merges the deployer's tiles-built/dropped into it.
+    _mirror_summary: dict = {}
 
     # Full-brief capture + durable persist — ONCE per accepted build (this only runs for
     # builds that actually got a slot, so busy-retries of a queued build never duplicate
@@ -930,6 +934,9 @@ def _run_build(run_id: str, brief: str, company_name: str, use_case: str, compan
         # custom_mcp_demo: the field exists only when the caller asked for it, so a
         # build that did not ask returns, reports and stores exactly what it did before.
         out["warnings"].extend(_custom_mcp_notes)
+        # DP Migrator: present only when a source dashboard was sent.
+        if _mirror_summary or dc.get("mirror"):
+            out["mirror"] = {**_mirror_summary, **(dc.get("mirror") or {})}
         # Which home page the portal opens on (cloned | template), when one was built.
         if (portal or {}).get("home_page"):
             out["home_page"] = portal["home_page"]
@@ -941,7 +948,7 @@ def _run_build(run_id: str, brief: str, company_name: str, use_case: str, compan
                 out["warnings"].append(
                     "custom_mcp_demo: requested, but no section was generated because "
                     "the build did not reach a successful ThoughtSpot deploy")
-        _opt_in = {k: out[k] for k in ("custom_mcp_demo_section",) if k in out}
+        _opt_in = {k: out[k] for k in ("custom_mcp_demo_section", "mirror") if k in out}
         # Mark the run's Slack root: check on full success, x otherwise (partial
         # or failed), and @-mention the alert users in-thread on failure. Reacts
         # once; the controller's own "Complete" post may have beaten us to it.
@@ -1034,6 +1041,21 @@ def _run_build(run_id: str, brief: str, company_name: str, use_case: str, compan
 
     controller = None
     try:
+        # DP Migrator (boone 2026-10-28): a picture of the prospect's dashboard is
+        # read HERE, on the build thread (a vision call takes seconds), and an
+        # unreadable one fails the build now — never a silent generic demo.
+        if mirror_image and not mirror:
+            from demoprep_app.migration.image_spec import image_to_spec
+            _set_progress(run_id, phase="reading the source dashboard picture", detail="")
+            mirror = image_to_spec(mirror_image).to_dict()
+        if mirror:
+            from demoprep_app.migration.sources import spec_result
+            from demoprep_app.migration.spec import MirrorSpec
+            _mirror_summary = spec_result(MirrorSpec.from_dict(mirror))
+            _log_hit(f"MIRROR run_id={run_id} kind={_mirror_summary.get('source_kind')!r} "
+                     f"name={str(_mirror_summary.get('name'))[:80]!r} sheets={len(_mirror_summary.get('sheets') or [])} "
+                     f"tiles={len(_mirror_summary.get('tiles') or [])} carried={_mirror_summary.get('carried')}")
+
         # (i) controller — acting user = the per-build owner (per-instance; no
         # process-global write, so concurrent builds never race on the owner).
         # With a settings document the controller skips its Supabase settings
@@ -1104,6 +1126,9 @@ def _run_build(run_id: str, brief: str, company_name: str, use_case: str, compan
         controller.generic_use_case_context = ""
         # The prospect's brand colours (ISS-19); None unless the caller asked.
         controller.brand_theme = (brand or {}).get("theme")
+        # DP Migrator: binds the blueprint's vocabulary and switches the liveboard
+        # to the mirror layout (chat_interface.run_ddl_creation / deploy_all).
+        controller.mirror_spec = mirror
 
         # (iii-b) Run-scoped session logging. MCP builds bypass process_chat_message,
         # which is where App/Chat runs create their loggers — without this, MCP runs
@@ -1420,6 +1445,14 @@ def _call_payload(frame) -> dict:
             # key (the same key a clone made from it carries), not the image.
             from demoprep_app.portal.login_clone.sources import describe_screenshot_arg
             out[name] = describe_screenshot_arg(v)
+        elif name == "source_dashboard" and isinstance(v, str):
+            # A workbook names the prospect's tables and fields: log its kind,
+            # size and hash, not the content.
+            from demoprep_app.migration.sources import describe_source_arg
+            out[name] = describe_source_arg(v)
+        elif name == "source_dashboard_image" and isinstance(v, str):
+            from demoprep_app.portal.login_clone.sources import describe_screenshot_arg
+            out[name] = describe_screenshot_arg(v)
         else:
             out[name] = v
     return out
@@ -1491,6 +1524,88 @@ async def check_homepage(url: str) -> dict:
     return out
 
 
+@mcp.tool()
+async def inspect_dashboard(source_dashboard: str = "", source_dashboard_image: str = "") -> dict:
+    """DP Migrator: read the prospect's existing dashboard and say what a build
+    would carry over. Call BEFORE build_demo_from_brief when the SE has sent a
+    Tableau workbook or a dashboard picture. Starts nothing, takes no build slot,
+    changes nothing anywhere. A workbook takes under a second; a picture takes a
+    vision call (~10-30 s).
+
+    Args:
+        source_dashboard: the Tableau workbook: the .twb file's XML text as is, or
+            a .twbx/.twb as a base64 data URI. Only the .twb inside a .twbx is read;
+            extracts (customer data) are never opened.
+        source_dashboard_image: a picture of the dashboard instead: an https image
+            URL or a base64 data URI (png, jpeg or webp, up to 10 MB). When both are
+            sent the workbook is used.
+
+    Returns a dict:
+        ok: true when something was read.
+        name: the dashboard (or workbook) title.
+        source_kind: "tableau_twb" or "image".
+        confidence: 0..1 (a workbook is 1.0; a picture is what the model is sure of).
+        measures, dimensions, dates: the fields read, with aggregation and formulas.
+        tables, joins: the source tables and how they join (workbook only).
+        sheets: one per chart: title, chart_type (the ThoughtSpot type it becomes),
+            measures, dimensions, date, fidelity ("exact" | "approximated" |
+            "dropped") and notes saying what changed or why it was dropped.
+        tiles: the sheets that will become tiles, in reading order (the first
+            dashboard's sheets, else every sheet).
+        carried: counts of exact / approximated / dropped.
+        parameters_not_carried, warnings: what the build will not do.
+        message_for_se: one sentence to relay, e.g. "Read 'Sales Overview': 6 of 7
+            charts carry over (1 approximated: dual axis as a combo), 1 dropped."
+        error: when ok is false, why (and nothing else is set).
+
+    WHAT TO DO NEXT: show the SE message_for_se and the sheets table; if they are
+    happy, call build_demo_from_brief with the SAME source_dashboard /
+    source_dashboard_image (plus the brief, company and the required ids).
+    Never raises; an unreadable source is ok false with the reason.
+    """
+    import asyncio
+    from demoprep_app.migration.sources import load_source_dashboard, spec_result
+    from demoprep_app.migration.spec import MirrorError
+
+    _log_hit(f"CALL inspect_dashboard file={describe_source_arg_safe(source_dashboard)} "
+             f"image={'yes' if (source_dashboard_image or '').strip() else 'no'}")
+    try:
+        spec, notes = await asyncio.to_thread(
+            load_source_dashboard,
+            source_dashboard if isinstance(source_dashboard, str) else "",
+            source_dashboard_image if isinstance(source_dashboard_image, str) else "")
+    except MirrorError as e:
+        return {"ok": False, "error": str(e)}
+    except Exception as e:  # noqa: BLE001 - never raises to the caller
+        return {"ok": False, "error": f"the dashboard could not be read: {type(e).__name__}: {str(e)[:200]}"}
+    if spec is None:
+        return {"ok": False, "error": "send source_dashboard (the .twb) or source_dashboard_image (a picture)"}
+    out = spec_result(spec, extra_warnings=notes)
+    counts = out["carried"]
+    total = sum(counts.values())
+    kept = counts["exact"] + counts["approximated"]
+    parts = [f"Read \"{spec.name}\": {kept} of {total} chart(s) carry over"]
+    if counts["approximated"]:
+        parts.append(f"({counts['approximated']} approximated)")
+    if counts["dropped"]:
+        parts.append(f", {counts['dropped']} dropped")
+    if spec.source_kind != "tableau_twb":
+        parts.append(f"; read from a picture, confidence {out['confidence']}")
+    out["message_for_se"] = " ".join(parts).replace(" ,", ",") + "."
+    out["ok"] = True
+    _log_hit(f"INSPECT-DASHBOARD kind={spec.source_kind} name={spec.name[:80]!r} sheets={total} "
+             f"carried={counts} confidence={out['confidence']}")
+    return out
+
+
+def describe_source_arg_safe(value) -> str:
+    """For the call log: the source argument's kind and size, never its content."""
+    if not isinstance(value, str) or not value.strip():
+        return "none"
+    from demoprep_app.migration.sources import describe_source_arg
+    return describe_source_arg(value)
+
+
 @mcp.tool()
 def build_demo_from_brief(
     brief: str,
@@ -1527,6 +1642,10 @@ def build_demo_from_brief(
     # An INPUT, not a feature flag: the SE's picture of the prospect's home
     # page, used for the cloned login before the live site (2026-10-21).
     homepage_screenshot: str = "",
+    # DP Migrator (boone 2026-10-28): the prospect's existing dashboard, rebuilt
+    # as this demo's liveboard. The Tableau workbook, or a picture of it.
+    source_dashboard: str = "",
+    source_dashboard_image: str = "",
     # The SE's settings document (boone 2026-10-22). Optional: without it the
     # build reads the SE's settings from Supabase as before.
     settings: dict | None = None,
@@ -1661,6 +1780,23 @@ def build_demo_from_brief(
                 building whether a screenshot is needed, call
                 check_homepage(url) first and send one when it says
                 needs_screenshot.
+        source_dashboard: Optional (DP Migrator). The prospect's Tableau workbook:
+                the .twb file's XML text as is, or a .twbx/.twb as a base64 data
+                URI. The demo then REBUILDS that dashboard: the data speaks its
+                measure and dimension names, and the liveboard copies its sheets
+                (chart types, titles, arrangement; a dual axis becomes a combo
+                chart) instead of the golden layout. The DP Web site is unchanged.
+                Only the .twb inside a .twbx is read; extracts (customer data) are
+                never opened. An unreadable file is refused at once (status
+                "failed") so the build cannot silently become a generic demo.
+                Call inspect_dashboard first to show the SE what will carry over.
+        source_dashboard_image: Optional (DP Migrator). A picture of the dashboard
+                instead of the file: an https image URL or a base64 data URI
+                (png, jpeg or webp, up to 10 MB). Read by a vision model on the
+                build thread, so lower fidelity: titles, chart types and labels
+                as printed; no joins, types or formulas. If it cannot be read the
+                build fails within seconds with the reason. When both are sent
+                the workbook is used.
 
     Not settable here: askMode (it breaks the upstream tab prune) and the home
     page (its copy is written from a brand screenshot). For those, call
@@ -1678,6 +1814,9 @@ def build_demo_from_brief(
         the cluster (no account there, or the cluster is in standby) the call
         fails at once with the reason and nothing is built. A brand theme that
         cannot be used is also returned at once as `warnings` on the "started" reply.
+        With a source dashboard the result also carries `mirror`: what was read
+        (sheets with their chart type and fidelity: exact / approximated /
+        dropped, with notes), the tiles built and the sheets dropped.
     """
     _log_hit(
         f"CALL build_demo_from_brief company={company_name!r} use_case={use_case!r} "
@@ -1757,6 +1896,34 @@ def build_demo_from_brief(
     # 2026-10-20) — brand["derive"] tells _run_build to do that. Bad input
     # never fails the build — None plus warnings.
     from demoprep_app.liveboards.brand_theme import BrandTheme, brand_request, portal_brand_options
+    # DP Migrator (boone 2026-10-28): the prospect's dashboard. A workbook is
+    # parsed NOW (milliseconds; refused before a slot is taken when unreadable);
+    # a picture is checked for shape here and read by the vision model on the
+    # build thread, where an unreadable one fails the build at once.
+    from demoprep_app.migration.sources import load_workbook_arg
+    from demoprep_app.migration.spec import MirrorError
+    from demoprep_app.portal.login_clone.sources import screenshot_problem
+    mirror: dict | None = None
+    mirror_image = ""
+    _mirror_notes: list[str] = []
+    if (source_dashboard and not isinstance(source_dashboard, str)) or \
+            (source_dashboard_image and not isinstance(source_dashboard_image, str)):
+        return {"status": "failed", "errors": ["source_dashboard and source_dashboard_image must be strings"]}
+    _src = (source_dashboard or "").strip()
+    _src_img = (source_dashboard_image or "").strip()
+    if _src:
+        try:
+            mirror = load_workbook_arg(_src).to_dict()
+        except MirrorError as e:
+            return {"status": "failed", "errors": [f"source_dashboard: {e}"]}
+        if _src_img:
+            _mirror_notes.append("source_dashboard_image ignored: the workbook was sent too and is exact")
+    elif _src_img:
+        _img_problem = screenshot_problem(_src_img)
+        if _img_problem:
+            return {"status": "failed", "errors": [f"source_dashboard_image: {_img_problem}"]}
+        mirror_image = _src_img
+
     brand = brand_request(apply_brand_theme, brand_theme, company_url)
     _portal_brand, _portal_brand_warnings = portal_brand_options(
         BrandTheme.from_dict(brand["theme"]) if brand["theme"] else None)
@@ -1822,6 +1989,7 @@ def build_demo_from_brief(
                        header_tiles=header_tiles,
                        schema_style=schema_style,
                        homepage_screenshot=_shot,
+                       mirror=mirror, mirror_image=mirror_image,
                        build_settings=build_settings)
         finally:
             _build_sem.release()
@@ -1842,6 +2010,11 @@ def build_demo_from_brief(
         started["warnings"] = list(_tile_notes)
     if _shot_warning:
         started.setdefault("warnings", []).append(_shot_warning)
+    if mirror or mirror_image:
+        started["mirror"] = ("workbook read: the liveboard will copy its sheets" if mirror
+                            else "picture sent: read by the vision model as the build starts")
+        if _mirror_notes:
+            started.setdefault("warnings", []).extend(_mirror_notes)
     return started
 
 

sprint_2026_04.md

@@ -269,6 +269,17 @@ should tell. KPI targets, growth trends, and anomaly patterns live in the matrix
 - 2026-10-22 (boone, after a Walmart demo): the browser's default link colour no longer counts as a brand colour. walmart.com's nav links are unstyled, so they read #0000EE and slipped in as a series colour. Measured on Chromium 149: an unstyled link is #0000EE, or #9E9EFF on a dark-scheme page; a visited link reports the same colour to scripts. Those two are skipped in TEXT readings only (button text, h1, h2, nav link); a background or brand variable in that blue still counts. Live walmart.com now reads #0053E2 / #004F9A / #001E60, all Walmart blues. Committed on `feature/brand-from-homepage`, not pushed. 4 new tests; brand suites 136; full suite 1911 pass, the same 3 pre-existing failures.
 - Ask (boone): "take a brand palette and build that off the home page, then change the colors on our charts to match that branding."
 
+## ISS-31: DP Migrator — rebuild the prospect's existing dashboard (Tableau .twb or a picture) as the demo (Ketan + Nick, 10-28)
+- Date: 2026-10-28  Severity: FEATURE
+- Ask: Ketan closed the 10-28 meeting by challenging boone to "build a comprehensive ThoughtSpot Embedded demo builder equipped with a built-in legacy migrator"; Nick Moscaritolo asked for the same the same day: company URL + either the Tableau file or a screenshot of the dashboard, DemoPrep infers the schema, runs the normal pipeline, embeds it in DP Web. boone's reading (agreed): demo-grade, not a migration product — "your dashboard's shape and names, our data, plus a story"; the liveboard "as much like theirs as we can", the TSE site in golden TSE style. Beta to show 10-29.
+- Status: BUILT 2026-10-28 on `claude/dashboard-migration-tse-5669ab` (cut from the test line `8528a7c`; the worktree had been on the August portal spike and was reset). NOT committed, NOT pushed. **Replayed live 2026-10-29 on secloud** (in-process through the MCP tool, Slack off, opp `TEST-NOT-A-DEAL`, env staging, owner boone): run 1 `51428cccbb02` → board `fd753f8e` (7.6 min, success) proved the path end to end — model columns Sales / Target / Sales V Target / Order Date, one tab "Sheet 1", one `ADVANCED_LINE_COLUMN` tile, data API 200 — and found one defect: the column matcher took "Total Sales V Target" for "Target", so the target line was missing (fixed in `mirror_layout._first`, fewest-extra-words wins; regression test). Run 2 `AMA_10290008_BKV` → board `395e7f14-f98f-4c20-a480-01e6d4fcba6e` (6.7 min): columns = Total Sales, lines = Total Sales V Target + Total Target, monthly, data API returns all four columns. Portal built on the template login (no company_url in the replay). Both test schemas are in DEMOBUILD_2026_10 (`AMA_10282358_GWD_sch`, `AMA_10290008_BKV_sch`) and can be cleaned up.
+  - New package `demoprep_app/migration/`: `spec.py` (MirrorSpec: tables, joins, fields, sheets with ThoughtSpot `chart_type` + fidelity exact/approximated/dropped, dashboards with zones), `mapping.py` (source marks/shelves -> chart type; dual axis -> `ADVANCED_LINE_COLUMN`), `tableau_twb.py` (deterministic .twb parser, defusedxml; strips paths/hosts/users; blends, relationships, parameters, table calcs, LOD noted), `image_spec.py` (one Anthropic vision call -> the same spec, lower confidence), `statement.py` (spec -> the blueprint's `user_request`: measure/dimension names bound, calcs re-expressed by the author, charts listed; never a wording `directives.py` reads as a prohibition), `questions.py` (one liveboard question per source sheet in the MODEL's column names; a sheet whose measures the model lacks is dropped by name), `sources.py` (.twb text / .twbx zip -> only its .twb member; the payload log records kind+size+hash, never content).
+  - Pipeline: `create_liveboard_from_model_mcp(explicit_questions=...)` asks the sheet questions as given; `enhance_mcp_liveboard(layout_strategy="mirror", mirror=...)` retypes and retitles from the source BEFORE classification (`demoprep_app/liveboards/mirror_layout.py`), skips groups, KPI/donut conversions, Muze, title humanising and the Demo Guide tile, keeps query validation, KPI sparklines, brand colours, axis repair; one tab named after the dashboard, tiles from the source zones (12-col grid, rows ≈ 1.6 × columns × aspect) or a KPI-first grid. `deploy_all(mirror=...)`, `ChatDemoInterface.mirror_spec`, `deployment_completion["mirror"]`.
+  - MCP: `build_demo_from_brief(source_dashboard=..., source_dashboard_image=...)` — a workbook is parsed before the slot is taken (unreadable = refused), a picture is read on the build thread (unreadable = the build fails within seconds); result `mirror` block. New tool `inspect_dashboard`. `docs/agent_q_flags.md` updated (ISS-31).
+  - Tests: `tests/test_migration_twb.py` (on `tests/fixtures/tableau_dual_axis_example.twb`, Nick's file with the user path scrubbed), `tests/test_mirror_layout.py` (incl. enhance end-to-end with a fake cluster), `tests/test_migration_questions.py`.
+  - Cut for the beta: zone-accurate layout beyond the first dashboard, source colours, several dashboards as tabs, Power BI (.pbix), Looker.
+  - Open: commit; push to test-mcp; Agent Q tool refresh after the test-mcp push; a DP name for the feature (placeholder "DP Migrator"); whether `inspect_dashboard` stays a separate beat or folds into the build. Polish: `mapping.chart_type_for` has no slot for Tableau's text/label encoding (where KPI and crosstab measures live); the parser passes those measures through its `rows` argument and notes it on the sheet — give the mapping a `text` parameter when there is time.
+
 ## ISS-24: Insight tile on the first tab, opt-in (`insight_tile`, boone: "tile=1")
 - Date: 2026-10-20  Severity: FEATURE
 - Status: BUILT 2026-10-20: `619d0b1` on `feature/header-tiles` (off test `e429fd8`), not on test. **An insight tile CAN be made through TML**, which corrects the September note. It is a viz with an `ai_tile` block (`target_agent: insight_code_runner`, `template_id: text_long_form`, gzip+base64 pandas `analysis_code` that reads the source vizzes as `<viz_guid>.csv`). The narrative is NOT stored; ThoughtSpot writes it on every view. A VALIDATE_ONLY and an ALL_OR_NONE import both worked. Ours analyses the first tab's KPI trends (up to 4) and driver charts (up to 3). Placement: logo 2 | insight 4 | KPIs 6 (KPIs two per row). Insight only: 6 | 6. **Unverified:** whether the narrative renders. boone to open the throwaway board `60f46445-fb45-463a-a29e-d7b994ffd594` on secloud ("ZZ insight tile test (copy of Premier Tech)"). EA 26.8: a cluster without it should reject the tile, and the build warns (untested).
@@ -701,6 +712,7 @@ implementation keeps:
 
 ### Sprint 4 (this sprint)
 
+- [x] **DP Migrator beta (Oct 28) — ISS-31, on `claude/dashboard-migration-tse-5669ab` off test `8528a7c`; NOT pushed, NOT replayed live.** Tableau .twb/.twbx or a dashboard picture -> MirrorSpec -> blueprint vocabulary + one question per sheet + mirror layout; `inspect_dashboard` tool. Details under ISS-31.
 - [x] **Findings triage, Waves 1–3 (Oct 20) — on `feature/findings-triage`, cut from the test line `hf-mcp-test/main` c0c09a2; NOT pushed.** Plan: `docs/PLAN_findings_triage_2026_10_15.md` (copy of the parent session's `dev_notes/` original, status section appended to both) (47 SE builds Oct 12–15: ~600 of 662 Slack warnings were `bound_not_inferable`; four deploy failures were unprovisioned users reported as "authentication failed"). Four commits: ISS-22 login precheck cherry-picked (6747616 → 30d7d85), Wave 1 c6a9e6a, Wave 2 1e97c45, Wave 3 (this entry's tip). Decisions (boone 2026-10-20): `bound_not_inferable` = `info` + one roll-up line; `_RATIO` keeps 0-1 with an open-ratio veto; never auto-create ThoughtSpot users.
   - **Oct 20, after the Turtle replay on test-mcp 4f0378f:** the two `insight_weak` lines it posted (1.20x vs promised 1.30x; 0.82x vs promised 0.78x) failed only because `_check_insight` took the pass bar from the BOOSTED magnitude (1.76x / 0.44x) while printing the authored promise. Fixed on `fix/insight-bar-authored-promise` (off test tip d02d82c): the bar follows whichever of authored/driven magnitude sits closer to 1.0 (boost never raises it; a band cap lowers it). Test `test_the_tuning_boost_does_not_raise_the_pass_bar`. Suite 1406 pass / 3 pre-existing fails.
   - **Wave 1 — stop the noise, show the real failures.** The post-load gate now reads the blueprint's `fmt`/`signed`/`kind` per measure (`DatasetColumn` carries them, `quality_gate.measure_formats`, threaded from `chat_interface`; the MCP path runs the same controller), so an int count or a currency amount is non-negative, not "unclassified". `infer_bound` returns a `signed` `MeasureBound` (unbounded by design, no gap) for NET_/MARGIN/VARIANCE/FLOW names, declared-signed measures and difference formulas instead of the same `None` as "no class matched". `quality.findings.dedupe`: one record per (code, table, measure) across stages, post-load wins (CSAT_SCORE_SUM was posted twice per build). `bound_not_inferable` is `info` at both emitters; Slack posts one roll-up line last and orders findings critical → send-blocking → data defect → insight_weak → rest. `insight_weak` states realized / needed / promised (as authored — `PlantedInsight.authored_magnitude`) / direction; the old text printed the pass bar as "it promised". `formula.validate` reports a copy (`X`, `X*1`, `1*X`, `X/1`, `X+0`) before generation; the gate never recomputes a mirror (straight to omit) and names the cause. `deploy_all`'s auth error is `thoughtspot_errors.trusted_auth_failure_message`: a missing account is the plain instruction naming user + cluster; the same text reaches the run errors, the MCP result and the Slack "Failed" post.

tests/fixtures/tableau_dual_axis_example.twb

@@ -0,0 +1,950 @@
+<?xml version='1.0' encoding='utf-8' ?>
+
+<!-- build 20201.20.0219.0753                               -->
+<workbook original-version='18.1' source-build='2020.1.0 (20201.20.0219.0753)' source-platform='win' version='18.1' xmlns:user='http://www.tableausoftware.com/xml/user'>
+  <document-format-change-manifest>
+    <_.fcp.MarkAnimation.true...MarkAnimation />
+    <SheetIdentifierTracking />
+    <WindowsPersistSimpleIdentifiers />
+  </document-format-change-manifest>
+  <preferences>
+    <preference name='ui.encoding.shelf.height' value='24' />
+    <preference name='ui.shelf.height' value='26' />
+  </preferences>
+  <datasources>
+    <datasource caption='ListOfOrders+OrderBreakdown' inline='true' name='federated.0683hos176mghg18jfdcj01g7fgn' version='18.1'>
+      <connection class='federated'>
+        <named-connections>
+          <named-connection caption='P1-AmazingMartEU2' name='excel-direct.06y78xf1p244xs1c9h76a18luhv4'>
+            <connection class='excel-direct' cleaning='no' compat='no' dataRefreshTime='' filename='C:/Tableau/Datasources/P1-AmazingMartEU2.xlsx' interpretationMode='0' password='' server='' validate='no' />
+          </named-connection>
+        </named-connections>
+        <relation join='inner' type='join'>
+          <clause type='join'>
+            <expression op='='>
+              <expression op='[ListOfOrders].[Order ID]' />
+              <expression op='[OrderBreakdown].[Order ID]' />
+            </expression>
+          </clause>
+          <relation connection='excel-direct.06y78xf1p244xs1c9h76a18luhv4' name='ListOfOrders' table='[ListOfOrders$]' type='table'>
+            <columns gridOrigin='A1:J4118:no:A1:J4118:0' header='yes' outcome='6'>
+              <column datatype='string' name='Order ID' ordinal='0' />
+              <column datatype='date' name='Order Date' ordinal='1' />
+              <column datatype='string' name='Customer Name' ordinal='2' />
+              <column datatype='string' name='City' ordinal='3' />
+              <column datatype='string' name='Country' ordinal='4' />
+              <column datatype='string' name='Region' ordinal='5' />
+              <column datatype='string' name='Segment' ordinal='6' />
+              <column datatype='date' name='Ship Date' ordinal='7' />
+              <column datatype='string' name='Ship Mode' ordinal='8' />
+              <column datatype='string' name='State' ordinal='9' />
+            </columns>
+          </relation>
+          <relation connection='excel-direct.06y78xf1p244xs1c9h76a18luhv4' name='OrderBreakdown' table='[OrderBreakdown$]' type='table'>
+            <columns gridOrigin='A1:H8048:no:A1:H8048:0' header='yes' outcome='6'>
+              <column datatype='string' name='Order ID' ordinal='0' />
+              <column datatype='string' name='Product Name' ordinal='1' />
+              <column datatype='real' name='Discount' ordinal='2' />
+              <column datatype='integer' name='Sales' ordinal='3' />
+              <column datatype='integer' name='Profit' ordinal='4' />
+              <column datatype='integer' name='Quantity' ordinal='5' />
+              <column datatype='string' name='Category' ordinal='6' />
+              <column datatype='string' name='Sub-Category' ordinal='7' />
+            </columns>
+          </relation>
+        </relation>
+        <cols>
+          <map key='[Category]' value='[OrderBreakdown].[Category]' />
+          <map key='[City]' value='[ListOfOrders].[City]' />
+          <map key='[Country]' value='[ListOfOrders].[Country]' />
+          <map key='[Customer Name]' value='[ListOfOrders].[Customer Name]' />
+          <map key='[Discount]' value='[OrderBreakdown].[Discount]' />
+          <map key='[Order Date]' value='[ListOfOrders].[Order Date]' />
+          <map key='[Order ID (OrderBreakdown)]' value='[OrderBreakdown].[Order ID]' />
+          <map key='[Order ID]' value='[ListOfOrders].[Order ID]' />
+          <map key='[Product Name]' value='[OrderBreakdown].[Product Name]' />
+          <map key='[Profit]' value='[OrderBreakdown].[Profit]' />
+          <map key='[Quantity]' value='[OrderBreakdown].[Quantity]' />
+          <map key='[Region]' value='[ListOfOrders].[Region]' />
+          <map key='[Sales]' value='[OrderBreakdown].[Sales]' />
+          <map key='[Segment]' value='[ListOfOrders].[Segment]' />
+          <map key='[Ship Date]' value='[ListOfOrders].[Ship Date]' />
+          <map key='[Ship Mode]' value='[ListOfOrders].[Ship Mode]' />
+          <map key='[State]' value='[ListOfOrders].[State]' />
+          <map key='[Sub-Category]' value='[OrderBreakdown].[Sub-Category]' />
+        </cols>
+        <metadata-records>
+          <metadata-record class='column'>
+            <remote-name>Order ID</remote-name>
+            <remote-type>130</remote-type>
+            <local-name>[Order ID]</local-name>
+            <parent-name>[ListOfOrders]</parent-name>
+            <remote-alias>Order ID</remote-alias>
+            <ordinal>0</ordinal>
+            <local-type>string</local-type>
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <collation flag='1' name='LEN_RUS_S2' />
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;WSTR&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Order Date</remote-name>
+            <remote-type>7</remote-type>
+            <local-name>[Order Date]</local-name>
+            <parent-name>[ListOfOrders]</parent-name>
+            <remote-alias>Order Date</remote-alias>
+            <ordinal>1</ordinal>
+            <local-type>date</local-type>
+            <aggregation>Year</aggregation>
+            <contains-null>true</contains-null>
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;DATE&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Customer Name</remote-name>
+            <remote-type>130</remote-type>
+            <local-name>[Customer Name]</local-name>
+            <parent-name>[ListOfOrders]</parent-name>
+            <remote-alias>Customer Name</remote-alias>
+            <ordinal>2</ordinal>
+            <local-type>string</local-type>
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <collation flag='1' name='LEN_RUS_S2' />
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;WSTR&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>City</remote-name>
+            <remote-type>130</remote-type>
+            <local-name>[City]</local-name>
+            <parent-name>[ListOfOrders]</parent-name>
+            <remote-alias>City</remote-alias>
+            <ordinal>3</ordinal>
+            <local-type>string</local-type>
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <collation flag='1' name='LEN_RUS_S2' />
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;WSTR&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Country</remote-name>
+            <remote-type>130</remote-type>
+            <local-name>[Country]</local-name>
+            <parent-name>[ListOfOrders]</parent-name>
+            <remote-alias>Country</remote-alias>
+            <ordinal>4</ordinal>
+            <local-type>string</local-type>
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <collation flag='1' name='LEN_RUS_S2' />
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;WSTR&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Region</remote-name>
+            <remote-type>130</remote-type>
+            <local-name>[Region]</local-name>
+            <parent-name>[ListOfOrders]</parent-name>
+            <remote-alias>Region</remote-alias>
+            <ordinal>5</ordinal>
+            <local-type>string</local-type>
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <collation flag='1' name='LEN_RUS_S2' />
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;WSTR&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Segment</remote-name>
+            <remote-type>130</remote-type>
+            <local-name>[Segment]</local-name>
+            <parent-name>[ListOfOrders]</parent-name>
+            <remote-alias>Segment</remote-alias>
+            <ordinal>6</ordinal>
+            <local-type>string</local-type>
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <collation flag='1' name='LEN_RUS_S2' />
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;WSTR&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Ship Date</remote-name>
+            <remote-type>7</remote-type>
+            <local-name>[Ship Date]</local-name>
+            <parent-name>[ListOfOrders]</parent-name>
+            <remote-alias>Ship Date</remote-alias>
+            <ordinal>7</ordinal>
+            <local-type>date</local-type>
+            <aggregation>Year</aggregation>
+            <contains-null>true</contains-null>
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;DATE&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Ship Mode</remote-name>
+            <remote-type>130</remote-type>
+            <local-name>[Ship Mode]</local-name>
+            <parent-name>[ListOfOrders]</parent-name>
+            <remote-alias>Ship Mode</remote-alias>
+            <ordinal>8</ordinal>
+            <local-type>string</local-type>
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <collation flag='1' name='LEN_RUS_S2' />
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;WSTR&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>State</remote-name>
+            <remote-type>130</remote-type>
+            <local-name>[State]</local-name>
+            <parent-name>[ListOfOrders]</parent-name>
+            <remote-alias>State</remote-alias>
+            <ordinal>9</ordinal>
+            <local-type>string</local-type>
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <collation flag='1' name='LEN_RUS_S2' />
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;WSTR&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='capability'>
+            <remote-name />
+            <remote-type>0</remote-type>
+            <parent-name>[ListOfOrders]</parent-name>
+            <remote-alias />
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <attributes>
+              <attribute datatype='integer' name='context'>0</attribute>
+              <attribute datatype='string' name='gridOrigin'>&quot;A1:J4118:no:A1:J4118:0&quot;</attribute>
+              <attribute datatype='boolean' name='header'>true</attribute>
+              <attribute datatype='integer' name='outcome'>6</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Order ID</remote-name>
+            <remote-type>130</remote-type>
+            <local-name>[Order ID (OrderBreakdown)]</local-name>
+            <parent-name>[OrderBreakdown]</parent-name>
+            <remote-alias>Order ID</remote-alias>
+            <ordinal>10</ordinal>
+            <local-type>string</local-type>
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <collation flag='1' name='LEN_RUS_S2' />
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;WSTR&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Product Name</remote-name>
+            <remote-type>130</remote-type>
+            <local-name>[Product Name]</local-name>
+            <parent-name>[OrderBreakdown]</parent-name>
+            <remote-alias>Product Name</remote-alias>
+            <ordinal>11</ordinal>
+            <local-type>string</local-type>
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <collation flag='1' name='LEN_RUS_S2' />
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;WSTR&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Discount</remote-name>
+            <remote-type>5</remote-type>
+            <local-name>[Discount]</local-name>
+            <parent-name>[OrderBreakdown]</parent-name>
+            <remote-alias>Discount</remote-alias>
+            <ordinal>12</ordinal>
+            <local-type>real</local-type>
+            <aggregation>Sum</aggregation>
+            <precision>15</precision>
+            <contains-null>true</contains-null>
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;R8&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Sales</remote-name>
+            <remote-type>20</remote-type>
+            <local-name>[Sales]</local-name>
+            <parent-name>[OrderBreakdown]</parent-name>
+            <remote-alias>Sales</remote-alias>
+            <ordinal>13</ordinal>
+            <local-type>integer</local-type>
+            <aggregation>Sum</aggregation>
+            <contains-null>true</contains-null>
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;I8&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Profit</remote-name>
+            <remote-type>20</remote-type>
+            <local-name>[Profit]</local-name>
+            <parent-name>[OrderBreakdown]</parent-name>
+            <remote-alias>Profit</remote-alias>
+            <ordinal>14</ordinal>
+            <local-type>integer</local-type>
+            <aggregation>Sum</aggregation>
+            <contains-null>true</contains-null>
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;I8&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Quantity</remote-name>
+            <remote-type>20</remote-type>
+            <local-name>[Quantity]</local-name>
+            <parent-name>[OrderBreakdown]</parent-name>
+            <remote-alias>Quantity</remote-alias>
+            <ordinal>15</ordinal>
+            <local-type>integer</local-type>
+            <aggregation>Sum</aggregation>
+            <contains-null>true</contains-null>
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;I8&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Category</remote-name>
+            <remote-type>130</remote-type>
+            <local-name>[Category]</local-name>
+            <parent-name>[OrderBreakdown]</parent-name>
+            <remote-alias>Category</remote-alias>
+            <ordinal>16</ordinal>
+            <local-type>string</local-type>
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <collation flag='1' name='LEN_RUS_S2' />
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;WSTR&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Sub-Category</remote-name>
+            <remote-type>130</remote-type>
+            <local-name>[Sub-Category]</local-name>
+            <parent-name>[OrderBreakdown]</parent-name>
+            <remote-alias>Sub-Category</remote-alias>
+            <ordinal>17</ordinal>
+            <local-type>string</local-type>
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <collation flag='1' name='LEN_RUS_S2' />
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;WSTR&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='capability'>
+            <remote-name />
+            <remote-type>0</remote-type>
+            <parent-name>[OrderBreakdown]</parent-name>
+            <remote-alias />
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <attributes>
+              <attribute datatype='integer' name='context'>0</attribute>
+              <attribute datatype='string' name='gridOrigin'>&quot;A1:H8048:no:A1:H8048:0&quot;</attribute>
+              <attribute datatype='boolean' name='header'>true</attribute>
+              <attribute datatype='integer' name='outcome'>6</attribute>
+            </attributes>
+          </metadata-record>
+        </metadata-records>
+      </connection>
+      <aliases enabled='yes' />
+      <column caption='Sales V Target' datatype='integer' name='[Calculation_953355781789577216]' role='measure' type='quantitative'>
+        <calculation class='tableau' formula='SUM([Sales])-SUM([federated.1lm8rfp01pfb1y157heyi0tdr8s4].[Target])' />
+      </column>
+      <column datatype='string' name='[Category]' role='dimension' type='nominal' />
+      <column datatype='string' name='[City]' role='dimension' semantic-role='[City].[Name]' type='nominal' />
+      <column datatype='string' name='[Country]' role='dimension' semantic-role='[Country].[ISO3166_2]' type='nominal' />
+      <column datatype='integer' name='[Number of Records]' role='measure' type='quantitative' user:auto-column='numrec'>
+        <calculation class='tableau' formula='1' />
+      </column>
+      <column datatype='string' name='[State]' role='dimension' semantic-role='[State].[Name]' type='nominal' />
+      <column-instance column='[Category]' derivation='None' name='[none:Category:nk]' pivot='key' type='nominal' />
+      <drill-paths>
+        <drill-path name='Country, State, City'>
+          <field>[Country]</field>
+          <field>[State]</field>
+          <field>[City]</field>
+        </drill-path>
+      </drill-paths>
+      <layout dim-ordering='alphabetic' dim-percentage='0.850962' measure-ordering='alphabetic' measure-percentage='0.149038' show-structure='true' />
+      <style>
+        <style-rule element='mark'>
+          <encoding attr='color' field='[none:Category:nk]' type='palette'>
+            <map to='#4e79a7'>
+              <bucket>&quot;Furniture&quot;</bucket>
+            </map>
+            <map to='#e15759'>
+              <bucket>&quot;Technology&quot;</bucket>
+            </map>
+            <map to='#f28e2b'>
+              <bucket>&quot;Office Supplies&quot;</bucket>
+            </map>
+          </encoding>
+        </style-rule>
+      </style>
+      <semantic-values>
+        <semantic-value key='[Country].[Name]' value='&quot;United States&quot;' />
+      </semantic-values>
+      <datasource-dependencies datasource='federated.1lm8rfp01pfb1y157heyi0tdr8s4'>
+        <column datatype='integer' name='[Target]' role='measure' type='quantitative' />
+      </datasource-dependencies>
+    </datasource>
+    <datasource caption='SalesTargets (P1-AmazingMartEU2)' inline='true' name='federated.1lm8rfp01pfb1y157heyi0tdr8s4' version='18.1'>
+      <connection class='federated'>
+        <named-connections>
+          <named-connection caption='P1-AmazingMartEU2' name='excel-direct.1fmxg1r17lu72y124nsqq160byg5'>
+            <connection class='excel-direct' cleaning='no' compat='no' dataRefreshTime='' filename='C:/Tableau/Datasources/P1-AmazingMartEU2.xlsx' interpretationMode='0' password='' server='' validate='no' />
+          </named-connection>
+        </named-connections>
+        <relation connection='excel-direct.1fmxg1r17lu72y124nsqq160byg5' name='SalesTargets' table='[SalesTargets$]' type='table'>
+          <columns gridOrigin='A1:C145:no:A1:C145:0' header='yes' outcome='6'>
+            <column datatype='date' name='Month of Order Date' ordinal='0' />
+            <column datatype='string' name='Category' ordinal='1' />
+            <column datatype='integer' name='Target' ordinal='2' />
+          </columns>
+        </relation>
+        <metadata-records>
+          <metadata-record class='column'>
+            <remote-name>Month of Order Date</remote-name>
+            <remote-type>7</remote-type>
+            <local-name>[Month of Order Date]</local-name>
+            <parent-name>[SalesTargets]</parent-name>
+            <remote-alias>Month of Order Date</remote-alias>
+            <ordinal>0</ordinal>
+            <local-type>date</local-type>
+            <aggregation>Year</aggregation>
+            <contains-null>true</contains-null>
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;DATE&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Category</remote-name>
+            <remote-type>130</remote-type>
+            <local-name>[Category]</local-name>
+            <parent-name>[SalesTargets]</parent-name>
+            <remote-alias>Category</remote-alias>
+            <ordinal>1</ordinal>
+            <local-type>string</local-type>
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <collation flag='1' name='LEN_RUS_S2' />
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;WSTR&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='column'>
+            <remote-name>Target</remote-name>
+            <remote-type>20</remote-type>
+            <local-name>[Target]</local-name>
+            <parent-name>[SalesTargets]</parent-name>
+            <remote-alias>Target</remote-alias>
+            <ordinal>2</ordinal>
+            <local-type>integer</local-type>
+            <aggregation>Sum</aggregation>
+            <contains-null>true</contains-null>
+            <attributes>
+              <attribute datatype='string' name='DebugRemoteType'>&quot;I8&quot;</attribute>
+            </attributes>
+          </metadata-record>
+          <metadata-record class='capability'>
+            <remote-name />
+            <remote-type>0</remote-type>
+            <parent-name>[SalesTargets]</parent-name>
+            <remote-alias />
+            <aggregation>Count</aggregation>
+            <contains-null>true</contains-null>
+            <attributes>
+              <attribute datatype='integer' name='context'>0</attribute>
+              <attribute datatype='string' name='gridOrigin'>&quot;A1:C145:no:A1:C145:0&quot;</attribute>
+              <attribute datatype='boolean' name='header'>true</attribute>
+              <attribute datatype='integer' name='outcome'>6</attribute>
+            </attributes>
+          </metadata-record>
+        </metadata-records>
+      </connection>
+      <column datatype='integer' name='[Number of Records]' role='measure' type='quantitative' user:auto-column='numrec'>
+        <calculation class='tableau' formula='1' />
+      </column>
+      <layout dim-ordering='alphabetic' dim-percentage='0.5' measure-ordering='alphabetic' measure-percentage='0.5' show-structure='true' />
+      <semantic-values>
+        <semantic-value key='[Country].[Name]' value='&quot;United States&quot;' />
+      </semantic-values>
+    </datasource>
+  </datasources>
+  <datasource-relationships>
+    <datasource-dependencies datasource='federated.0683hos176mghg18jfdcj01g7fgn'>
+      <column datatype='string' name='[Category]' role='dimension' type='nominal' />
+      <column datatype='date' name='[Order Date]' role='dimension' type='ordinal' />
+      <column-instance column='[Order Date]' derivation='Month' name='[mn:Order Date:ok]' pivot='key' type='ordinal' />
+      <column-instance column='[Category]' derivation='None' name='[none:Category:nk]' pivot='key' type='nominal' />
+      <column-instance column='[Order Date]' derivation='Month-Trunc' name='[tmn:Order Date:ok]' pivot='key' type='ordinal' />
+      <column-instance column='[Order Date]' derivation='Year-Trunc' name='[tyr:Order Date:ok]' pivot='key' type='ordinal' />
+      <column-instance column='[Order Date]' derivation='Year' name='[yr:Order Date:ok]' pivot='key' type='ordinal' />
+    </datasource-dependencies>
+    <datasource-dependencies datasource='federated.1lm8rfp01pfb1y157heyi0tdr8s4'>
+      <column datatype='string' name='[Category]' role='dimension' type='nominal' />
+      <column datatype='date' name='[Month of Order Date]' role='dimension' type='ordinal' />
+      <column-instance column='[Month of Order Date]' derivation='Month' name='[mn:Month of Order Date:ok]' pivot='key' type='ordinal' />
+      <column-instance column='[Category]' derivation='None' name='[none:Category:nk]' pivot='key' type='nominal' />
+      <column-instance column='[Month of Order Date]' derivation='Month-Trunc' name='[tmn:Month of Order Date:ok]' pivot='key' type='ordinal' />
+      <column-instance column='[Month of Order Date]' derivation='Year-Trunc' name='[tyr:Month of Order Date:ok]' pivot='key' type='ordinal' />
+      <column-instance column='[Month of Order Date]' derivation='Year' name='[yr:Month of Order Date:ok]' pivot='key' type='ordinal' />
+    </datasource-dependencies>
+    <datasource-relationship source='federated.0683hos176mghg18jfdcj01g7fgn' target='federated.1lm8rfp01pfb1y157heyi0tdr8s4'>
+      <column-mapping>
+        <map key='[federated.0683hos176mghg18jfdcj01g7fgn].[mn:Order Date:ok]' value='[federated.1lm8rfp01pfb1y157heyi0tdr8s4].[mn:Month of Order Date:ok]' />
+        <map key='[federated.0683hos176mghg18jfdcj01g7fgn].[none:Category:nk]' value='[federated.1lm8rfp01pfb1y157heyi0tdr8s4].[none:Category:nk]' />
+        <map key='[federated.0683hos176mghg18jfdcj01g7fgn].[tmn:Order Date:ok]' value='[federated.1lm8rfp01pfb1y157heyi0tdr8s4].[tmn:Month of Order Date:ok]' />
+        <map key='[federated.0683hos176mghg18jfdcj01g7fgn].[tyr:Order Date:ok]' value='[federated.1lm8rfp01pfb1y157heyi0tdr8s4].[tyr:Month of Order Date:ok]' />
+        <map key='[federated.0683hos176mghg18jfdcj01g7fgn].[yr:Order Date:ok]' value='[federated.1lm8rfp01pfb1y157heyi0tdr8s4].[yr:Month of Order Date:ok]' />
+      </column-mapping>
+    </datasource-relationship>
+  </datasource-relationships>
+  <worksheets>
+    <worksheet name='Sheet 1'>
+      <table>
+        <view>
+          <datasources>
+            <datasource caption='ListOfOrders+OrderBreakdown' name='federated.0683hos176mghg18jfdcj01g7fgn' />
+            <datasource caption='SalesTargets (P1-AmazingMartEU2)' name='federated.1lm8rfp01pfb1y157heyi0tdr8s4' />
+          </datasources>
+          <datasource-dependencies datasource='federated.0683hos176mghg18jfdcj01g7fgn'>
+            <column caption='Sales V Target' datatype='integer' name='[Calculation_953355781789577216]' role='measure' type='quantitative'>
+              <calculation class='tableau' formula='SUM([Sales])-SUM([federated.1lm8rfp01pfb1y157heyi0tdr8s4].[Target])' />
+            </column>
+            <column datatype='string' name='[Category]' role='dimension' type='nominal' />
+            <column datatype='date' name='[Order Date]' role='dimension' type='ordinal' />
+            <column datatype='integer' name='[Sales]' role='measure' type='quantitative' />
+            <column-instance column='[Category]' derivation='None' name='[none:Category:nk]' pivot='key' type='nominal' />
+            <column-instance column='[Sales]' derivation='Sum' name='[sum:Sales:qk]' pivot='key' type='quantitative' />
+            <column-instance column='[Order Date]' derivation='Month-Trunc' name='[tmn:Order Date:qk]' pivot='key' type='quantitative' />
+            <column-instance column='[Calculation_953355781789577216]' derivation='User' name='[usr:Calculation_953355781789577216:qk]' pivot='key' type='quantitative' />
+          </datasource-dependencies>
+          <datasource-dependencies datasource='federated.1lm8rfp01pfb1y157heyi0tdr8s4'>
+            <column datatype='integer' name='[Target]' role='measure' type='quantitative' />
+            <column-instance column='[Target]' derivation='Sum' name='[sum:Target:qk]' pivot='key' type='quantitative' />
+          </datasource-dependencies>
+          <filter class='categorical' column='[federated.0683hos176mghg18jfdcj01g7fgn].[none:Category:nk]'>
+            <groupfilter function='member' level='[none:Category:nk]' member='&quot;Furniture&quot;' user:ui-domain='relevant' user:ui-enumeration='inclusive' user:ui-marker='enumerate' />
+          </filter>
+          <slices>
+            <column>[federated.0683hos176mghg18jfdcj01g7fgn].[none:Category:nk]</column>
+          </slices>
+          <aggregation value='true' />
+        </view>
+        <style>
+          <style-rule element='axis'>
+            <encoding attr='space' class='0' field='[federated.0683hos176mghg18jfdcj01g7fgn].[sum:Sales:qk]' field-type='quantitative' fold='true' scope='rows' synchronized='true' type='space' />
+            <format attr='display' class='0' field='[federated.0683hos176mghg18jfdcj01g7fgn].[sum:Sales:qk]' scope='rows' value='false' />
+            <format attr='title' class='0' field='[federated.1lm8rfp01pfb1y157heyi0tdr8s4].[sum:Target:qk]' scope='rows' value='Sales &amp; Target' />
+            <format attr='title' class='0' field='[federated.0683hos176mghg18jfdcj01g7fgn].[usr:Calculation_953355781789577216:qk]' scope='rows' value='Performance' />
+          </style-rule>
+          <style-rule element='label'>
+            <format attr='text-format' field='[federated.0683hos176mghg18jfdcj01g7fgn].[tmn:Order Date:qk]' value='*dd-mmm-yy' />
+            <format attr='text-orientation' field='[federated.0683hos176mghg18jfdcj01g7fgn].[tmn:Order Date:qk]' value='-90' />
+          </style-rule>
+          <style-rule element='worksheet'>
+            <format attr='font-weight' value='bold' />
+          </style-rule>
+          <style-rule element='legend-title'>
+            <format attr='font-weight' value='normal' />
+          </style-rule>
+        </style>
+        <panes>
+          <pane selection-relaxation-option='selection-relaxation-allow'>
+            <view>
+              <breakdown value='auto' />
+            </view>
+            <mark class='Bar' />
+            <mark-sizing custom-mark-size-in-axis-units='1.0' mark-alignment='mark-alignment-left' mark-sizing-setting='marks-scaling-on' use-custom-mark-size='false' />
+            <style>
+              <style-rule element='mark'>
+                <format attr='mark-labels-cull' value='true' />
+                <format attr='mark-labels-show' value='false' />
+              </style-rule>
+              <style-rule element='pane'>
+                <format attr='minwidth' value='1139' />
+                <format attr='maxwidth' value='1139' />
+                <format attr='minheight' value='145' />
+                <format attr='maxheight' value='145' />
+                <format attr='aspect' value='0' />
+              </style-rule>
+            </style>
+          </pane>
+          <pane id='1' selection-relaxation-option='selection-relaxation-allow' y-axis-name='[federated.0683hos176mghg18jfdcj01g7fgn].[sum:Sales:qk]'>
+            <view>
+              <breakdown value='auto' />
+            </view>
+            <mark class='Bar' />
+            <mark-sizing mark-sizing-setting='marks-scaling-off' />
+            <encodings>
+              <color column='[federated.0683hos176mghg18jfdcj01g7fgn].[none:Category:nk]' />
+            </encodings>
+            <style>
+              <style-rule element='mark'>
+                <format attr='mark-labels-cull' value='true' />
+                <format attr='mark-labels-show' value='false' />
+                <format attr='size' value='1.6701657772064209' />
+              </style-rule>
+              <style-rule element='pane'>
+                <format attr='minwidth' value='1139' />
+                <format attr='maxwidth' value='1139' />
+                <format attr='minheight' value='224' />
+                <format attr='maxheight' value='224' />
+                <format attr='aspect' value='0' />
+              </style-rule>
+            </style>
+          </pane>
+          <pane id='2' selection-relaxation-option='selection-relaxation-allow' y-axis-name='[federated.1lm8rfp01pfb1y157heyi0tdr8s4].[sum:Target:qk]'>
+            <view>
+              <breakdown value='auto' />
+            </view>
+            <mark class='Area' />
+            <encodings>
+              <lod column='[federated.0683hos176mghg18jfdcj01g7fgn].[none:Category:nk]' />
+              <lod column='[federated.1lm8rfp01pfb1y157heyi0tdr8s4].[sum:Target:qk]' />
+            </encodings>
+            <style>
+              <style-rule element='mark'>
+                <format attr='mark-labels-cull' value='true' />
+                <format attr='mark-labels-show' value='false' />
+                <format attr='mark-color' value='#a0cbe8' />
+              </style-rule>
+              <style-rule element='pane'>
+                <format attr='minwidth' value='1139' />
+                <format attr='maxwidth' value='1139' />
+                <format attr='minheight' value='224' />
+                <format attr='maxheight' value='224' />
+                <format attr='aspect' value='0' />
+              </style-rule>
+            </style>
+          </pane>
+          <pane id='3' selection-relaxation-option='selection-relaxation-allow' y-axis-name='[federated.0683hos176mghg18jfdcj01g7fgn].[usr:Calculation_953355781789577216:qk]'>
+            <view>
+              <breakdown value='auto' />
+            </view>
+            <mark class='Bar' />
+            <mark-sizing mark-sizing-setting='marks-scaling-off' />
+            <encodings>
+              <color column='[federated.0683hos176mghg18jfdcj01g7fgn].[usr:Calculation_953355781789577216:qk]' />
+              <lod column='[federated.0683hos176mghg18jfdcj01g7fgn].[none:Category:nk]' />
+            </encodings>
+            <style>
+              <style-rule element='mark'>
+                <format attr='mark-labels-cull' value='true' />
+                <format attr='mark-labels-show' value='false' />
+                <format attr='size' value='1.087458610534668' />
+              </style-rule>
+              <style-rule element='pane'>
+                <format attr='minwidth' value='1139' />
+                <format attr='maxwidth' value='1139' />
+                <format attr='minheight' value='145' />
+                <format attr='maxheight' value='145' />
+                <format attr='aspect' value='0' />
+              </style-rule>
+            </style>
+          </pane>
+        </panes>
+        <rows>([federated.1lm8rfp01pfb1y157heyi0tdr8s4].[sum:Target:qk] + ([federated.0683hos176mghg18jfdcj01g7fgn].[sum:Sales:qk] + [federated.0683hos176mghg18jfdcj01g7fgn].[usr:Calculation_953355781789577216:qk]))</rows>
+        <cols>[federated.0683hos176mghg18jfdcj01g7fgn].[tmn:Order Date:qk]</cols>
+      </table>
+      <simple-id uuid='{C975713C-4086-4120-A4FC-F5C47D1D3741}' />
+    </worksheet>
+  </worksheets>
+  <windows saved-dpi-scale-factor='1.5' source-height='75'>
+    <window class='worksheet' maximized='true' name='Sheet 1'>
+      <cards>
+        <edge name='left'>
+          <strip size='146'>
+            <card type='pages' />
+            <card type='filters' />
+            <card type='marks' />
+          </strip>
+        </edge>
+        <edge name='top'>
+          <strip size='2147483647'>
+            <card type='columns' />
+          </strip>
+          <strip size='2147483647'>
+            <card type='rows' />
+          </strip>
+          <strip size='2147483647'>
+            <card type='title' />
+          </strip>
+        </edge>
+        <edge name='right'>
+          <strip size='100'>
+            <card mode='radiolist' param='[federated.0683hos176mghg18jfdcj01g7fgn].[none:Category:nk]' show-all='false' type='filter' />
+            <card pane-specification-id='1' param='[federated.0683hos176mghg18jfdcj01g7fgn].[none:Category:nk]' type='color' />
+            <card pane-specification-id='3' param='[federated.0683hos176mghg18jfdcj01g7fgn].[usr:Calculation_953355781789577216:qk]' type='color' />
+          </strip>
+        </edge>
+      </cards>
+      <viewpoint>
+        <highlight>
+          <color-one-way>
+            <field>[federated.0683hos176mghg18jfdcj01g7fgn].[none:Category:nk]</field>
+            <field>[federated.0683hos176mghg18jfdcj01g7fgn].[yr:Order Date:ok]</field>
+          </color-one-way>
+        </highlight>
+      </viewpoint>
+      <simple-id uuid='{0F0F4737-D6EB-403D-97C2-ED1040E6DF06}' />
+    </window>
+  </windows>
+  <thumbnails>
+    <thumbnail height='192' name='Sheet 1' width='192'>
+      iVBORw0KGgoAAAANSUhEUgAAAMAAAADACAYAAABS3GwHAAAACXBIWXMAABYlAAAWJQFJUiTw
+      AAAgAElEQVR4nO2dd3gVZdq475k5Peekk5BGQgKhhN4RFEGwgCiCZbEruuK66/a++1vddYu7
+      ut9+3667sssqFhAUEBVBmnSVXhJ6CS0hvZ2cPuX3R0IgQJITZAKBua/rXMmZmXeeZ97zPvPW
+      53kFTdM0DAyuU8QrrYCBwZXEMACD6xrTuV/8fj9ut/tK6WJg0OYI5/YBVFVFVdUrqc9FKSkp
+      ISEh4UqrYXAN0qgGEEURUbz6WkWiKGIymVq+0MCglVx9pd3AoA0xDMDguiZsA1D8NaxctZIa
+      nwJAxbFdrNt5RDfFDAzagrAMQA54KTqZz/z5H3DkZBElJSWsX/o+n2zI01s/AwNdCatnWbpn
+      Fc+9MIOyiip+/aPnMEsC1ogEvvWLIXrrZ2CgK0I4SyE0VcHvLmfxirXcdMt4nFYRm82GJApt
+      oSNFRUV07NixTWQZXF+EVQMIooQ9qgMDMiL5w8++TTBlOA/naJxOGMW9N3bXW0cDA90IvxNc
+      W8rrb8zjhlEjKS0vJy5SYtOuAy0kCrF+8Wx+/Yuf8fNfvciidbsAjVN7v+Tl3/6a//fSX9l7
+      qgoC1bz77tsUu0MEq4/zr9ffwR0y1ugZ6E/4s0uCgCRKiJKEGqxl7cbjRGc90GKa9N4j+MWt
+      D6DVHuf/ZqygdnAGny1fz/gnfkiCbw//WbCE7GfG4/V6UEIeFr63gMETnsRpbpvmlcH1TdgG
+      IEXEM+3hSbwyYzZUB9ju6M/PJwxtPpFoItYFH749i5LqagbdejeCv4yQKZUuqdHYhUEkzN9I
+      hQKyu5R5b8zAnnkDgzKiARqWZWiahqIol/6UBgZNELYBaKpKQrdhvPTyALw+GYfDjiTIyKqG
+      qZnOsNURy6AbhnP65EH25+bRP6MXF+t2i1YXvbO7kHu8hKAKlvrG2Zk+uuG2YKAH4RtAsJY3
+      X/k5y3ecajgmiBLpfcbwm198i0Sn9YI0iuyjqMRNZvcepKfFs+3VmXhNozArheQXVpMYPEip
+      PYkYCUSLjZwhY9HK3mDVjmPcMTCjYV2SIAjGWiADXQjfAJQAJSEnL782i06xVnKXzWKr2p3A
+      V++ycscpHrox6yJpgmz4dA67j5WhmewMGTuJlMgoxtw0gDmvv4xPdDLl0acwA5IoIYgmRk+6
+      j3+9PpfT2c+S5DJfzmc1MLiAsOYBAFRvGT///ndJvukhxg/JZPk7f6MwZSIDfKtw953O46Oz
+      dVPSmAcw0Iuwh0FFRxzTn53GqS8W8eKLL3FIzuCxiYOxJw5geE6SnjoaGOhG2DWA4q9h+dLF
+      xHa/iQFdOmIym2irgUqjBjDQi/BrAEmi/OguZrzxAT5NaLPCb2CgJ2F3gmW/h1PlNZTs3srj
+      j+4gzmWl97iHeP7+m3VUz8BAX8LvBMsBDh/cjydw1mc4skMaWanxuil3BqMJZKAXYdcAomQi
+      WHGC9xetxifXGUHO6PvaxAAMDPQi/MVwnjLefHseHTrGcbA0SEYUiDaXnroZGOhO+NOrqkLI
+      HsMdY0ayJm8JQwem8cmxk0Af/bQzMDiHao+f7/19WZPnxwzozCO3tq48hr8YzhXHncOGonTI
+      5JaECl54fT/Tfv5yq4QZGHwdNA0qanxNnvf6g62+Z1gGUHl0K8sOa3xj6sMA5Lw8g2dlFYvZ
+      WJ9j0L4JqwTXFh1kxRe1jB3QudFxi91JZIRNF8UMDNqCsF/he1fN4bEtHzU6Nvieb/HCUxOa
+      TqSp5OdtYsmKdVT4NAbdcjd3DOtO0eEdzF+0HI8UzeSpD9I1BuZ/vJRRd0whWitm9vwNTHn4
+      flyGU4yBzoRtADljH+aV797b6JjZam8+kaZQVuVj3L2P08Hm478zFjGkfypLl65k8J2P0MG3
+      l7kLl/OzJ8dSUVmBLPv49IP5ZN001fAIM2gTwjIAZ8eu3DJcIzo6unV3F80MvnEMqhzk8K48
+      pPhkJG8pfiGF3t1ScAhxxC35P8oVkGsrWPTuTNSEfkzqVhcIV9O0hs/VGLTXoG1pqQxoWsvX
+      nE9YBhCTOZipma26bwNBbwUrPl7EcW8EUx+8G7NyEk0T69cSiYiihqqBaLaSkppCflUtIQ3M
+      Qt3DnDEAwyXSoGUDaH05afUwjiKH0EQJUxhRpDVVZtOKxQQT+vLkjf2wmSVC3jhMSiEnS2pJ
+      CB2h1NyRGBOI1ggG3TwBYdF/WZd7ilv6pCJJElAXHdpsNpxjrndMpuYLtygKrS4nYRtAyF+L
+      2w+2mv38+YNdZJpPQo97eHRc3ybTqCE/u3bv4KT3ANs+/xBRiuSZn/6IG4f2YN4/XyaIjdsf
+      eBzLmQSChVsnT+af/1lEr6zpJEYYw6wG+hLWYjh/xRG+89S3ORW0ce83f0Bg01ss2Onjb2/8
+      h96JjibTaZpGKBRs5ARvtlgRUAmFQmiIWOr9CkKyjGSq+18OhZBMZsR6Z3tjMZwBQFWtn8f+
+      sKjJ8+OHdeGZuwa16p5hrQWqOLQNb5fxzJ31KrvnvcpeUz9++tBAFi7Z2Gw6QRCwWKxYrWc/
+      ogCCINYdt5gRBAGEuqpLFAQEQcBssTQUfgMDPQnLAKI6ZSMcXsOPfvY7ikKRDB7Qldzde/XW
+      zcBAd8JqZDs69uGPL/+WEp9IRrzErJlvUeXqzbS7Ruqtn4GBroQXHFcQSeuaQ1r99x/8+ndo
+      CIiC0UwxaN9c0jCLpmkoqopgajvHeIOm8fiCyMrFx8gFQSAy4sKgZVcb//10B4u/ONjk+Zk/
+      mYgkXf4dvVrhD+Bn6bwP6DRyLDsWvM6mkzKPfet7DMrqcNmVMmgdf3h3A3n5JRc953JYePdX
+      k9tYo9ajaRrqFQh/Gb5TfG0Fy77azCPpHZj3ZTEPjkpk/vKvGPTsRD31M7hKKa3ycKq0psnz
+      XVJicTmu/pqnVT7BJn8N781bQOagsXRJKGBPxfUzUfXh+v2s3p7f5PkXnriZ2MgWFgdeQ2zZ
+      X8iMj7c1ef6lp0bTOzOxDTW6NMI3AEc8zzz9KCu2HuO2yeMp3LyYSaMH6qnbVUWl28fx4uom
+      zzfVBje4ugm/VyEIdEjuhF1188mytUS5XMjGAjWDdk7YNYDqr+a1V15GjU5i+z4vY+Nj+GSd
+      yLDuLccFDflrqagN0SEuBlEAVQ5SUlxMSLCSnNQBSVMoKasgOq4DZlGlpLCImKRkLMZscLvn
+      3I6tpoEGoIGGVrd8uf60rDbfAa7yy2gtjDnWBhSOVfgbviuqdo68Ol0a/taLC98AQj5K/SKT
+      Rwwi9+NcTpwoANJbSsWJvM18unItnoiuPD9tMhZNZsuKBazdW4QQ8tF91BQm9k9k0aIFTHzg
+      KYTTm1iwqZKnHk4OV7XrlrqRk5auqSsYGhqqWlfglPoCoNQn1qi7j9ZQQM4W1nNlaIBa/6XY
+      3bwD+qFSPyGLu1Fa7RwZ2jmFEqCohfvtK/a1uCtpjV/heGUAQaChgJ87VXV+aoFWGIDJ2YFJ
+      o3rx17++RlG1n9dOdubXfxncQiqNkBDBmNE3sXJHIQBBbyU7DpTw0NPPEaec5G8zVjG2//11
+      52pO8dHi7Uz55nSs0tXx9m8oJC0UtJqAjOQJNRQwWTk7rKedKXRn/m8oeDQUvLOyBEBD0RrL
+      VFQNhPo5GA0E7WyhqgnITeolqxrbTrkbvp+5pdDwVzh7TICjJ0r4/Mt9ja4Xzvl/3IiedE7t
+      gDvQfPM3IKt4Q2ojWeci1JdM8by/TWGWWp54FYS661pDWAYQCviRVY0hE6cxc/QUKqr8xMbH
+      43JFtJBSIiunNzWn9iAK9QYQrEA1JxPvsmAVMkgQy6gKQrD8BH979W8MGP8kKZF1C6RlWW7w
+      BgsGWx/yorXIqkZesR9PUG38FkHjVLW/2bS5hbVEORU04MyLSoBGr6BzfxpRaFwYL/b/+Wma
+      oiXjFGnugnMaFhqEQjLVbm+TV4dCMmjqeVpeTCcV7cweb82rV39981epqtr4dX7Re6CPQ8yM
+      F59myc7yC44Pvuc5Xny6Gaf4iyCKNlBqCaoaFsGDJ2DHZgZLXCee/8YYFi5YRflNvYizSQ3b
+      IomiiMViaeHOXx9VVgmqfqxm6YJzktD8eIHNbMJmuTLDws0VCwEaHIvCoaW3rCgISJKE2EJ+
+      CKLYKrlCS3JFMawaoDUyIUwDuO/ZF7nVd2E164hOaD6hplBUcJLiEwXU1lRy5PBh0lKTiLWU
+      s3rdFuICRwh16k50/XPZYjMZPzSXRUs38fikG7hKWkFXBFlWOF3a9LCrK8JGdGTTvhgG4RGW
+      ASSmZZII1JYXsG3XPoJKXXUVj53UhGYc5VWFfTu+5NBpN1FW2LBuDbffP43b75nMqlXrOSLG
+      8NA9oxFEhczMLGxmge433MmJT5dS5gmR6Lx+3SA9vgBzPvmqyfOD+3RmzLAebajRtUkrdoms
+      5rXf/4odBbUUVPhIdUH/+35C/+y0phNJFkZPnMro849HZjLlwcZe9mPH3tqg0m133ROuWgYG
+      X4vw1wJ53ZwKOfjlDx/iN299wU/HJ7LK07r21rXO0ZOlnDx9YV/pDIP7ZOKw6d+XMQifsA3A
+      HOGic2wcocgOxJfm8Y8P9pA1Vr+dIdsjJ09X8NXOo02e790tzTCAq4ywDEDTNBTsPPPDHyJa
+      7UyfPpW8Cht33jFCb/0MDHTDHwiFZwC+0r389tWP+dGLP6Now2xeePVdNHscnXoO4OaeV/+K
+      v+Y4XlTF0cJKAEKqRn65v9Fwc1anBOzGW7tdUVXjZeHypleq9uvRiQE56ZRWuMMNj55HsT2R
+      OHMtr7//EROff5nulctYum4rN/ds3TwAaIT8bnZu3YZXimHYkD5YtSC78vaR1aMPERaF7V9s
+      JXvI8DYJjrt5fyHvLt/d5PnHJo8wDKCdISsKpRXuJs97fIGG/8OLDZqQhC9/AQvmePmiPI7/
+      jOxO0YrV0LQ/RJNoSpCl771BkaUTLt8u3iys5ZkJvdi0+SsSOvfk2MaPyAtkMeAaDo7rD4QI
+      hZqesXS2AxfGcAkEZYLBppdqOBwWpDCiDOpFWAbg6jSUh27+ig9X7+bR6d+io8PEuhOV3Diy
+      V6sFBmrLOOW28+D0e4gSKvifl2fjHt8LLRQkP+9Lvtzj45npA65pX+M1m/aza//JJs8//+jY
+      NtRGX7bm5rNh26Emzz8xZSQJcZFtqFFjwjIA0WRl4hM/YeITZ49N/e6LlyRQlmtBisVuERCI
+      JtriwSOD7K1k7Zp1JPS5zQiNbtBmtHndYzK7QC7DE1DRghVUBF04zWCOSuSRp75J8MB6jlQ0
+      v/DMwOBy0eart6wR8XSOVZj97nu4AoXE9L0JZ/05yRbHvXcN5535S3nuqUlYDYeYy8bxgvJm
+      R0bG3tCT3t1S21Cjq4M2NwBBsjDu/sdJ2Z2LV+rPgH49ENQgI0feRKRdwtH1Bsb7tlDrU7Aa
+      0aEvG6qmEgw13RlVrtMNSK5ICTNZnfQZPPzsAdFKz545DV+79x1yBbQyuB4xXrEtICsaQUVF
+      acFhI6SqDZ5eTV5Tf6+W3BhDikZIaclBpO5eAM29uzUgqKgt+twq9fdr6Tq5/rqWnjXcfDtz
+      v5aCYoUUFbGF4VJVq3vWlvLu3GdttD+A1+ulpuYSBvd1xu1243K5dLm31x/C08wGyw67FVEU
+      CQRDdd5QTRDhsBEKyc02Mxx2G6IoEAiECMnN30sDvN6mBwPMZhNWS91ycZ8/2KQnlCAIRDhs
+      KIqKzx+46DUAVqsZs8mELCv4A03nh81qwWSSCIVkAsFQk9fZbVYkSSQYkgk2c11r8hfAE0ae
+      qKqK19f0s1rMZiwWE4qiNq4BHA4HDsfV42RxrptcYmL7XnJhcHWifxNI0/B5qqmq8WJ2uIiL
+      diGg4XVXU13rwxUTj9NmJuCpxo+NqAgL/tpqAthw2s0NPsFyM29MA4NLRXcDqDq9j9lzlxKg
+      rpqb+PCzpJtLeGf2fHyaiGZP5umnHuT09hXsUnO4f0Q6H85+m+63P0z/9FjA2CTPQD90NwCr
+      swP3PPwUHeMjyVv1HgfyC/HVbCJx4AQmjezGivdmsO1AEXVRgDS2rZiPlnEjfTvF6q2agYH+
+      M8H2yA4kdXByePsqluwoY1ifVIrLgmRlJCNJZrpmplJcUgbAhoX/4e0NZdw1ti/GHJhBW6C7
+      AaghLys+eJMVudVM+9Z0UqKs2MzgqR9p8Hh82O11PfyRk5/irhwTa3ecDCuWjIHB16VVBqAE
+      veQf3EfuoeNUFJ2i3N3ymp3iQ1vJLbdx66iBeMtPU1YVIDM7hS1r1nLw0B7Wbs+na+eUBnVu
+      vus+Dq9ZRGG1/oGwDAzC7wMofhbNfIUP1+dSFdOPn99oYSPD+MnUG5tN5g/IWJUqli1ZDED2
+      kFu5pd8ohlYuY+WK9eSMmUKPJAeFFR1JVp1IER25e1w/9h8+QfLALtf0smiDK09YG2UDhKoL
+      +P4vfsujD9zNKwt38etbo5h1OIlXn9c/hImxUbaBXoTdBDJFRNMjRuKd+YupPL6bV99cRp+e
+      RlQIg/ZN2DUAmkrZiUOs3bSZ0go/cUmdGTvuJmIc+vvLGjWAgV6EXQOovgr+9o8ZZI+4m+nP
+      PEW6nMc/56/XUzcDA90J2wA0VcHrrqKouBxZ9nOqsKjZxVAGBu2BsEeBpIh4Hpw4kt/96ln+
+      VxCxxHfh938aqaduBga6E34fAFBVBW9tFRVVAeI6xGK1WDDpsHv3+Rh9AAO9CD86tOzl47f+
+      xfKthxocOnqNncq37x2ll24GBroTtgEo3mpWb9nDmLseJimqLnBTTHJmC6kMDC4/+cXV1Poa
+      9z8zO0YRYWv9iuHwN8q2R9K9U0cEq52oqDrvLCPSscGV4J3V+8k73jgM/e8eGk631JhW3yv8
+      GsBfS3llKV+89XrDdpV9b3uU708d00wqDX9NGes/X8YRTyzTpo7HLGic3Pclsz9YgkeM4RtP
+      TCOng8C77y9i3KQHiVEKmTl3HY9Me7hNYoMaXN+Evz+AK5Gf/f7vVNfUNjgwW+zOFlIp7Ni4
+      kYDoIBT0oQGyv5rPlm/gzmk/IsG3l38vWEK3Z8bj9XmRg7UsmLuAoXc+aRR+gzahFZ1gH3P/
+      /gJzlm2jwhPEZREYMvWn/P6b45u9/fA7JlFzag8nV+0HIOAvRzalkpUSjV0YSIJnAxUKyDWl
+      zHtzBo7MEQxMr9t3TD2zzaamtXr7S4NrmIsMXKqqekllJPwtkjwVfHW4nB//4Fn+7+PdfPfG
+      KA5GXcJu7udsU38uos1F325d2Z1fQlAFi3jmcq3RXwODi6GhXVIZCX+neKsVl9lOVHIKUuGH
+      fLU3iuqUbKBfqwRa7XGYlQLyC6tJDB6k1J5EjASixUbPwbeglr7Byu3HGD8ooyEOjCAIDXsG
+      GxhcbMNsSZQuqYyEnUKwxvK9H/0AU0xHfvndKazbW8aUSS3MAch+5s78H7YeKiMkK/xq31am
+      /fj33DJqELNnvIxPcHHvY09hBiTJhCCaGDPpPv75+lxOd3uWJJfhCG+gL61YDapw4sAutu89
+      1hCJLLFLP0b00X8uwJgJNjiX387d1PbDoHJtKa/+8Xe4bUlEWOq2R80REtrEAAwM9CL8iTCr
+      g/SufRj32PfITqiLHidKRrvcoH0Tfh8AAaqP84OnH8RSvwBu8D3P8cJTzQ2DGhhc3YRtAGrA
+      w0mfjd//70yyEyPqElvtuilmYNAWhN+GMdtItMPaz5dxJLqu4Cd3H8So/l310s3AQHfCnwlW
+      NTK69+RUZQUFnrpj1qQeeullYNAmhN8HEEQcES6GDxvHiJzrby8pg2uT8EeBzGa8xYdZuLmc
+      Xn/8PlFWSU+9DFpJaW2QY5W+RscSnRY6xRj9tOYIfx7A5+bo6XIq9m3ikYe2E+u0hLEc+tpC
+      UTX8cuMNiSQBbOYr/zI4XRNgzZGKRscGpES2KwM4XRNgzo7CRsdSo2w80C9JN5nhO8Xbo/nG
+      k99hdHEJ5W4/HRKTSExO002xq5Fyb5D3dhY1OpYUaeX+PsYsdXsl/CaQZKLq2C5mzFqEOyAT
+      ldyTn/zyp3rqZnCVE1RUlh4oa3TMZhK5LTv+CmnUesIO6aB4ypjz4Sruf/4F/vXP17ijq8J7
+      S77QUzeDqxxNg4KaQKPPaXfTm9NdjbQqpommKahIOJ12QoEARhB/g/ZO2AYgOTsw7aG7eP+v
+      P2XylKmsKozm8btvugSRGp7K0yz/ZCEfLllNlS8EIS8bN26g2qeghmpZvXwV7pBhXQb6E1Yf
+      4LN5M0gdfCe7T/l4deYcrKg4Xc5L2sZIDflZOv89lOT+RHmP8vaHCt+ZPIg9e3LJ7DWI/SsX
+      Uh41CKfhE2zQBoRlAMfzvmL1gRqO531FSZWfaHvdsF9qzjDGDu7eKoEBbxmlvigeuu1mXPTn
+      wJ9mUa0NQg142bnxM/aftvHs+B7GxhgGbUJYBnDf0z/gnXc/YI/XT2lJMX5rXcspopO31QIV
+      2YsqurCaBAScOM0+fDKoIR+HDx4mIn04Nqmu+Muy3OAQ73a7CQbrtk2yWOriEQUCASTprCuc
+      3+/HbDYjSRKqqhIIBLBa63YiVxSFUCiEzWZruLeiKHXnA5VYv/hNIz0FVxI1/X7ccG+fz4dk
+      NjOlmwtV1QgEAthsNkyiQFVVVcO9JX8ptrx/NH5oVxpVmY81bPXq9/uxufOxbPhTo8tC8Tko
+      I37UcG9BELAcmYslUNzouvKke7DGdAIgGAwiCALJdolv9IzCHwhgNpmQJAmLJFJSUtKQB6qq
+      Is6ZhuatbvysT8wBs41QKISmaVgsFlR/Y4cTEAjiaMhfTdPw+f1MzHQgCCKqqhAMBnHY7bjd
+      7sb56ylB/OR7je8Wm45vzO8a/XYWycT9PaLQNK3htzNLYqP8BXh4RCd8g5KwWq0NeRBlkXG7
+      3Y3KhXX9b5Hcpxrn8Zg/4JWiGvI3LAOI7dSbb3+/E527f0avEePJTHSFk+yimC3RiEox1V6Z
+      WK2IMjmaSDOYnHFMmvIAy96eSe7pvvROcjZkjiRJuFwXyjz/2MWuCQdN9KJ4Go/va5KZmJiz
+      Hkbh3lujCs1b0vig2Uls7NltX10uF2rwJMGaxpM+luhOWKKiGt9P88J5hTEuJgrhEp+1urIA
+      zVvZ6FhURASC1dH4wjDuHxkZGZZMVanCX13Q+KDZdtH8jQvjfi39FmfOBwOVaO7GeeywWXDG
+      JDR8D7sTLKCwe81H/OOdJQSUS++gWiNi6ZkWwdsz/8O/Xn+HzjeMIOKMDJOLyffeyvIFH1Eb
+      Upu9j4HB5SD81aBIZHTrzqZP3+a3gZMkR9tJ7zuKO0f2ap1E0czIiVNJyz9GQIiga1YaaDK3
+      3TaeGIeENbIv94+3oyoaGD7x4EwF4bylFpL1yuhyDRK+P4AgENsxk8n3nV3+YLVcmkukZLaT
+      mX3uUmoz6enpDd/SMrtd0n2vRYSuU660Ctc04c8D2CIZe+ttdIy2Y03owg29s0hJSmg5oYHB
+      VUz4TaCgm7+/9EtOBq3kh5LIuT2Khbt8vDjtNj31a384UxHGv33eQWNQ92ol7BpA9rk5Xisy
+      9Z7bsZo0qqqq8QeM3dzPRxAEBEE872MYwNVKK6JDxzO2bxr/84+ZFJZ7+duJGJ574VE9dWs7
+      JAtC0sDGxxwdrowuBm1K+E0gTWDo+AdJHzaBgF+hQ3In0lOujUIi2GKQbn7pSqthcAUIywBk
+      fzl/+uF3+HxfEaIthh/87q8MSb02Cr/B9U1YfYCKfevZqXbng0+W8sq3b2fu/I/11svA4Gsj
+      OOLAmdjoI4iN3/lh1QABnxe700Hh0YOERDvVJQfJzc3FFZ9MRlI4k9cG5yPEdsZ8++8bH3MY
+      eXk5MU94tcVrwjIAszMOofgz/vKX3QBEAX/5y1/oe/tj/PDBW76Wktcrgj0Gqcv1kXeC2Y7U
+      5ebGxyL1c3RvDWGFR1eVEP5A6ILjkskS1mywr7qYI0VeemR3RhJADtSyd3cuXimKAf16YFGD
+      7D14mPQuPXCYFfK27Saz3wAiTHXDh0Z49MtH9R+GX7gY7tfbL1wMd50QVg0gSmYcjktZmKOQ
+      t34pH6/egjmpD9ldOyOqQVZ8MIujwVgc/gL2FLh5clw3NmxYR0xKVwq2LGFzWSI5A1u+u4HB
+      10Xn+OYCCVkDeTotnflrDwIQ8JSRXy7x4PRvEC2U8+qf51E7thuaEqLw8DZWbynjm8/djWhM
+      HumCGNcJzd54yfXFthy6XtDFAKpKCiip8hCfnEFCchI1p84GbJJDbjDF47CKCMQSa3FTGwLZ
+      Xcbij5fQachdRBrukLrhembelVbhqqJVUSHCpfBILmvXruVk+YUeYyaTE+QKvEENLVRJZdBJ
+      hAXM0Uk8OX063n3rOVbVvkJrGLRfdKkBeg6/nZ7DAVVmz7aNHDuWT0lhCWs+/5wBw0aQGulj
+      3rwFRAVOEdFjEGf8e0yOBCbf0Y95C1fy3BMTMCoCA73RfY8jRVGQIuIZ2j8eTZVBtHDH1CfZ
+      uXUbHqkLk4f0QdCCDBkyDJdNJKLnzdzi/YIqT4gYm4Cmaaiq2uAPbGBwOQl/l8griDEMaqAX
+      uvQBDAzaC41qAK/XS01NzZXU56LIstzkLuCqqjbsKN8cV+K6K3GvMz9nSz4IV3O+hXvd5bhX
+      u2gCNUcoFGqIt9MciqIgSS3H8Q/3unDkXk6Z4T6npmlomtZiwbicz9ma+11t+dvuN/oN19sq
+      nIxqzXXhyL2cMsN9zjqPtMun27Wev+2+BjAw+DoYnWCD65p2awCaplJy6ghfbdzAxi82kX/6
+      /FiWbYFC/p48imt8LV962Qiyb/tuqoNyG8oEVfWwc1MubTtHr3A0L48St375204NQOOLj9/g
+      zYWfU15di7uyhCWz/8XcVbt03LNDQw4FCQQC53y8bFuzmmNlbt1khoLny3Sz/tMVlPj0nBjU
+      CDaSGcDvK2X5R6vRryheLH89bF39OcfLa3WT2k47wdVs2nSah3/9K1LsdZ0lZUfLtDgAAA/W
+      SURBVFQOL/1pCe5b+hJeyNbWorJp8dss2nSMKKet/phGVZmPtDt0EQiEWPbO39lwtBqn3dKg
+      R3mxzGi9RALg4d+/f4EiIRKbue4dqWkhPGGFrr1UVL78eBafbD1BZMQ5+Vvqo7OOUtupAUSQ
+      nCTy5YZNDMxORtRkTuRtJKJzBvq5dUjkDBrCroooHnt0ChFmEQjw4b/+o5tEsDBg6CBORQR5
+      +v6xSKIAuJn5kp4yAZzcMKI/+fb+TL6pJwKghAr562/m6yizLn9zq+N4/JF7cJhFwM+C12bq
+      KBOkF1544QVdJeiCRGa3bpQezWNX3j7yjx5DicxgyoRRRFxivNJwsDpjSU6Iwel0YpLq3oyC
+      IBGfnEJkwxv68uKM7UiHKCdR0a4GHwlBMJPUKRW7Sb/9iTukpOOy24iKjGiIaydKNtI6p+j2
+      1rS5YklKiMHlcmESzzyrSIeUVFw2fSIlt9MaABzRiYydeC+aplIXetDLto176TWyP7aWEl8i
+      gmQmNS313COYLZaGH0sXmSYbGekpjWVaLZe0PVVrMNmjaCxWwGq16BrkUZAspDXKXzBbrPU1
+      nz60006wis/jwePx4PX68Hq9eGpLWPnJWl07acGAD0+93LpPDdvWrtWxk6YR8HnPk1nJxs9W
+      U+q/0Ef78nE2f898at3FrPx0nb75678wf7euWcOJCqMTfB4+Zr3yIkVCFHbLmWZAiEoufeea
+      llHZtnQOH24+TmzkmZ6GRkWxm/Rm030dQqyc+zobjrqJijizJ4BCSWmAMbrJBPDxxp9foESK
+      wW6pf0dqIaqJaj7Z10Jly5J3+XjrSWIa5W8tWTpKbacGEMGIkQPYJ+Rw/5jeCICqFPHKL+bq
+      KFOix6ChbC9z8tij9+G0tF0n+LjVxzPfuLUNO8F1+XvI3Jt7b+7VZp3gnoOGsqsy+pxBBqMT
+      3CRxyenEuhxEOh117VJBwGxxkJqRrJtVW50xpCV1qOsE17dLJZOFDsnJunXSnDEdSYqPwhXp
+      rO8EC5jMVpLSUnTtBMenZBDrdOA6J38tFgcp6frlr80ZS1pSPE6ns6Hdr3f+orV73Nrbr/xT
+      y3f72lTqzuVztY82HmhDibK2et4sbd3eU20oU9M0rUab9efXtOMef5tK3f7Ze9onXx7UXU47
+      7QQ3Jpw14ZebcFddXnaZV2CzjSuWv23wrO14NahGVWkJqtWJy25BMpnaLJaQIgeorKhCk6zE
+      xkTpOkwH4C4vojpkokNsFCaThNQmBVJDVVRUTUOWZSSTCQEBSZJ0DSPk91RRVasSG+tCEiUk
+      Sd9nbaedYACNgkO72LT/JJgc9MzpRZcuWcRFOXR9b4Q8pXwwZy5uwYmkeLEkdOe+O0djN+v3
+      QwVqS/n8863IiGR0y6FHt2w6xrp0roE09n+5lOU7juOwmlGCfgKqiD0iinF3Tvpae0U3h6+y
+      kJUrNuGTVdKzc8jumkVax3jdXjLtuAYANI1Q0E9VZRmbVy9h61GJ7/3yKV0H6wr2rGXeuhKm
+      PzUZU7CSt2e8xZD7n6RPakzLib8GmipTVVrIqk8/ZPPBYlIyunHbhAl0T4vXSaLC2vdn4ckY
+      wYhuScg1R3lj4V7G9LOxuSCGpx8co9vbU1VkaqorOZK3mU+W7eCeZ79F39TYlhNeAu26Bigv
+      OMrWnbs4cPAIzoR0bpvQv2HT7csuTZWprfVidsVhNRXgra3FIqjY7DbMYXomXSrukmN8vnYD
+      ew+dIqvXAL5z52NEKSf4v/9+yPd/9bROzyxgNkNxcQXWfpkEK4J4qj1EdeyEeqgavbYxD9RW
+      sH3rVvbv30+NGsHwcWPJiNNvfqcd1wAKB3ZsodYUS8/uWdjN+hbCgKeQ999axPkLnyVrFOMn
+      30NajH7L8E4fyeWk20K/Xl2xmM6szgxy4mgxyVlpuu0n7ncXs/iD+RwucaMKVm6ZdB+JviMc
+      VdMYPSBTl6ZmeeEh9h6tomff3sS59FrUcpZ2bACgygHyD+Sx72gBzvhUBvTrQ6Rd/0ot4Kmm
+      sKiMiOg4lICX+MQkzJJ+7XE14Gbd58s5VlyLIICmObnjgYkk6rQAr46zneCzCEgmSeexmbqa
+      fUfufmSTk5w+fUlNiNZNZrtuAuVvW8WibWXcctNASvd/xayj5Tz30Dj0rAsC1QW8884HiJGR
+      JCT1ouzQZkbe+wRdEvRqfMGpvA1sOSmTEx1JSo8kVq8/hF33kSCVnWsWs+lgIQBywIspsguP
+      Pnm3bs1MAG/pEWbNXsTg0eOI9hfx3uy5PDLtSZIi9TH2dmwACvmHTtD7htvp1ysDtYuLzb/7
+      iFrG6doJLj15EL+jC9MeGMDmL4rxoVHp9YKOxSLg9xOTkEbHyFo6du6G9ZOvKA+EiLTq+fOJ
+      9BpxK9lDFQD8xXt4d02pbittz1BedBxbYg4jBvVB1LpyaOcBTle5SYrUxxmnHRuARHafbN5b
+      sRSLuxelh3cRN6CfTt5gZ4lPyiBY9gEr1ygUHSqhMiAyMlZfqRk5g9i37TSdMhOZ8/rrhBK6
+      kmDTs/lThyyHCNTvDCSLEjXHTuABXfM4IS2b4JI5LF1hwxos46TqYFycfhLbdR9A0xQK8w9y
+      9FQptsgO9OndHauObfEzeCpOk7vvMLJgIatHL5Ji9GwUXCkUdqxeytbDp+u+CiayB93ITf26
+      6D4/66koZPe+I6iijeycXnSItOsmq50aQC0rFi6jWm2susWewLgJN6FPdsls/uwzHDnDifUc
+      5oA7jtGDu+gi6SxBtq5ezbHy88eeHNx851ji26AWAEDTcFeVcrqkloxumegjVWHPV+vYd+r8
+      6B5Who4ZTVqsUxep7bQJZKVb334E62035Kti+5frOeQNod++ixqlp04Q2XkA5rICjpW3xbIL
+      hRP78zhBDH1ycsjKSKZu30ATLrO+P52madSUFXLgwH527thJRdBMj5zBpHfL1EmiQFJGV6zx
+      aXXyVZnDuVvYnJtP7xtH6SSz3dYAdT+Q7HezZcPn7DhUSu+hIxncqws2q1mnKjrEpzNfx53a
+      h+jq/ex1xzNuaDZgIi0rk2iHtcU7tB6NoN9PVdlpcvP2crLgNPbYZHr16Ue3zsk6umLW8Maf
+      /0GwQzpdsrri8Bxmr68z0yYP17X5o2kaaApH8rayat1mErMHMHLYAGJddt3WebXTGiDIxiWL
+      2HygiP4jx/D4k3dgFgX0bZyKZA8cxIGCcuSIFLIj4Pjx44CV2NROOhmAgMVmJyG1M6MSkqmp
+      rmDXV2t5/805PPHTb5Ph0qttLCBKJkwmCZPZjCgIbbCPnsrxvE18uupL4jr3ZcpjTxNplQAB
+      NHT7bdtpDVDJv/84Ayk5FZvpbM5YHR0Zf88tOoZGOYunqoyAFEGsboUQQKHkRD47duVSXlWD
+      bHLRM6cH3bpm4bTr66CuaRrVpQUcPHiQ3bt2URGQ6NZrCHfcOkynPkCINfNnk1smn5enNkbc
+      fhsZcfr0AdqpAWjIssL5qguC2AYzlXVs+/QtjkYM4b6be+goxcPbf/4rhZY4umWmE9HgFWVn
+      8KhhxFj1WgRxLiGOHziOLTaCqjIvGT2y0KOuAw1FUVDV84tj3eyz0QRqhHDOhhke3v/n+wx7
+      bCqdItqiQNQRm9wZ2ab3rIONCY9OozZwfgQIk67ukI3x8dl7H3Hrj79Ntx5JOsoRkCQTZ9YV
+      5n6+kNOR/bh1kF6d7jquAY8wldrqGuQL3hz6ktHvRoZ0j2fxf//N1mOlOkmRiOuYTHp6Ounp
+      acjVZaj2aNLTU7Dp7ChyFgu9hw8kUufFhucT9HnwXmD4l5922gQ6F41QMIRo8rHq422MnDRG
+      pz6AwsFtX5B3vLTxsR37Gf3EMwzNTNBF6llklr89E6n/BG7pnaazrAtRlSpWLd7BiLtHt0kf
+      S5FDaIJK7oYviek1SLc+QDttAoUoPF7YMA8AoGnlbPlyN4N1MwARUa7mUEENY0f0rY/MJlNy
+      MF8XaReT32vEGITYKIpOFhCV1FHHZlCIgmMFnPv+VZUytmzKZbBuBqBSVVpMlefcAOxBdmze
+      Ru/0HMMAGqOwZM7rVEakE1vf7tc0Hx5dZQpk9BpOz5LNdOnZmyibCQhSsmcfljZpj4skZ2UD
+      bma+No9R35lO1yi93sUKn85+nRpXBjFn8lf14dVJ2hkOblrGxztK6Zx8xvtL4URZDb11lNlO
+      DcDGzaOGsr4imcfvHNJGgbHAFBHLhAm3neOLa+bmKfchWvQZF4EAy2a/yVeHi885plJZqqLf
+      3Cicyd8va1J5dPzgNgqMJdJz0HA2ndrMfQ8/WD8HoH9grHbbB9BUGX9AwWa3IgCa5ufwvgLS
+      e2bpNE4NgdoyVi5ZzPa9+QQVFXtkHMNG38GogdlIugzTaRzZspQ1p5w8cueZWdhaZv3pDW5+
+      /lkda4CL5K/q5/D+QjJ6ZurmgaZpKgF/ALPVVu8Er1CYfxx7Ygoxukw0ttsaAEJ+L/t3b+Pg
+      0dMogonULt0Z2KenboUfVHas+oRiaxY//uWj2EwC7tJ8/vvmApJSnqFHkh5DogKZfUZSLp2o
+      m5kVBcBGVk43nDqPyoT8Hvbt2sah/CIUwURa1x4M7N1Tt8IPoCkyxScOsGP3ATxBheiEFAYM
+      HKjTLHsd7XQYVGHZ3H+z/WSAnL796denO5X7NzDrw3UousnU8PtDREZF17k/CmBzRhJhFgkp
+      ermIg2CNpE92CieOHGL/gUMUFHsZNWkCSToWClBYOuff7CoINeRv+d51vPWRvvl7eMty3l+x
+      ndSuOQwc0I8oKnn7rdkU1+i3M1k7rQFqOHTIzzd+cxvJtrqGQfcMFy/98VM8jNHJYUOi/6gx
+      LFiwmFc3r8DhMOHxBkjrPozsjvpNiBXs+5L3P9tETGwsJhFqqsqJ7DyEB+64QUc/5BoOHwnw
+      4Au3kmStk5HdKYI//mUZ3vtH6xSDW+bo/mP0v+luBvWpXxGanc6xvf+hsKqWjpFGE+gcoujR
+      3cH82fPo3yMDkxrgcO5mEvoPR5/BsnqpHbN49Oln8fp8BGUVq9WKw+HQMTKcny9WfsGQOx/i
+      hi6JCEDIU8Rrf3uPwpsGkh6pl4NiFN2zbcyf/T79uqdjUgIcyt1MYv8bdMxfE9m9u/Le0oUo
+      pf2JcZkpOXmI43IEdxgeYReiqTJH9u7k6KlSFMFEQqeuDOiRcQUiZ+qJzIp3/0VJ/BAmDO+B
+      SRSoLNjLW4u2Mv35bxLv0K9FrqkyR/bs4GhBGapgIiE9m/7d09skIkTu/iN4giqRMQn079cX
+      p02//k67NYDrBX9NCZ8vW8qeY6WYJAHREcOYcePpldmxDZYoX/sYBtBO0DQVVUX3YLHXG4YB
+      GFzXGK8Tg+sawwAMrmsMAzC4rjEMwOC6xjAAg+sawwAMrmsMAzC4rjEMwOC6xjAAg+sawwAM
+      rmv+PxIhINcVIQaiAAAAAElFTkSuQmCC
+    </thumbnail>
+  </thumbnails>
+</workbook>

tests/test_liveboard_creation_context.py

@@ -137,7 +137,9 @@ def test_prepare_liveboard_creation_context_falls_back_to_ddl_columns(monkeypatc
 def test_normal_thoughtspot_deploy_path_uses_golden_two_tab_layout():
     source = inspect.getsource(thoughtspot_deployer.ThoughtSpotDeployer.deploy_all)
 
-    assert 'layout_strategy="golden_two_tab"' in source
+    # The golden layout is the default; a DP Migrator build (mirror_tiles from the
+    # prospect's dashboard, 2026-10-28) is the one case that takes the mirror layout.
+    assert 'layout_strategy="mirror" if mirror_tiles else "golden_two_tab"' in source
 
 
 def test_tml_export_parser_accepts_yaml_exports():

tests/test_migration_questions.py

@@ -0,0 +1,201 @@
+"""DP Migrator plumbing around the spec: questions per sheet, the blueprint
+statement, the argument loader, and the picture reading's JSON -> spec.
+
+Run: pytest tests/test_migration_questions.py -q --noconftest
+"""
+from __future__ import annotations
+
+import base64
+import io
+import json
+import zipfile
+
+import pytest
+
+from demoprep_app.migration import questions as q
+from demoprep_app.migration.image_spec import _extract_json, _spec_from_json
+from demoprep_app.migration.sources import (
+    describe_source_arg, load_source_dashboard, load_workbook_arg, spec_result,
+)
+from demoprep_app.migration.spec import (
+    MirrorError, MirrorSpec, ROLE_DATE, ROLE_DIMENSION, ROLE_MEASURE, SOURCE_TABLEAU,
+    ShelfField, SourceDashboard, SourceField, SourceJoin, SourceSheet, SourceTable, Zone,
+)
+from demoprep_app.migration.statement import HEADING, statement_from_spec
+
+
+def _spec():
+    combo = SourceSheet(
+        name="Sheet 1", marks=["Bar", "Area"],
+        rows=[ShelfField("Target", ROLE_MEASURE, "sum"), ShelfField("Sales", ROLE_MEASURE, "sum"),
+              ShelfField("Sales V Target", ROLE_MEASURE, "sum")],
+        cols=[ShelfField("Order Date", ROLE_DATE, grain="month")],
+        color=ShelfField("Category", ROLE_DIMENSION), filters=["Category"], dual_axis=True,
+        chart_type="ADVANCED_LINE_COLUMN", fidelity="approximated", notes=["dual axis drawn as a combo chart"])
+    kpi = SourceSheet(name="Total Sales", marks=["Text"], cols=[ShelfField("Sales", ROLE_MEASURE, "sum")], chart_type="KPI")
+    stacked = SourceSheet(name="Mix", marks=["Bar"], rows=[ShelfField("Sales", ROLE_MEASURE, "sum")],
+                          cols=[ShelfField("Region", ROLE_DIMENSION)], color=ShelfField("Category", ROLE_DIMENSION),
+                          chart_type="STACKED_COLUMN")
+    gone = SourceSheet(name="Returns", marks=["Bar"], rows=[ShelfField("Returns", ROLE_MEASURE, "sum")],
+                       cols=[ShelfField("Region", ROLE_DIMENSION)], chart_type="COLUMN")
+    return MirrorSpec(
+        source_kind=SOURCE_TABLEAU, name="Sales vs Target",
+        tables=[SourceTable("ListOfOrders", ["a"] * 10, "table", "excel-direct"),
+                SourceTable("OrderBreakdown", ["a"] * 8, "table", "excel-direct")],
+        joins=[SourceJoin("ListOfOrders", "OrderBreakdown", "Order ID", "Order ID", "inner")],
+        fields=[SourceField("Sales", ROLE_MEASURE, "integer", "OrderBreakdown", "sum"),
+                SourceField("Target", ROLE_MEASURE, "integer", "SalesTargets", "sum"),
+                SourceField("Returns", ROLE_MEASURE, "integer", "OrderBreakdown", "sum"),
+                SourceField("Sales V Target", ROLE_MEASURE, "integer", formula="SUM([Sales])-SUM([Target])"),
+                SourceField("Number of Records", ROLE_MEASURE, "integer", formula="1"),
+                SourceField("Category", ROLE_DIMENSION), SourceField("Region", ROLE_DIMENSION),
+                SourceField("Order Date", ROLE_DATE, "date")],
+        sheets=[combo, kpi, stacked, gone])
+
+
+MODEL = [{"name": "Sales", "type": "MEASURE"}, {"name": "Target", "type": "MEASURE"},
+         {"name": "Sales Vs Target", "type": "MEASURE"}, {"name": "Category", "type": "ATTRIBUTE"},
+         {"name": "Region", "type": "ATTRIBUTE"}, {"name": "Order Date", "type": "ATTRIBUTE"}]
+
+
+def test_one_question_per_sheet_in_the_models_words():
+    qs, dropped, warnings = q.questions_from_spec(_spec(), MODEL)
+    assert [x["title"] for x in qs] == ["Sheet 1", "Total Sales", "Mix"]
+    assert qs[0]["question"] == "total Sales and total Sales Vs Target and total Target by Order Date monthly", \
+        "on a combo the target-like measure goes last, so it is drawn as the line over the bars"
+    assert qs[0]["measures"] == ["Sales", "Sales Vs Target", "Target"]
+    assert qs[0]["chart_type"] == "ADVANCED_LINE_COLUMN" and "Category" not in qs[0]["question"], \
+        "colour is not kept on a combo, so it is not asked"
+    assert qs[1]["question"] == "total Sales monthly", "a KPI gets the model's date for its trend"
+    assert qs[2]["question"] == "total Sales by Region and Category", "a stacked column keeps its colour split"
+    assert dropped == ["Returns"]
+    assert any("Returns" in w and "dropped" in w for w in warnings)
+
+
+def test_resolver_prefers_the_column_whose_words_cover_the_source_name():
+    names = ["Sales Vs Target", "Sales", "Product Sub Category", "Category", "ORDER_DATE"]
+    assert q.resolve_column("Sales V Target", names) == "Sales Vs Target"
+    assert q.resolve_column("Sub-Category", names) == "Product Sub Category"
+    assert q.resolve_column("Order Date", names) == "ORDER_DATE"
+    assert q.resolve_column("Net Revenue", names) is None
+
+
+def test_statement_binds_the_vocabulary_without_prohibitions():
+    text = statement_from_spec(_spec())
+    assert text.startswith(HEADING)
+    assert "Sales (sum); Target (sum); Returns (sum)" in text
+    assert "Sales V Target = SUM([Sales])-SUM([Target])" in text
+    assert "Number of Records" not in text
+    assert "Order Date is the date on the charts (monthly grain)" in text
+    assert 'inner join to OrderBreakdown on Order ID' in text
+    assert '"Sheet 1": Target, Sales, Sales V Target by Order Date (month), colour by Category [combo chart' in text
+    assert '"Mix": Sales by Region, colour by Category [stacked column chart]' in text
+    assert "do not " not in text.lower() and "never " not in text.lower(), \
+        "directives.py reads those as binding prohibitions"
+    from demoprep_app.scenario.directives import extract_directives
+    assert extract_directives(text).is_empty()
+
+
+def test_statement_leaves_out_join_keys_and_source_ids():
+    spec = _spec()
+    spec.fields += [SourceField("Order ID", ROLE_DIMENSION), SourceField("Order ID (OrderBreakdown)", ROLE_DIMENSION)]
+    spec.fields[3].formula = "SUM([Sales])-SUM([federated.1lm8rfp01pfb1y157heyi0tdr8s4].[Target])"
+    text = statement_from_spec(spec)
+    assert "Order ID" not in text.split("Source tables")[0].split("Dimensions")[1].split("Date:")[0]
+    assert "Sales V Target = SUM([Sales])-SUM([Target])" in text
+    assert "federated." not in text
+
+
+def test_statement_from_a_picture_says_so():
+    spec = _spec()
+    spec.source_kind = "image"
+    assert "read from a screenshot" in statement_from_spec(spec)
+
+
+# ---- argument loading ------------------------------------------------------
+def test_workbook_text_and_twbx_zip_both_load(monkeypatch):
+    import demoprep_app.migration.sources as sources
+    seen = {}
+
+    def fake_parse(xml_text):
+        seen["xml"] = xml_text
+        return _spec()
+    import demoprep_app.migration.tableau_twb as twb
+    monkeypatch.setattr(twb, "parse_twb", fake_parse)
+
+    assert load_workbook_arg("<?xml version='1.0'?><workbook/>").name == "Sales vs Target"
+    assert seen["xml"].startswith("<?xml")
+
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as zf:
+        zf.writestr("Data/extract.hyper", b"\x00customer data\x00")
+        zf.writestr("Book.twb", "<?xml version='1.0'?><workbook version='18.1'/>")
+    uri = "data:application/octet-stream;base64," + base64.b64encode(buf.getvalue()).decode()
+    assert load_workbook_arg(uri).name == "Sales vs Target"
+    assert "workbook version='18.1'" in seen["xml"]
+    assert "customer data" not in seen["xml"]
+
+    with pytest.raises(MirrorError):
+        load_workbook_arg("hello there")
+    with pytest.raises(MirrorError):
+        load_workbook_arg("data:application/zip;base64," + base64.b64encode(b"PK\x03\x04junk").decode())
+    empty = io.BytesIO()
+    with zipfile.ZipFile(empty, "w") as zf:
+        zf.writestr("Data/x.hyper", b"")
+    with pytest.raises(MirrorError, match="no .twb"):
+        load_workbook_arg(base64.b64encode(empty.getvalue()).decode())
+
+
+def test_loader_prefers_the_workbook_and_describes_without_content(monkeypatch):
+    import demoprep_app.migration.tableau_twb as twb
+    monkeypatch.setattr(twb, "parse_twb", lambda xml: _spec())
+    spec, notes = load_source_dashboard("<workbook/>", "data:image/png;base64,AAAA")
+    assert spec is not None and notes and "ignored" in notes[0]
+    assert load_source_dashboard("", "") == (None, [])
+    d = describe_source_arg("<?xml version='1.0'?><workbook>ListOfOrders secret host</workbook>")
+    assert d.startswith("<twb xml bytes=") and "ListOfOrders" not in d and "secret" not in d
+    assert describe_source_arg("") == ""
+
+
+def test_spec_result_carries_counts_and_tiles():
+    out = spec_result(_spec(), tiles=[{"title": "Sheet 1", "chart_type": "ADVANCED_LINE_COLUMN", "question": "x"}],
+                      dropped=["Returns"], extra_warnings=["note"])
+    assert out["carried"] == {"exact": 3, "approximated": 1, "dropped": 0}
+    assert out["tiles_built"][0]["title"] == "Sheet 1" and out["tiles_dropped"] == ["Returns"]
+    assert out["warnings"][-1] == "note"
+    json.dumps(out)
+
+
+# ---- picture reading -------------------------------------------------------
+def test_vision_json_becomes_a_spec_with_zones_and_lower_fidelity():
+    d = {"dashboard_name": "Sales Overview",
+         "measures": [{"name": "Sales", "aggregation": "sum", "format": "currency"}],
+         "dimensions": [{"name": "Region", "sample_values": ["East", "West"]}],
+         "dates": [{"name": "Order Date", "grain": "month"}],
+         "sheets": [
+             {"title": "Total Sales", "marks": ["Text"], "measures": [{"name": "Sales"}],
+              "position": {"x": 0, "y": 0, "w": 0.25, "h": 0.15}, "confidence": 0.9},
+             {"title": "Sales by Region", "marks": ["Bar"], "measures": [{"name": "Sales"}], "y_dimension": "Region",
+              "position": {"x": 0, "y": 0.2, "w": 0.5, "h": 0.4}, "confidence": 0.8},
+             {"title": "Sales Trend", "marks": ["Line"], "measures": [{"name": "Sales"}], "x": "Order Date",
+              "color": "Region", "date": {"name": "Order Date", "grain": "month"},
+              "position": {"x": 0.5, "y": 0.2, "w": 0.5, "h": 0.4}, "confidence": 0.7},
+         ], "confidence": 0.8, "notes": ["axis labels small"]}
+    spec = _spec_from_json(d)
+    assert spec.source_kind == "image" and spec.name == "Sales Overview"
+    assert [s.chart_type for s in spec.sheets] == ["KPI", "BAR", "LINE"]
+    assert all(s.fidelity == "approximated" for s in spec.sheets)
+    assert spec.confidence == 0.8
+    assert spec.primary_dashboard().sheet_names == ["Sheet 1", "Sheet 2", "Sheet 3"]
+    assert spec.sheets[2].color.field == "Region" and spec.sheets[2].date.grain == "month"
+    assert {f.name for f in spec.fields} == {"Sales", "Region", "Order Date"}
+    assert "axis labels small" in spec.warnings
+    qs, dropped, _ = q.questions_from_spec(spec, MODEL)
+    assert [x["question"] for x in qs] == ["total Sales monthly", "total Sales by Region",
+                                           "total Sales by Region and Order Date monthly"]
+
+
+def test_extract_json_tolerates_fences_and_prose():
+    assert _extract_json('```json\n{"a": 1}\n```') == {"a": 1}
+    assert _extract_json('Here you go: {"a": [1, 2]} thanks') == {"a": [1, 2]}
+    assert _extract_json("nothing") is None

tests/test_migration_twb.py

@@ -0,0 +1,438 @@
+"""parse_twb: a Tableau workbook's XML -> MirrorSpec.
+
+The real workbook in tests/fixtures/tableau_dual_axis_example.twb (Tableau
+2020.1, two Excel data sources blended, a legacy inner join, a dual-axis
+bar + area sheet) is the ground truth; the small hand-written workbooks below
+cover the grammar the fixture does not use (dashboards, 2020.2 relationships,
+parameters, KPI/bar sheets, Measure Values, table calcs).
+
+Run: source .venv/bin/activate && python -m pytest tests/test_migration_twb.py -q --noconftest
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from demoprep_app.migration.spec import (
+    FIDELITY_APPROXIMATED, FIDELITY_EXACT, MirrorError, MirrorSpec,
+    ROLE_DATE, ROLE_DIMENSION, ROLE_MEASURE, SOURCE_TABLEAU, SourceJoin,
+)
+from demoprep_app.migration.tableau_twb import parse_twb
+
+FIXTURE = Path(__file__).parent / "fixtures" / "tableau_dual_axis_example.twb"
+
+#: Strings that would leak where the prospect's file lives; none may reach the spec.
+LEAKS = ("C:/", "Tableau/Datasources", "federated.", ".xlsx", "excel-direct.")
+
+
+@pytest.fixture(scope="module")
+def spec() -> MirrorSpec:
+    return parse_twb(FIXTURE.read_text(encoding="utf-8"))
+
+
+# ---------------------------------------------------------------------------
+# the real workbook
+# ---------------------------------------------------------------------------
+
+def test_fixture_identity_and_meta(spec):
+    assert spec.source_kind == SOURCE_TABLEAU
+    assert spec.name == "Sheet 1"                      # no dashboards: first worksheet
+    assert spec.confidence == 1.0
+    meta = spec.source_meta
+    assert meta["format"] == "twb"
+    assert meta["tableau_version"] == "18.1"
+    assert meta["source_build"].startswith("2020.1.0")
+    assert meta["worksheets"] == 1
+    assert meta["dashboards"] == 0
+    assert "sha256_12" in meta and meta["bytes"] == FIXTURE.stat().st_size
+    assert set(meta) == {"format", "tableau_version", "source_build", "worksheets", "dashboards", "bytes", "sha256_12"}
+
+
+def test_fixture_tables(spec):
+    by_name = {t.name: t for t in spec.tables}
+    assert set(by_name) == {"ListOfOrders", "OrderBreakdown", "SalesTargets"}
+    assert len(by_name["ListOfOrders"].columns) == 10
+    assert {"Order Date", "Ship Mode"} <= set(by_name["ListOfOrders"].columns)
+    assert len(by_name["OrderBreakdown"].columns) == 8
+    assert "Sub-Category" in by_name["OrderBreakdown"].columns
+    assert len(by_name["SalesTargets"].columns) == 3
+    assert all(t.connection == "excel-direct" for t in spec.tables)
+    assert all(t.kind == "table" for t in spec.tables)
+
+
+def test_fixture_joins(spec):
+    inner = [j for j in spec.joins if j.kind == "inner"]
+    blends = [j for j in spec.joins if j.kind == "blend"]
+    assert len(spec.joins) == 2
+    assert inner == [SourceJoin("ListOfOrders", "OrderBreakdown", "Order ID", "Order ID", "inner")]
+    assert blends == [SourceJoin("ListOfOrders+OrderBreakdown", "SalesTargets (P1-AmazingMartEU2)",
+                                 "Category", "Category", "blend")]
+    assert any("blended onto ListOfOrders+OrderBreakdown on Category" in w for w in spec.warnings)
+
+
+def test_fixture_fields(spec):
+    measures = {f.name: f for f in spec.measures()}
+    assert {"Sales", "Profit", "Quantity", "Discount", "Target", "Sales V Target"} <= set(measures)
+    assert (measures["Sales"].aggregation, measures["Sales"].datatype) == ("sum", "integer")
+    assert measures["Discount"].datatype == "real"
+    assert measures["Target"].datatype == "integer"
+    calc = measures["Sales V Target"]
+    assert calc.is_calculated
+    assert calc.formula == "SUM([Sales])-SUM([federated.1lm8rfp01pfb1y157heyi0tdr8s4].[Target])"
+    assert spec.field_named("Number of Records") is None
+    assert spec.field_named("Measure Names") is None
+    assert not any(f.name.startswith("Calculation_") for f in spec.fields)
+    dims = {f.name for f in spec.dimensions()}
+    assert {"Category", "Sub-Category", "Region", "Segment", "Ship Mode", "Country", "State", "City",
+            "Customer Name", "Product Name"} <= dims
+    dates = {f.name for f in spec.date_fields()}
+    assert {"Order Date", "Ship Date", "Month of Order Date"} <= dates
+    assert measures["Sales"].table == "OrderBreakdown"
+    names = [f.name.lower() for f in spec.fields]
+    assert len(names) == len(set(names))                # deduped across data sources
+
+
+def test_fixture_sheet(spec):
+    assert len(spec.sheets) == 1
+    s = spec.sheets[0]
+    assert s.name == "Sheet 1" and s.title == "Sheet 1"
+    assert s.marks == ["Bar", "Area"]
+    assert s.dual_axis is True
+    assert [(f.field, f.role, f.aggregation) for f in s.rows] == [
+        ("Target", ROLE_MEASURE, "sum"), ("Sales", ROLE_MEASURE, "sum"), ("Sales V Target", ROLE_MEASURE, "sum")]
+    assert [(f.field, f.role, f.grain) for f in s.cols] == [("Order Date", ROLE_DATE, "month")]
+    assert s.color is not None and (s.color.field, s.color.role) == ("Category", ROLE_DIMENSION)
+    assert s.size is None
+    assert s.filters == ["Category"]
+    assert s.chart_type == "ADVANCED_LINE_COLUMN"
+    assert s.fidelity == FIDELITY_APPROXIMATED
+    assert any("combo" in n for n in s.notes)
+
+
+def test_fixture_tiles_and_summary(spec):
+    assert spec.tiles() == [spec.sheets[0]]
+    summary = spec.summary()
+    json.dumps(summary)                                 # must serialise for the inspect tool
+    assert summary["sheets"][0]["date"] == "Order Date (month)"
+    assert summary["sheets"][0]["measures"] == ["Target", "Sales", "Sales V Target"]
+    assert summary["tiles"] == ["Sheet 1"]
+    assert MirrorSpec.from_dict(spec.to_dict()).summary() == summary
+
+
+def test_fixture_leaks_nothing_about_the_file(spec):
+    strings = [spec.name]
+    for t in spec.tables:
+        strings += [t.name, t.kind, t.connection, *t.columns]
+    for f in spec.fields:
+        strings += [f.name, f.table, *f.notes]           # formulas are kept verbatim and are not names
+    for j in spec.joins:
+        strings += [j.left_table, j.right_table, j.left_field, j.right_field]
+    for s in spec.sheets:
+        strings += [s.name, s.title, *s.notes, *s.filters, *(f.field for f in s.shelf_fields)]
+    strings += spec.warnings + spec.parameters
+    for leak in LEAKS:
+        assert not [x for x in strings if leak in x], leak
+
+
+# ---------------------------------------------------------------------------
+# input validation
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("text", ["not xml", "<foo/>", "", "   \n", "<workbook>"])
+def test_rejects_non_workbooks(text):
+    with pytest.raises(MirrorError) as err:
+        parse_twb(text)
+    assert "Traceback" not in str(err.value) and "Exception" not in str(err.value)
+
+
+def test_rejects_oversized_text():
+    with pytest.raises(MirrorError, match="25 MB"):
+        parse_twb("<workbook>" + " " * (25 * 1024 * 1024 + 1))
+
+
+def test_rejects_xml_entities():
+    with pytest.raises(MirrorError):
+        parse_twb("<!DOCTYPE x [<!ENTITY a 'b'>]><workbook>&a;</workbook>")
+
+
+def test_bare_workbook_has_low_confidence():
+    spec = parse_twb("<workbook/>")
+    assert spec.name == "Tableau workbook"
+    assert spec.sheets == [] and spec.fields == [] and spec.tables == []
+    assert spec.confidence == 0.5
+    assert any("complete Tableau workbook" in w for w in spec.warnings)
+
+
+# ---------------------------------------------------------------------------
+# hand-written workbooks
+# ---------------------------------------------------------------------------
+
+DS = "federated.0abc123def456ghi789"
+DS2 = "federated.9zyx876wvu543tsr210"
+
+ORDERS = """<relation connection='excel-direct.1' name='Orders' table='[Orders$]' type='table'>
+  <columns header='yes'>
+    <column datatype='string' name='Category' ordinal='0'/>
+    <column datatype='integer' name='Sales' ordinal='1'/>
+    <column datatype='integer' name='Profit' ordinal='2'/>
+    <column datatype='date' name='Order Date' ordinal='3'/>
+  </columns>
+</relation>"""
+
+
+def _meta(local: str, parent: str, kind: str, agg: str) -> str:
+    return (f"<metadata-record class='column'><remote-name>{local}</remote-name><local-name>[{local}]</local-name>"
+            f"<parent-name>[{parent}]</parent-name><local-type>{kind}</local-type>"
+            f"<aggregation>{agg}</aggregation></metadata-record>")
+
+
+ORDERS_META = (_meta("Category", "Orders", "string", "Count") + _meta("Sales", "Orders", "integer", "Sum")
+               + _meta("Profit", "Orders", "integer", "Sum") + _meta("Order Date", "Orders", "date", "Year"))
+
+DEPS = f"""<column datatype='string' name='[Category]' role='dimension' type='nominal'/>
+<column datatype='date' name='[Order Date]' role='dimension' type='ordinal'/>
+<column datatype='integer' name='[Sales]' role='measure' type='quantitative'/>
+<column datatype='integer' name='[Profit]' role='measure' type='quantitative'/>
+<column-instance column='[Category]' derivation='None' name='[none:Category:nk]' pivot='key' type='nominal'/>
+<column-instance column='[Order Date]' derivation='Month-Trunc' name='[tmn:Order Date:qk]' pivot='key' type='quantitative'/>
+<column-instance column='[Sales]' derivation='Sum' name='[sum:Sales:qk]' pivot='key' type='quantitative'/>
+<column-instance column='[Profit]' derivation='Sum' name='[sum:Profit:qk]' pivot='key' type='quantitative'/>"""
+
+
+def _datasource(relation: str, metadata: str = "", columns: str = "", caption: str = "Sales Data",
+                ds_id: str = DS) -> str:
+    return f"""<datasource caption='{caption}' inline='true' name='{ds_id}' version='18.1'>
+  <connection class='federated'>
+    <named-connections>
+      <named-connection caption='Book1' name='excel-direct.1'>
+        <connection class='excel-direct' filename='C:/Tableau/Datasources/Book1.xlsx' password='' server='' username='boone'/>
+      </named-connection>
+    </named-connections>
+    {relation}
+    <metadata-records>{metadata}</metadata-records>
+  </connection>
+  {columns}
+</datasource>"""
+
+
+def _worksheet(name: str, rows: str = "", cols: str = "", mark: str = "Bar", encodings: str = "",
+               deps: str = DEPS, filters: str = "", layout: str = "") -> str:
+    return f"""<worksheet name='{name}'>
+  {layout}
+  <table>
+    <view>
+      <datasources><datasource caption='Sales Data' name='{DS}'/></datasources>
+      <datasource-dependencies datasource='{DS}'>{deps}</datasource-dependencies>
+      {filters}
+    </view>
+    <panes><pane><mark class='{mark}'/><encodings>{encodings}</encodings></pane></panes>
+    <rows>{rows}</rows>
+    <cols>{cols}</cols>
+  </table>
+</worksheet>"""
+
+
+def _workbook(datasources: str = "", worksheets: str = "", dashboards: str = "", extra: str = "") -> str:
+    dash = f"<dashboards>{dashboards}</dashboards>" if dashboards else ""
+    return f"""<?xml version='1.0' encoding='utf-8' ?>
+<workbook source-build='2020.1.0 (20201.20.0219.0753)' version='18.1' xmlns:user='http://www.tableausoftware.com/xml/user'>
+  <datasources>{datasources}</datasources>
+  {extra}
+  <worksheets>{worksheets}</worksheets>
+  {dash}
+</workbook>"""
+
+
+def test_dashboard_zones_sizes_and_order():
+    kpi = _worksheet("KPI", mark="Text", encodings=f"<text column='[{DS}].[sum:Sales:qk]'/>")
+    bars = _worksheet("Bars", rows=f"[{DS}].[none:Category:nk]", cols=f"[{DS}].[sum:Sales:qk]")
+    dash = """<dashboard name='Overview'>
+  <size maxheight='800' maxwidth='1000' minheight='800' minwidth='1000' sizing-mode='fixed'/>
+  <zones>
+    <zone h='100000' id='1' type='layout-basic' w='100000' x='0' y='0'>
+      <zone h='100000' id='2' name='Bars' w='50000' x='50000' y='0'/>
+      <zone h='100000' id='3' name='KPI' w='50000' x='0' y='0'/>
+      <zone h='10000' id='4' type='text' w='100000' x='0' y='90000'>
+        <formatted-text><run>Hello</run></formatted-text>
+      </zone>
+    </zone>
+  </zones>
+  <devicelayouts>
+    <devicelayout auto-generated='true' name='Phone'>
+      <zones><zone h='100000' id='9' name='KPI' w='100000' x='0' y='0'/></zones>
+    </devicelayout>
+  </devicelayouts>
+</dashboard>"""
+    spec = parse_twb(_workbook(_datasource(ORDERS, ORDERS_META), kpi + bars, dash))
+
+    assert spec.name == "Overview"
+    assert spec.source_meta["dashboards"] == 1 and spec.source_meta["worksheets"] == 2
+    dash_spec = spec.primary_dashboard()
+    assert dash_spec is not None and (dash_spec.width, dash_spec.height) == (1000, 800)
+    assert [z.kind for z in dash_spec.zones] == ["sheet", "sheet", "text"]   # container skipped, phone layout skipped
+    kpi_zone = spec.zone_for("KPI")
+    assert (kpi_zone.x, kpi_zone.y, kpi_zone.w, kpi_zone.h) == (0.0, 0.0, 0.5, 1.0)
+    bars_zone = spec.zone_for("Bars")
+    assert (bars_zone.x, bars_zone.y, bars_zone.w, bars_zone.h) == (0.5, 0.0, 0.5, 1.0)
+    text_zone = next(z for z in dash_spec.zones if z.kind == "text")
+    assert (text_zone.y, text_zone.h) == (0.9, 0.1)
+    assert dash_spec.sheet_names == ["KPI", "Bars"]                 # by position, not XML order
+    assert [s.name for s in spec.tiles()] == ["KPI", "Bars"]
+    assert spec.summary()["mirrored_dashboard"] == "Overview"
+
+
+def test_relationships_read_as_inner_joins():
+    returns = """<relation connection='excel-direct.1' name='Returns' table='[Returns$]' type='table'>
+  <columns header='yes'><column datatype='string' name='Order ID' ordinal='0'/></columns>
+</relation>"""
+    object_graph = f"""<_.fcp.ObjectModelEncapsulateLegacy.true...object-graph>
+  <objects>
+    <object caption='Orders' id='Orders_1A2B3C'><properties context=''>{ORDERS}</properties></object>
+    <object caption='Returns' id='Returns_4D5E6F'><properties context=''>{returns}</properties></object>
+  </objects>
+  <relationships>
+    <relationship>
+      <expression op='='>
+        <expression op='[Orders_1A2B3C].[Order ID]'/>
+        <expression op='[Returns_4D5E6F].[Order ID]'/>
+      </expression>
+      <first-end-point object-id='Orders_1A2B3C'/>
+      <second-end-point object-id='Returns_4D5E6F'/>
+    </relationship>
+  </relationships>
+</_.fcp.ObjectModelEncapsulateLegacy.true...object-graph>"""
+    spec = parse_twb(_workbook(_datasource(object_graph, ORDERS_META)))
+
+    assert {t.name for t in spec.tables} == {"Orders", "Returns"}
+    assert spec.joins == [SourceJoin("Orders", "Returns", "Order ID", "Order ID", "inner")]
+    assert "1 relationship(s) read as inner joins" in spec.warnings
+
+
+def test_legacy_left_join_and_custom_sql():
+    joined = f"""<relation join='left' type='join'>
+  <clause type='join'>
+    <expression op='='><expression op='[Orders].[Category]'/><expression op='[Targets].[Category]'/></expression>
+  </clause>
+  {ORDERS}
+  <relation connection='excel-direct.1' name='Targets' type='text'>SELECT category, target FROM secret_schema.targets</relation>
+</relation>"""
+    spec = parse_twb(_workbook(_datasource(joined, ORDERS_META)))
+
+    assert spec.joins == [SourceJoin("Orders", "Targets", "Category", "Category", "left")]
+    targets = next(t for t in spec.tables if t.name == "Targets")
+    assert targets.kind == "custom_sql" and targets.columns == [] and targets.connection == "excel-direct"
+    assert any("Custom SQL" in w for w in spec.warnings)
+    assert not any("secret_schema" in w for w in spec.warnings)
+
+
+def test_parameters_are_listed_not_carried():
+    params = """<datasource hasconnection='false' inline='true' name='Parameters' version='18.1'>
+  <aliases enabled='yes'/>
+  <column caption='Top N' datatype='integer' name='[Parameter 1]' param-domain-type='range' role='measure' type='quantitative' value='10'/>
+  <column caption='Region Pick' datatype='string' name='[Parameter 2]' param-domain-type='list' role='measure' type='nominal' value='&quot;East&quot;'/>
+</datasource>"""
+    spec = parse_twb(_workbook(params + _datasource(ORDERS, ORDERS_META)))
+
+    assert spec.parameters == ["Top N", "Region Pick"]
+    assert "2 parameter(s) are not carried: Top N, Region Pick" in spec.warnings
+    assert spec.field_named("Top N") is None
+    assert {t.name for t in spec.tables} == {"Orders"}
+    assert spec.summary()["parameters_not_carried"] == ["Top N", "Region Pick"]
+
+
+def test_text_mark_with_one_measure_is_a_kpi():
+    on_label = _worksheet("Total Sales", mark="Text", encodings=f"<text column='[{DS}].[sum:Sales:qk]'/>")
+    on_rows = _worksheet("Total Profit", mark="Text", rows=f"[{DS}].[sum:Profit:qk]")
+    spec = parse_twb(_workbook(_datasource(ORDERS, ORDERS_META), on_label + on_rows))
+
+    label, rows = spec.sheets
+    assert (label.chart_type, label.fidelity) == ("KPI", FIDELITY_EXACT)
+    assert [f.field for f in label.measures] == ["Sales"]
+    assert label.rows == [] and label.cols == []
+    assert (rows.chart_type, rows.fidelity) == ("KPI", FIDELITY_EXACT)
+    assert [f.field for f in rows.measures] == ["Profit"]
+
+
+def test_bar_sheet_with_dimension_on_rows():
+    sheet = _worksheet("Sales by Category", rows=f"[{DS}].[none:Category:nk]", cols=f"[{DS}].[sum:Sales:qk]",
+                       filters=f"<filter class='categorical' column='[{DS}].[none:Category:nk]'/>",
+                       layout="<layout-options><title><formatted-text><run>Sales by </run><run>Category</run></formatted-text></title></layout-options>")
+    spec = parse_twb(_workbook(_datasource(ORDERS, ORDERS_META), sheet))
+
+    s = spec.sheets[0]
+    assert s.chart_type == "BAR" and s.fidelity == FIDELITY_EXACT
+    assert [(f.field, f.role) for f in s.rows] == [("Category", ROLE_DIMENSION)]
+    assert [(f.field, f.role, f.aggregation) for f in s.cols] == [("Sales", ROLE_MEASURE, "sum")]
+    assert s.filters == ["Category"]
+    assert s.title == "Sales by Category"
+    assert s.dual_axis is False
+
+
+def test_measure_values_expands_to_dependent_measures():
+    sheet = _worksheet("Measures", rows="[Multiple Values]", cols=f"[{DS}].[none:Category:nk]",
+                       encodings=f"<color column='[{DS}].[:Measure Names]'/>")
+    spec = parse_twb(_workbook(_datasource(ORDERS, ORDERS_META), sheet))
+
+    s = spec.sheets[0]
+    assert [(f.field, f.role, f.aggregation) for f in s.rows] == [("Sales", ROLE_MEASURE, "sum"),
+                                                                 ("Profit", ROLE_MEASURE, "sum")]
+    assert s.color is None                                           # Measure Names is dropped
+    assert "Measure Values expanded" in s.notes
+    assert spec.field_named("Measure Names") is None
+
+
+def test_table_calc_is_noted_and_approximated():
+    deps = DEPS.replace(
+        "<column-instance column='[Sales]' derivation='Sum' name='[sum:Sales:qk]' pivot='key' type='quantitative'/>",
+        "<column-instance column='[Sales]' derivation='Sum' name='[sum:Sales:qk]' pivot='key' type='quantitative'>"
+        "<table-calc ordering-type='Rows' type='MovingCalc'/></column-instance>")
+    sheet = _worksheet("Trend", mark="Line", rows=f"[{DS}].[sum:Sales:qk]", cols=f"[{DS}].[tmn:Order Date:qk]", deps=deps)
+    spec = parse_twb(_workbook(_datasource(ORDERS, ORDERS_META), sheet))
+
+    s = spec.sheets[0]
+    assert s.chart_type == "LINE"
+    assert s.fidelity == FIDELITY_APPROXIMATED
+    assert "table calculation on Sales is not carried" in s.notes
+    assert [(f.field, f.role, f.grain) for f in s.cols] == [("Order Date", ROLE_DATE, "month")]
+
+
+def test_dual_axis_from_parenthesised_shelf_group():
+    sheet = _worksheet("Dual", rows=f"([{DS}].[sum:Sales:qk] + [{DS}].[sum:Profit:qk])",
+                       cols=f"[{DS}].[tmn:Order Date:qk]")
+    spec = parse_twb(_workbook(_datasource(ORDERS, ORDERS_META), sheet))
+
+    s = spec.sheets[0]
+    assert s.dual_axis is True
+    assert s.chart_type == "ADVANCED_LINE_COLUMN" and s.fidelity == FIDELITY_APPROXIMATED
+
+
+def test_uncaptioned_calculation_gets_a_readable_name():
+    columns = """<column datatype='real' name='[Calculation_123456789]' role='measure' type='quantitative'>
+  <calculation class='tableau' formula='{FIXED [Category] : SUM([Sales])}'/>
+</column>
+<column caption='Margin' datatype='real' name='[Calculation_987654321]' role='measure' type='quantitative'>
+  <calculation class='tableau' formula='SUM([Profit]) / SUM([Sales])'/>
+</column>"""
+    spec = parse_twb(_workbook(_datasource(ORDERS, ORDERS_META, columns)))
+
+    unnamed = spec.field_named("Calculated field 1")
+    assert unnamed is not None and unnamed.is_calculated
+    assert "level-of-detail expression; re-expressed loosely" in unnamed.notes
+    assert any("Calculated field 1" in w for w in spec.warnings)
+    margin = spec.field_named("Margin")
+    assert margin is not None and margin.formula == "SUM([Profit]) / SUM([Sales])" and margin.role == ROLE_MEASURE
+    assert not any(f.name.startswith("Calculation_") for f in spec.fields)
+
+
+def test_unreadable_dashboard_size_is_warned_not_guessed():
+    dash = """<dashboard name='Odd'>
+  <size maxheight='tall' maxwidth='1000' sizing-mode='fixed'/>
+  <zones><zone h='100000' id='1' name='Bars' w='100000' x='0' y='0'/></zones>
+</dashboard>"""
+    bars = _worksheet("Bars", rows=f"[{DS}].[none:Category:nk]", cols=f"[{DS}].[sum:Sales:qk]")
+    spec = parse_twb(_workbook(_datasource(ORDERS, ORDERS_META), bars, dash))
+
+    assert (spec.dashboards[0].width, spec.dashboards[0].height) == (1000, 0)
+    assert any("'Odd'" in w and "maxheight" in w for w in spec.warnings)

tests/test_mirror_layout.py

@@ -0,0 +1,233 @@
+"""Mirror layout (DP Migrator, boone 2026-10-28): the board copies the source
+dashboard's chart types, titles and arrangement instead of the golden layout.
+
+Run: pytest tests/test_mirror_layout.py -q --noconftest
+"""
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from demoprep_app.liveboards.mirror_layout import (
+    apply_mirror_layout, match_tiles, retype_for_mirror, _zone_to_grid,
+)
+
+
+def _viz(viz_id, name, chart_type, query, columns):
+    return {
+        "id": viz_id,
+        "answer": {
+            "name": name,
+            "search_query": query,
+            "display_mode": "CHART_MODE",
+            "answer_columns": [{"name": c} for c in columns],
+            "chart": {"type": chart_type, "axis_configs": [{"x": [columns[-1]], "y": [columns[0]]}]},
+        },
+    }
+
+
+def _tile(title, chart_type, measures, dims=(), date=None, sheet=None, grain="monthly"):
+    return {"question": "q", "source": "mirror", "sheet": sheet or title, "title": title,
+            "chart_type": chart_type, "fidelity": "exact", "notes": [],
+            "measures": list(measures), "dimensions": list(dims), "date": date, "grain": grain}
+
+
+COMBO_TILE = _tile("Sales vs Target", "ADVANCED_LINE_COLUMN", ["Sales", "Target"], date="Order Date", sheet="Sheet 1")
+KPI_TILE = _tile("Total Sales", "KPI", ["Sales"], date="Order Date", sheet="Sheet 2")
+BAR_TILE = _tile("Sales by Region", "BAR", ["Sales"], dims=["Region"], sheet="Sheet 3")
+TABLE_TILE = _tile("Order Detail", "TABLE", ["Sales", "Profit"], dims=["Customer Name"], sheet="Sheet 4")
+
+
+def _board():
+    return {"liveboard": {"name": "Acme - Sales", "visualizations": [
+        _viz("Viz_1", "Total sales and total target by order date monthly", "LINE",
+             "[Sales] [Target] [Order Date].monthly", ["Total Sales", "Total Target", "Order Date"]),
+        _viz("Viz_2", "Total sales monthly", "LINE", "[Sales] [Order Date].monthly", ["Total Sales", "Order Date"]),
+        _viz("Viz_3", "Total sales by region", "COLUMN", "[Sales] [Region]", ["Total Sales", "Region"]),
+        _viz("Viz_4", "Sales and profit by customer name", "COLUMN", "[Sales] [Profit] [Customer Name]",
+             ["Total Sales", "Total Profit", "Customer Name"]),
+        {"id": "Viz_9", "note_tile": {"text": "scaffolding"}},
+    ]}}
+
+
+def test_tiles_match_answers_in_order_and_by_words():
+    vizs = [v for v in _board()["liveboard"]["visualizations"] if "note_tile" not in v]
+    mapping = match_tiles(vizs, [COMBO_TILE, KPI_TILE, BAR_TILE, TABLE_TILE])
+    assert mapping["Viz_1"] is COMBO_TILE
+    assert mapping["Viz_3"] is BAR_TILE
+    assert mapping["Viz_4"] is TABLE_TILE
+    # Out of order: the answers came back shuffled, words still find the tile.
+    shuffled = [vizs[2], vizs[0], vizs[3], vizs[1]]
+    mapping = match_tiles(shuffled, [COMBO_TILE, KPI_TILE, BAR_TILE, TABLE_TILE])
+    assert mapping["Viz_3"] is BAR_TILE and mapping["Viz_1"] is COMBO_TILE
+
+
+def test_retype_sets_source_types_titles_and_combo_config():
+    board = _board()
+    changes, mapping = retype_for_mirror(board["liveboard"]["visualizations"], [COMBO_TILE, KPI_TILE, BAR_TILE, TABLE_TILE])
+    by_id = {v["id"]: v for v in board["liveboard"]["visualizations"]}
+    combo = by_id["Viz_1"]["answer"]
+    assert combo["name"] == "Sales vs Target"
+    assert combo["chart"]["type"] == "ADVANCED_LINE_COLUMN"
+    assert "axis_configs" not in combo["chart"]
+    keys = {d["key"] for block in combo["chart"]["custom_chart_config"] for d in block["dimensions"]}
+    assert {"x-axis", "y-axis-column", "y-axis-line"} <= keys
+    cols = {d["key"]: d for block in combo["chart"]["custom_chart_config"] for d in block["dimensions"]}
+    assert cols["y-axis-column"]["axes"][0]["columns"] == ["Total Sales"]
+    assert cols["y-axis-line"]["axes"][0]["columns"] == ["Total Target"]
+    assert cols["x-axis"]["axes"][0]["column"] == "Order Date"
+    state = json.loads(combo["chart"]["client_state_v2"])
+    assert state["axisProperties"][0]["properties"]["linkedColumns"] == ["Total Sales", "Total Target"]
+
+    assert by_id["Viz_2"]["answer"]["chart"]["type"] == "KPI"
+    bar = by_id["Viz_3"]["answer"]
+    assert bar["chart"]["type"] == "BAR"
+    assert bar["chart"]["axis_configs"] == [{"x": ["Region"], "y": ["Total Sales"]}]
+    table = by_id["Viz_4"]["answer"]
+    assert table["display_mode"] == "TABLE_MODE" and "chart" not in table
+    assert any("matched 4 of 4" in c for c in changes)
+    assert any("set 4 chart type" in c for c in changes)
+    assert len(mapping) == 4
+
+
+def test_combo_keeps_every_measure_when_names_overlap():
+    """Live board fd753f8e (2026-10-29): "Target" matched "Total Sales V Target"
+    first and the target line vanished from the combo chart."""
+    board = {"liveboard": {"visualizations": [
+        _viz("Viz_1", "total sales and total sales v target and total target by order date monthly",
+             "LINE", "sum [Sales] sum [Sales V Target] sum [Target] [Order Date].monthly",
+             ["Total Sales", "Total Sales V Target", "Total Target", "Month(Order Date)"]),
+    ]}}
+    tile = _tile("Sheet 1", "ADVANCED_LINE_COLUMN", ["Sales", "Sales V Target", "Target"], date="Order Date", sheet="Sheet 1")
+    retype_for_mirror(board["liveboard"]["visualizations"], [tile])
+    chart = board["liveboard"]["visualizations"][0]["answer"]["chart"]
+    cols = {d["key"]: d for block in chart["custom_chart_config"] for d in block["dimensions"]}
+    assert cols["y-axis-column"]["axes"][0]["columns"] == ["Total Sales"]
+    assert cols["y-axis-line"]["axes"][0]["columns"] == ["Total Sales V Target", "Total Target"]
+    assert cols["x-axis"]["axes"][0]["column"] == "Month(Order Date)"
+
+
+def test_duplicate_source_titles_stay_distinct():
+    board = {"liveboard": {"visualizations": [
+        _viz("Viz_1", "a", "LINE", "[Sales] [Order Date].monthly", ["Total Sales", "Order Date"]),
+        _viz("Viz_2", "b", "LINE", "[Sales] [Ship Date].monthly", ["Total Sales", "Ship Date"]),
+    ]}}
+    tiles = [_tile("Trend", "LINE", ["Sales"], date="Order Date", sheet="s1"),
+             _tile("Trend", "LINE", ["Sales"], date="Ship Date", sheet="s2")]
+    retype_for_mirror(board["liveboard"]["visualizations"], tiles)
+    names = [v["answer"]["name"] for v in board["liveboard"]["visualizations"]]
+    assert names == ["Trend", "Trend (2)"]
+
+
+def test_grid_layout_when_the_source_had_no_dashboard():
+    board = _board()
+    tiles = [COMBO_TILE, KPI_TILE, BAR_TILE, TABLE_TILE]
+    _, mapping = retype_for_mirror(board["liveboard"]["visualizations"], tiles)
+    mirror = {"name": "Sheet 1", "source_kind": "tableau_twb", "dashboards": []}
+    out, changes = apply_mirror_layout(board, mirror, tiles, mapping)
+    lb = out["liveboard"]
+    assert all("note_tile" not in v for v in lb["visualizations"]), "note tiles are dropped"
+    assert "groups" not in lb
+    tabs = lb["layout"]["tabs"]
+    assert len(tabs) == 1 and tabs[0]["name"] == "Sheet 1"
+    tiles_out = {t["visualization_id"]: t for t in tabs[0]["tiles"]}
+    assert set(tiles_out) == {"Viz_1", "Viz_2", "Viz_3", "Viz_4"}
+    assert tiles_out["Viz_2"]["y"] == 0, "the KPI leads"
+    assert tiles_out["Viz_4"]["width"] == 12, "a table spans the row"
+    assert all(t["x"] + t["width"] <= 12 for t in tiles_out.values())
+    assert "grid" in changes[0]
+
+
+def test_zone_layout_follows_the_source_dashboard():
+    board = _board()
+    tiles = [COMBO_TILE, KPI_TILE, BAR_TILE, TABLE_TILE]
+    _, mapping = retype_for_mirror(board["liveboard"]["visualizations"], tiles)
+    mirror = {"name": "Sales Overview", "source_kind": "tableau_twb", "mirrored_dashboard": "Sales Overview",
+              "dashboards": [{"name": "Sales Overview", "width": 1200, "height": 800, "zones": [
+                  {"sheet": "Sheet 2", "x": 0.0, "y": 0.0, "w": 0.25, "h": 0.2, "kind": "sheet"},
+                  {"sheet": "Sheet 1", "x": 0.25, "y": 0.0, "w": 0.75, "h": 0.5, "kind": "sheet"},
+                  {"sheet": "Sheet 3", "x": 0.0, "y": 0.5, "w": 0.5, "h": 0.5, "kind": "sheet"},
+                  {"sheet": "Sheet 4", "x": 0.5, "y": 0.5, "w": 0.5, "h": 0.5, "kind": "sheet"},
+                  {"sheet": "", "x": 0, "y": 0, "w": 1, "h": 0.05, "kind": "text"},
+              ]}]}
+    out, changes = apply_mirror_layout(board, mirror, tiles, mapping)
+    tab = out["liveboard"]["layout"]["tabs"][0]
+    assert tab["name"] == "Sales Overview"
+    t = {x["visualization_id"]: x for x in tab["tiles"]}
+    assert t["Viz_2"]["x"] == 0 and t["Viz_2"]["width"] == 3
+    assert t["Viz_1"]["x"] == 3 and t["Viz_1"]["width"] == 9
+    assert t["Viz_3"]["x"] == 0 and t["Viz_4"]["x"] == 6
+    assert t["Viz_3"]["y"] == t["Viz_4"]["y"] > t["Viz_1"]["y"]
+    # No two tiles overlap.
+    placed = list(t.values())
+    for a in placed:
+        for b in placed:
+            if a is b:
+                continue
+            assert (a["x"] + a["width"] <= b["x"] or b["x"] + b["width"] <= a["x"]
+                    or a["y"] + a["height"] <= b["y"] or b["y"] + b["height"] <= a["y"])
+    assert "source dashboard zones" in changes[0]
+
+
+def test_zone_to_grid_respects_the_grid_and_minimums():
+    g = _zone_to_grid({"x": 0.9, "y": 0.0, "w": 0.3, "h": 0.01}, (1000, 500))
+    assert g["x"] + g["w"] <= 12 and g["w"] >= 2 and g["h"] >= 3
+
+
+def test_enhance_in_mirror_mode_keeps_titles_and_skips_the_golden_passes(monkeypatch):
+    """End to end through enhance_mcp_liveboard with a fake cluster: no groups,
+    no title rewrite, source chart types, one tab named after the dashboard."""
+    import yaml
+    import liveboard_creator as lc
+
+    board = _board()
+    raw = yaml.safe_dump({"guid": "lb-1", **board})
+    imported = {}
+
+    class _Resp:
+        def __init__(self, payload):
+            self.status_code = 200
+            self._payload = payload
+
+        def json(self):
+            return self._payload
+
+    class _Session:
+        def post(self, url, **kwargs):
+            if "tml/export" in url:
+                return _Resp([{"edoc": raw}])
+            imported["body"] = kwargs.get("json")
+            return _Resp([{"response": {"status": {"status_code": "OK"}}}])
+
+    class _Client:
+        base_url = "https://example"
+        session = _Session()
+
+    monkeypatch.setattr(lc, "fetch_search_column_map", lambda *a, **k: None)
+    monkeypatch.setattr(lc, "_fetch_model_columns", lambda *a, **k: [])
+    monkeypatch.setattr(lc, "_humanize_viz_titles",
+                        lambda **k: pytest.fail("mirror mode must not rewrite the source titles"))
+    captured = {}
+
+    def _import(ts_client, tml):
+        captured["tml"] = tml
+        return {"success": True, "dropped": []}
+    monkeypatch.setattr(lc, "import_liveboard_tml_with_recovery", _import)
+
+    tiles = [COMBO_TILE, KPI_TILE, BAR_TILE, TABLE_TILE]
+    mirror = {"name": "Sales Overview", "source_kind": "tableau_twb", "dashboards": [], "tiles": tiles}
+    result = lc.enhance_mcp_liveboard(
+        liveboard_guid="lb-1", company_data={"name": "Acme", "use_case": "Sales"},
+        ts_client=_Client(), layout_strategy="mirror", mirror=mirror, llm_model=None,
+    )
+    assert result.get("success"), result
+    tml = captured["tml"]["liveboard"]
+    names = [v["answer"]["name"] for v in tml["visualizations"]]
+    assert names == ["Sales vs Target", "Total Sales", "Sales by Region", "Order Detail"]
+    assert "groups" not in tml or not tml["groups"]
+    assert tml["layout"]["tabs"][0]["name"] == "Sales Overview"
+    types = [v["answer"].get("chart", {}).get("type") for v in tml["visualizations"]]
+    assert types[:3] == ["ADVANCED_LINE_COLUMN", "KPI", "BAR"]
+    assert tml["visualizations"][3]["answer"]["display_mode"] == "TABLE_MODE"
+    assert any(e.startswith("Mirror") for e in result["enhancements"])

tests/test_payload_capture_is_complete.py

@@ -39,7 +39,8 @@ def test_capture_includes_every_parameter_of_the_tool():
                environment="", schema_style="simple", apply_brand_theme=False,
                brand_theme=None, custom_mcp_demo=False,
                logo_tile=False, insight_tile=False, homepage_screenshot="",
-               settings=None):  # settings document, 2026-10-22
+               settings=None,  # settings document, 2026-10-22
+               source_dashboard="", source_dashboard_image=""):  # DP Migrator, 2026-10-28
         return M._call_payload(inspect.currentframe())
 
     got = set(sample())

tests/test_payload_reaches_the_database.py

@@ -126,7 +126,8 @@ def test_tool_signature_survives_the_entire_path():
                environment="", schema_style="simple", apply_brand_theme=False,
                brand_theme=None, custom_mcp_demo=False,
                logo_tile=False, insight_tile=False, homepage_screenshot="",
-               settings=None):  # settings document, 2026-10-22
+               settings=None,  # settings document, 2026-10-22
+               source_dashboard="", source_dashboard_image=""):  # DP Migrator, 2026-10-28
         return M._call_payload(inspect.currentframe())
 
     results = captured_row(sample())

thoughtspot_deployer.py

@@ -3065,7 +3065,7 @@ class ThoughtSpotDeployer:
                   company_research: str = None, additional_context: str = None,
                   vertical: str = None, line: str = None, function: str = None,
                   progress_callback=None, session_logger=None,
-                  brand_theme: Dict = None) -> Dict:
+                  brand_theme: Dict = None, mirror: Dict = None) -> Dict:
         """
         Deploy complete data model to ThoughtSpot
         
@@ -3077,6 +3077,10 @@ class ThoughtSpotDeployer:
             brand_theme: A resolved brand theme (BrandTheme.to_dict(), ISS-19) to
                 colour the liveboard in. None — every App/Chat build, and any MCP
                 build that did not ask — leaves the board in the default palette.
+            mirror: DP Migrator (boone 2026-10-28): the prospect's dashboard as a
+                MirrorSpec dict (demoprep_app.migration.spec). The liveboard then
+                asks one question per source sheet and is laid out like the
+                source (layout_strategy "mirror"). None = the golden board.
         
         Returns:
             Dict with deployment results and names of created objects
@@ -4371,6 +4375,35 @@ class ThoughtSpotDeployer:
                                 company_data['brand_theme'] = brand_theme
                             model_columns = liveboard_context['model_columns']
                             matrix_config = liveboard_context['matrix_config']
+
+                            # Mirror mode (DP Migrator): the liveboard copies the prospect's
+                            # dashboard, so its questions come from the source sheets, phrased
+                            # with THIS model's column names, not from the LLM. A sheet whose
+                            # measures the model lacks is dropped by name, never silently.
+                            mirror_tiles: List[Dict] = []
+                            if mirror:
+                                from demoprep_app.migration.questions import questions_from_spec
+                                from demoprep_app.migration.spec import MirrorSpec
+                                mirror_tiles, _mirror_dropped, _mirror_warnings = questions_from_spec(
+                                    MirrorSpec.from_dict(mirror), model_columns)
+                                for _w in _mirror_warnings:
+                                    results['warnings'].append(f"mirror: {_w}")
+                                    log_progress(f"   [WARN] mirror: {_w}")
+                                results['mirror'] = {
+                                    'tiles': [{'title': t['title'], 'chart_type': t['chart_type'],
+                                               'question': t['question'], 'fidelity': t['fidelity'],
+                                               'notes': t['notes']} for t in mirror_tiles],
+                                    'dropped': list(_mirror_dropped),
+                                }
+                                if mirror_tiles:
+                                    log_progress(f"   [mirror] {len(mirror_tiles)} question(s) from the source dashboard")
+                                else:
+                                    _w = "mirror: none of the source sheets can be asked of this model; building the standard board"
+                                    results['warnings'].append(_w)
+                                    log_progress(f"   [WARN] {_w}")
+                                if _slog:
+                                    _slog.log("thoughtspot", "mirror questions", count=len(mirror_tiles),
+                                              dropped=list(_mirror_dropped), warnings=list(_mirror_warnings))
                             # Surface gate/context warnings in the build result, not just the log.
                             results['warnings'].extend(liveboard_context.get('warnings') or [])
 
@@ -4441,7 +4474,10 @@ class ThoughtSpotDeployer:
                                         model_name=model_name,
                                         company_data=company_data,
                                         use_case=use_case or 'General Analytics',
-                                        num_visualizations=16,  # boone 2026-09-10/16: 4 KPIs + 5-6 exec + 3-4 manager + showcase (16 since the variety push routes 1-in-4 to showcase)
+                                        # boone 2026-09-10/16: 4 KPIs + 5-6 exec + 3-4 manager + showcase (16 since
+                                        # the variety push routes 1-in-4 to showcase). Mirror: one per source sheet.
+                                        num_visualizations=len(mirror_tiles) if mirror_tiles else 16,
+                                        explicit_questions=mirror_tiles or None,
                                         liveboard_name=liveboard_name,
                                         matrix_config=matrix_config,
                                         llm_model=llm_model,
@@ -4604,8 +4640,9 @@ class ThoughtSpotDeployer:
                                     fix_kpis=True,
                                     apply_brand_colors=True,
                                     llm_model=llm_model,
-                                    layout_strategy="golden_two_tab",
+                                    layout_strategy="mirror" if mirror_tiles else "golden_two_tab",
                                     model_id=model_guid,
+                                    mirror={**mirror, 'tiles': mirror_tiles} if mirror_tiles else None,
                                 )
                                 # Tiles ThoughtSpot rejected were dropped so the rest of
                                 # the enhancements could land. That gap is REPORTED, never