databricks-tellr-app 0.4.2.dev13__tar.gz → 0.4.2.dev15__tar.gz

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks-tellr-app
-Version: 0.4.2.dev13
+Version: 0.4.2.dev15
 Summary: Tellr application package for Databricks Apps
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -33,6 +33,7 @@ Requires-Dist: pandas==2.3.3
 Requires-Dist: python-pptx==0.6.23
 Requires-Dist: playwright==1.48.0
 Requires-Dist: Pillow==11.3.0
+Requires-Dist: svgpathtools>=1.6.0
 Requires-Dist: google-api-python-client==2.190.0
 Requires-Dist: google-auth-oauthlib==1.2.4
 Requires-Dist: google-auth-httplib2==0.3.0

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev15}/databricks_tellr_app.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks-tellr-app
-Version: 0.4.2.dev13
+Version: 0.4.2.dev15
 Summary: Tellr application package for Databricks Apps
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -33,6 +33,7 @@ Requires-Dist: pandas==2.3.3
 Requires-Dist: python-pptx==0.6.23
 Requires-Dist: playwright==1.48.0
 Requires-Dist: Pillow==11.3.0
+Requires-Dist: svgpathtools>=1.6.0
 Requires-Dist: google-api-python-client==2.190.0
 Requires-Dist: google-auth-oauthlib==1.2.4
 Requires-Dist: google-auth-httplib2==0.3.0

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev15}/databricks_tellr_app.egg-info/requires.txt

@@ -27,6 +27,7 @@ pandas==2.3.3
 python-pptx==0.6.23
 playwright==1.48.0
 Pillow==11.3.0
+svgpathtools>=1.6.0
 google-api-python-client==2.190.0
 google-auth-oauthlib==1.2.4
 google-auth-httplib2==0.3.0

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "databricks-tellr-app"
-version = "0.4.2.dev13"
+version = "0.4.2.dev15"
 description = "Tellr application package for Databricks Apps"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -38,6 +38,19 @@ dependencies = [
     "python-pptx==0.6.23",
     "playwright==1.48.0",
     "Pillow==11.3.0",
+    # WF-02: imported by BOTH Python emitters (html_to_pptx, html_to_google_slides)
+    # and declared in the root manifest, but never here — so on every deployment the
+    # lazy `from svgpathtools import parse_path` failed and image extraction became a
+    # silent no-op, letting base64 survive into the prompt.
+    #
+    # Ranged, matching the root declaration, rather than exact-pinned like the
+    # resolver-speedup block below. MEASURED before shipping, because a new
+    # dependency here is what has previously blown the Apps build budget: adding it
+    # takes the resolution from 196 to 198 packages in 15.7s vs 18.5s baseline — no
+    # backtracking, and FASTER, not slower. Its numpy and scipy requirements are
+    # already in the closure (via mlflow / scikit-learn / skops / pandas), so the only
+    # new distributions are svgpathtools itself and the tiny pure-Python svgwrite.
+    "svgpathtools>=1.6.0",
     "google-api-python-client==2.190.0",
     "google-auth-oauthlib==1.2.4",
     "google-auth-httplib2==0.3.0",

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev15}/src/api/mcp_server.py

@@ -649,7 +649,10 @@ def _render_deck_response(
         "Poll the status of a deck generation or edit job. Returns "
         "lightweight status while pending/running; when ready, returns the "
         "complete deck as structured slide data, a standalone HTML "
-        "document, and URLs into tellr's full editor and view-only surfaces."
+        "document, and URLs into tellr's full editor and view-only surfaces. "
+        "A ready turn is not always an applied change: when "
+        "metadata.clarification_needed is true the deck was left UNCHANGED and "
+        "metadata.clarification carries the question to answer before retrying."
     ),
 )
 async def get_deck_status(
@@ -795,6 +798,34 @@ async def _get_deck_status_impl(
                 for m in db_messages
             ]
 
+            # WG2-01. An edit instruction that names no slide is DELIBERATELY not
+            # applied: chat_service asks which slide instead (its RC10 twins, plus the
+            # ambiguous add-vs-replace pair) and attaches ``clarification_needed`` to
+            # the COMPLETE event, which ``job_queue.process_chat_request`` copies
+            # verbatim into ``result["metadata"]``.
+            #
+            # Such a turn completes normally, so "ready" is the honest status and
+            # ``replacement_info`` is None — which is indistinguishable from an edit
+            # that applied but replaced nothing. Rebuilding ``metadata`` from
+            # hand-picked keys DROPPED the flag, so an automated caller reading
+            # ``status`` concluded the edit had landed when the deck was untouched; the
+            # only remaining trace was a ``message_type == "clarification"`` row in the
+            # transcript. Surfaced ADDITIVELY, and ``status`` keeps its existing meaning
+            # for clients already reading it.
+            clarification_needed = bool(result_metadata.get("clarification_needed"))
+            clarification = None
+            if clarification_needed:
+                # The question itself, so a caller can act on it without re-filtering
+                # the transcript. Last one wins: it is the turn's most recent ask.
+                clarification = next(
+                    (
+                        message.get("content")
+                        for message in reversed(messages)
+                        if message.get("message_type") == "clarification"
+                    ),
+                    None,
+                )
+
             return {
                 "session_id": session_id,
                 "request_id": request_id,
@@ -808,6 +839,8 @@ async def _get_deck_status_impl(
                     or result_metadata.get("latency_seconds"),
                     "experiment_url": result.get("experiment_url"),
                     "session_title": result.get("session_title"),
+                    "clarification_needed": clarification_needed,
+                    "clarification": clarification,
                 },
             }
     except MCPToolError:
@@ -851,7 +884,11 @@ def _check_contiguous(indices: list[int]) -> None:
         "The edit is applied in-place; the session_id and deck_url stay "
         "stable across edits. Returns a request_id; the caller polls "
         "get_deck_status for completion and receives the updated deck "
-        "plus replacement_info summarizing what changed."
+        "plus replacement_info summarizing what changed. An instruction that "
+        "identifies no slide — neither via slide_indices nor by naming one in "
+        "the text — is answered with a clarifying question INSTEAD of an edit: "
+        "get_deck_status then reports metadata.clarification_needed with the "
+        "deck unchanged."
     ),
 )
 async def edit_deck(

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev15}/src/api/routes/export.py

@@ -1,6 +1,7 @@
 """Export endpoints for PDF and PPTX generation."""
 
 import logging
+import re
 import tempfile
 from pathlib import Path
 from typing import Optional
@@ -41,6 +42,33 @@ class ExportPPTXRequest(BaseModel):
     chart_images: Optional[list[list[ChartImage]]] = None  # Chart images per slide (client-side captured)
 
 
+# WF-03. `@import` is only valid before every other rule of ITS OWN STYLESHEET, and this
+# document used to inject `*{}` and `html,body{}` ahead of the deck's CSS in a SINGLE
+# `<style>` — so a deck whose CSS OPENS with a webfont `@import` had that rule silently
+# discarded. Measured: 0 font faces in the export against 35 in the UI, which was the whole
+# of the long-unexplained 38.25 px per-component residual on the DS-OFF deck.
+#
+# The fix is STRUCTURAL, and it is the reason there is no CSS parsing here. Two `<style>`
+# elements are two stylesheets, so the deck gets its OWN `<style>`: its leading `@import` is
+# then already first in its own sheet and valid with NO rewriting at all. Cascade order
+# between separate `<style>` elements is document order, so resets-then-deck-then-resets
+# keeps exactly the precedence the single combined sheet had.
+#
+# MEASURED IN CHROMIUM under the real SLIDE_CSP: combined -> 1 sheet, 0 font faces, import
+# dead; split -> 2 sheets, font faces registered, import applied; and with a reset and the
+# deck setting the same property at equal specificity, the DECK still wins on order.
+#
+# This REPLACES a hand-written leading-`@charset`/`@import` scanner that lived here. Three
+# rounds of review found four tokenizer defects in it (`str.isspace()` accepting NBSP, an
+# unescaped top-level `\)`, a lone `@charset` rewriting the document, an ASCII-only ident
+# guard) and then a fifth (`@layer name;` may legally precede `@import`, which it missed,
+# re-losing the font for ordinary modern CSS). Every one of those was a bug in DECIDING what
+# the deck's CSS means. Emitting the deck's CSS VERBATIM in its own sheet removes the need to
+# decide, so that entire class of defect is now unreachable rather than patched: NUL bytes,
+# top-level `<!--`, a lone CR inside a string, escaped at-keywords and `@layer` are all
+# simply the browser's business, exactly as they are in the deck's own stylesheet.
+
+
 def build_slide_html(slide: dict, slide_deck: dict) -> str:
     """Build complete HTML for a single slide.
     
@@ -56,12 +84,11 @@ def build_slide_html(slide: dict, slide_deck: dict) -> str:
     external_scripts = slide_deck.get("external_scripts", [])
     deck_css = slide_deck.get("css", "")
     deck_scripts = slide_deck.get("scripts", "")
-    
+
     # Clean up deck_scripts: remove any trailing extra IIFE closings
     # deck_scripts should be a series of (function() { ... })(); blocks
     # but sometimes there might be an extra })(); at the end
     if deck_scripts:
-        import re
         # Remove any trailing })(); that might be extra
         deck_scripts = deck_scripts.rstrip()
         # Count opening and closing IIFEs
@@ -102,8 +129,22 @@ def build_slide_html(slide: dict, slide_deck: dict) -> str:
         }
     )
     
+    # NO `crossorigin` — deliberately, and it must stay that way (WM-02).
+    #
+    # `crossorigin="anonymous"` turns these into CORS requests. cdn.tailwindcss.com
+    # answers with a 302 and no CORS headers, so the request failed with
+    # net::ERR_FAILED and Tailwind's Preflight never landed — measured consequence
+    # on a DS-OFF deck: h3 rendered 22px/600 in the exported file against
+    # 16px/400 on screen, up to 38.25 px of per-component drift and a heading
+    # losing a line to re-wrap. The frontend surfaces emit the same tag WITHOUT the
+    # attribute (see buildSlideDocument in frontend/src/services/slideDocument.ts)
+    # and it loads, so dropping it is parity with what the user actually saw.
+    #
+    # Safe to drop on its own because there is NO `integrity` attribute here: with
+    # SRI present, removing `crossorigin` would block the script outright and turn
+    # a 38 px drift into no styling at all.
     scripts_html = "\n".join([
-        f'    <script src="{src}" crossorigin="anonymous"></script>'
+        f'    <script src="{src}"></script>'
         for src in external_scripts
     ])
 
@@ -147,7 +188,33 @@ def build_slide_html(slide: dict, slide_deck: dict) -> str:
       background: #ffffff;
       font-family: 'Inter', 'Segoe UI', system-ui, -apple-system, sans-serif;
     }}
-    {deck_css}
+  </style>
+  <style>{deck_css}</style>
+  <style>
+    /* After deck CSS: the fixed-frame document owns its OWN box (WM-01).
+       The html/body rule above is emitted BEFORE the deck, so a deck-authored
+       `body {{ padding: 48px 0; gap: 48px }}` — real generator output — used to win
+       on order and translate the WHOLE slide down: `.slide` measured at y=48, and
+       the .pptx carried that offset on every positioned component (dy 46-48 px)
+       including the background rectangle, whose bottom then sat at 768 inside a
+       720 frame. So: a 48 px unpainted band at the top of every exported slide and
+       48 px of content pushed past the clip.
+       Restated HERE, after the deck, exactly as the frontend preview surfaces
+       already do it (SLIDE_PREVIEW_RESET_STYLE is appended after the deck CSS in
+       buildSlideDocument), so the export agrees with what the user saw on screen.
+       Deliberately NOT added to the shared SLIDE_ROOT_RESET_STYLE: that constant is
+       also injected into the standalone MULTI-slide export, whose scrolling layout
+       depends on `body {{ padding: 40px 20px }}`.
+       No `!important`, matching the frontend rule: it wins by ORDER at equal
+       specificity, so both surfaces treat a deck's `!important` body padding the
+       same way and cannot drift apart. That ORDER now spans separate `<style>`
+       elements — the deck has a stylesheet of its own so its leading `@import`
+       stays valid (WF-03) — and the cascade orders separate sheets by DOCUMENT
+       ORDER, so this later sheet still wins exactly as it did inside one block. */
+    html, body {{
+      margin: 0;
+      padding: 0;
+    }}
     /* After deck CSS: flatten the slide root (outer margin / radius / shadow) —
        inside this fixed 1280x720 overflow:hidden document a root margin
        shifts content past the clip and truncates the export's bottom edge

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev15}/src/api/routes/settings/design_systems.py

@@ -25,6 +25,7 @@ import re
 import unicodedata
 from collections import OrderedDict
 from typing import Any, List, Optional, cast
+from urllib.parse import unquote
 
 from fastapi import APIRouter, Depends, File, Form, HTTPException, Response, UploadFile, status
 from pydantic import BaseModel, Field
@@ -833,6 +834,60 @@ def set_default_design_system(ds_id: int, db: Session = Depends(get_db)):
         )
 
 
+# SDR-4437 HIGH-3: workspace-global library writes are admin-only. REMOVING the
+# org default is the same org-wide state change as setting it, so it carries the
+# same gate — authorship must not buy it.
+@router.post(
+    "/{ds_id}/clear-default", response_model=DesignSystemDetail,
+    dependencies=[Depends(require_admin)],
+)
+def clear_default_design_system(ds_id: int, db: Session = Depends(get_db)):
+    """Remove the org-wide default, returning the library to "no default".
+
+    The lifecycle used to be ASYMMETRIC: ``set-default`` could promote a system and
+    switch between systems, but nothing could withdraw the flag — so returning to
+    no-default meant DELETING the design system or promoting a different one, and
+    the legacy slide-style fallback was unreachable in practice. Generation then
+    resolves no design system (``get_default_design_system_id`` returns None) and
+    new sessions take the legacy path.
+
+    Idempotent: clearing a system that is not the default succeeds and changes
+    nothing, so a double-click cannot produce an error to interpret.
+
+    Deliberately asymmetric with ``set-default``, which refuses an INACTIVE row:
+    promoting a tombstone into org-wide state is wrong, but REMOVING org-wide state
+    is always the safe direction and must never be blocked — refusing it would
+    strand the flag with no way to withdraw it.
+
+    Clearing correctly UNFREEZES rename/delete for the row's author: the freeze in
+    :func:`_require_creator_or_admin` is a function of the LOADED row's
+    ``is_default``, so it lifts when the flag does. That grants a non-admin nothing
+    new, because this route is itself admin-only.
+    """
+    try:
+        ds = db.query(DesignSystem).filter(DesignSystem.id == ds_id).first()
+        if not ds:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Design system {ds_id} not found",
+            )
+        if ds.is_default:
+            ds.is_default = False
+            db.commit()
+            db.refresh(ds)
+            logger.info(f"Cleared default design system: {ds.name} (id={ds.id})")
+        return _detail(ds)
+    except HTTPException:
+        raise
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Error clearing default design system {ds_id}: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to clear default design system",
+        )
+
+
 def _template_thumbnail_url(ds_id: int, template_id: int) -> str:
     return f"/api/settings/design-systems/{ds_id}/templates/{template_id}/thumbnail"
 
@@ -1180,6 +1235,35 @@ _TEXT_SOURCE_MIMES = frozenset(
 # pass — only ever seen in double-encoding smuggling attempts, so reject outright.
 _ENCODED_TRAVERSAL_RE = re.compile(r"%(2e|2f|5c)", re.IGNORECASE)
 
+# How many decode passes a value may need before it stops changing. A value still
+# mutating after this many is pathological, never a real bundle path, and is
+# refused rather than normalized (see :func:`_validated_file_path`).
+_MAX_DECODE_PASSES = 4
+
+
+def _has_canonical_shape(value: str) -> bool:
+    """True when ``value`` has the shape of a canonical bundle-relative path.
+
+    The SHAPE half of :func:`_validated_file_path`, factored out so the exact same
+    rules can be re-applied to each decoded form of a request path — one source of
+    truth, rather than a second, weaker copy of the checks.
+    """
+    if not value or "\\" in value:
+        return False
+    # NUL / C0 control characters never appear in a legitimate stored path, and
+    # NUL in particular must be rejected BEFORE the DB lookup: psycopg2 refuses
+    # NUL in a bound parameter (ValueError), which would surface as a 500
+    # instead of the uniform opaque 404 (SQLite masks this as a no-match 404).
+    if any(ord(ch) < 0x20 for ch in value):
+        return False
+    if _ENCODED_TRAVERSAL_RE.search(value):
+        return False
+    if value.startswith("/") or re.match(r"^[A-Za-z]:", value):
+        return False
+    if any(segment in ("", ".", "..") for segment in value.split("/")):
+        return False
+    return True
+
 
 def _validated_file_path(raw: str) -> Optional[str]:
     """Return ``raw`` when it is a canonical bundle-relative path, else ``None``.
@@ -1190,22 +1274,32 @@ def _validated_file_path(raw: str) -> Optional[str]:
     backslashes, absolute/drive paths, empty/``.``/``..`` segments, and lingering
     percent-encoded traversal bytes all fail. Lookups are DB-exact within one
     design system (no filesystem involved), so this is defence-in-depth.
+
+    MULTIPLY-ENCODED forms are refused too. ``_ENCODED_TRAVERSAL_RE`` matches a
+    lingering ``%2e``/``%2f``/``%5c``, but in ``%252e`` the traversal is hidden
+    behind its own encoded ``%``, so ONE pass of that check cannot see it. The
+    value is therefore decoded repeatedly and every intermediate form must satisfy
+    the same shape rules; a value that keeps decoding into a traversal is refused
+    at any depth.
+
+    The refusal keys on TRAVERSAL, never on the ``%`` character: a literal ``%``
+    is legitimate in a brand's own filename, and an escape that decodes to
+    something harmless (``%41`` -> ``A``) stays accepted. Rejecting ``%`` outright
+    would turn a brand's real file into a 404 — the same class of brand-hostile
+    limit the uncapped-text columns exist to avoid.
     """
-    if not raw or "\\" in raw:
-        return None
-    # NUL / C0 control characters never appear in a legitimate stored path, and
-    # NUL in particular must be rejected BEFORE the DB lookup: psycopg2 refuses
-    # NUL in a bound parameter (ValueError), which would surface as a 500
-    # instead of the uniform opaque 404 (SQLite masks this as a no-match 404).
-    if any(ord(ch) < 0x20 for ch in raw):
-        return None
-    if _ENCODED_TRAVERSAL_RE.search(raw):
-        return None
-    if raw.startswith("/") or re.match(r"^[A-Za-z]:", raw):
-        return None
-    if any(segment in ("", ".", "..") for segment in raw.split("/")):
+    if not _has_canonical_shape(raw):
         return None
-    return raw
+    candidate = raw
+    for _ in range(_MAX_DECODE_PASSES):
+        decoded = unquote(candidate)
+        if decoded == candidate:
+            return raw
+        if not _has_canonical_shape(decoded):
+            return None
+        candidate = decoded
+    # Still changing after _MAX_DECODE_PASSES: refuse rather than keep unwrapping.
+    return None
 
 
 def _is_text_source(path: str, mime: str) -> bool:

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev15}/src/services/agent_factory.py

@@ -312,6 +312,44 @@ def _get_prompt_content(
     }
 
 
+def _design_system_is_active(design_system_id: int) -> bool:
+    """True when that design system exists and is ACTIVE.
+
+    The tool gate below needs the same verdict the prompt branch reaches at
+    :func:`_get_prompt_content` (``.filter_by(id=…, is_active=True)``, else
+    *"Design system not found, using default"*), so both halves of a generation
+    request agree about whether a design system is in play.
+
+    NOT the same question as ``chat_service.resolve_active_design_system_id``,
+    despite the name: that resolves the ``{{ds-asset:ID}}`` scope for a deck
+    RESPONSE and deliberately still resolves a soft-deleted system's bytes, so
+    already-generated decks keep their fonts and images (the D7 retention
+    contract). This is the AUTHORING question — may new content be made against
+    this brand — and a tombstone answers no.
+
+    Fails CLOSED. A lookup error degrades exactly the way the prompt branch does
+    (no brand material) rather than advertising a tool whose own lookup would fail
+    in the same breath.
+    """
+    try:
+        from src.core.database import get_db_session
+        from src.database.models import DesignSystem
+
+        with get_db_session() as db:
+            return (
+                db.query(DesignSystem.id)
+                .filter_by(id=design_system_id, is_active=True)
+                .first()
+                is not None
+            )
+    except Exception as e:
+        logger.error(
+            f"Failed to resolve design_system_id for tool registration: {e}",
+            extra={"design_system_id": design_system_id},
+        )
+        return False
+
+
 def _build_tools(
     config: AgentConfig,
     session_data: dict[str, Any],
@@ -351,12 +389,21 @@ def _build_tools(
     )
     tools.append(image_search_tool)
 
-    # Brand-asset search tool — ONLY when a design system is selected (state
-    # guard). Bound to the design_system_id via closure so it surfaces only that
-    # system's assets; the compiled style's ASSET CONTRACT tells the model to call
-    # it. Gated on design_system_id alone — a pinned template_id (Phase 4) shapes
-    # prompt assembly only and never changes tool registration.
-    if config.design_system_id is not None:
+    # Brand-asset search tool — ONLY when a selected design system is ACTIVE.
+    # Bound to the design_system_id via closure so it surfaces only that system's
+    # assets; the compiled style's ASSET CONTRACT tells the model to call it. A
+    # pinned template_id (Phase 4) shapes prompt assembly only and never changes
+    # tool registration.
+    #
+    # The is_active half matters because a session keeps its pin after the design
+    # system is soft-deleted: on the id alone, generation got a fully working brand
+    # tool for a TOMBSTONE (measured: "Found 2 brand asset(s)" with embeddable
+    # handles) while the prompt branch, which does filter is_active, supplied no
+    # brand at all — so new content was authored against a deleted brand with none
+    # of its instructions. Both halves now answer the same question.
+    if config.design_system_id is not None and _design_system_is_active(
+        config.design_system_id
+    ):
         tools.append(build_ds_asset_tool(config.design_system_id))
 
     genie_index = 0

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev15}/src/services/converter_jail/jail.py

@@ -43,6 +43,13 @@ class JailResult:
     returncode: int
     timed_out: bool
     stderr_tail: str = ""
+    #: Per-slide outcomes reported by the trusted runner, in the order received:
+    #: True when the slide's generated code produced its slide, False when the
+    #: deterministic placeholder fallback was used. EMPTY when the runner reported
+    #: nothing (a runner with no result channel, or one that died before emitting) —
+    #: callers must treat empty as "unknown", never as "all failed", so an absent
+    #: channel cannot manufacture a failure.
+    slide_results: tuple = ()
 
 
 @dataclass
@@ -177,8 +184,14 @@ def _spawn(
 
         assert proc.stdout is not None
 
+        slide_results: List[bool] = []
+
         def _drain_stdout():
             for line in proc.stdout:
+                result = protocol.decode_slide_result(line)
+                if result is not None:
+                    slide_results.append(result[1])
+                    continue
                 decoded = protocol.decode_progress(line)
                 if decoded and progress_cb:
                     try:
@@ -207,6 +220,7 @@ def _spawn(
             returncode=proc.returncode if proc.returncode is not None else -1,
             timed_out=timed_out,
             stderr_tail="".join(stderr_lines[-40:]),
+            slide_results=tuple(slide_results),
         )
     finally:
         shutil.rmtree(env["HOME"], ignore_errors=True)

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev15}/src/services/converter_jail/pptx_runner.py

@@ -106,14 +106,22 @@ def run(job_dir: str, output_path: str, emit: Optional[Callable[[str], None]] =
         sdir = Path(job_dir) / entry["dir"]
         assets_dir = str(sdir / protocol.ASSETS_DIR)
 
+        # Report whether this slide got REAL content or the deterministic
+        # placeholder. Both fallback branches below are invisible in the saved
+        # file — it is a valid .pptx either way — so the host cannot otherwise
+        # tell an all-placeholder deck from a good one.
+        rendered = True
         if not entry.get("has_code"):
             _add_fallback(prs, i, f"Slide {i}")
+            rendered = False
         else:
             html_str = (sdir / protocol.HTML_NAME).read_text(encoding="utf-8")
             code = (sdir / protocol.CODE_NAME).read_text(encoding="utf-8")
             if not _exec_snippet(code, prs, html_str, assets_dir):
                 _add_fallback(prs, i, "Slide Content")
+                rendered = False
 
+        emit(protocol.encode_slide_result(entry["index"], rendered))
         emit(protocol.encode_progress(i, total, f"Building slide {i}/{total}…"))
 
     prs.save(output_path)

{databricks_tellr_app-0.4.2.dev13 → databricks_tellr_app-0.4.2.dev15}/src/services/converter_jail/protocol.py

@@ -23,6 +23,39 @@ HTML_NAME = "html.txt"
 ASSETS_DIR = "assets"
 
 
+# Sentinel prefix for the trusted per-slide RESULT channel. Same trust property as
+# PROGRESS_PREFIX and for the same reason: only the trusted runner emits it, and
+# generated code's stdout is redirected to stderr before any snippet executes, so a
+# snippet cannot forge a result for itself. The host needs this because whether a
+# slide produced REAL content is only known after validation and execution — a
+# non-empty snippet can still be rejected by the import allowlist or raise when it
+# runs, and both outcomes fall back to a placeholder slide. Without a report, an
+# all-placeholder deck is indistinguishable from a good one.
+RESULT_PREFIX = "@@TELLR_JAIL_SLIDE_RESULT@@ "
+
+
+def encode_slide_result(index: int, rendered: bool) -> str:
+    """Encode one per-slide outcome as a single stdout line (with newline).
+
+    ``rendered`` is True only when the slide's own generated code ran and produced
+    its slide; False whenever the deterministic placeholder fallback was used.
+    """
+    payload = json.dumps({"index": index, "rendered": bool(rendered)})
+    return f"{RESULT_PREFIX}{payload}\n"
+
+
+def decode_slide_result(line: str):
+    """Decode a stdout line into ``(index, rendered)``, or None when the line is
+    not a slide-result line / is malformed."""
+    if not line.startswith(RESULT_PREFIX):
+        return None
+    try:
+        data = json.loads(line[len(RESULT_PREFIX):].strip())
+        return int(data["index"]), bool(data["rendered"])
+    except (ValueError, KeyError, TypeError):
+        return None
+
+
 def encode_progress(current: int, total: int, message: str) -> str:
     """Encode one progress event as a single stdout line (with newline)."""
     payload = json.dumps({"current": current, "total": total, "message": message})