implicant 0.7.2__tar.gz → 0.7.5__tar.gz

implicant-0.7.2/README.md → implicant-0.7.5/PKG-INFO

@@ -1,3 +1,30 @@
+Metadata-Version: 2.5
+Name: implicant
+Version: 0.7.5
+Summary: Python client SDK for the Implicant FHE inference platform
+Author: Implicant
+License: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: implicant-fhe<0.6,>=0.5
+Requires-Dist: numpy>=1.26
+Requires-Dist: pydantic>=2.6
+Requires-Dist: rich>=13.8
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: build>=1; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Provides-Extra: ui
+Requires-Dist: fastapi>=0.115; extra == 'ui'
+Requires-Dist: uvicorn>=0.30; extra == 'ui'
+Provides-Extra: vision
+Requires-Dist: opencv-python-headless>=4.8; extra == 'vision'
+Requires-Dist: pillow>=10; extra == 'vision'
+Requires-Dist: torch>=2.2; extra == 'vision'
+Requires-Dist: torchvision>=0.17; extra == 'vision'
+Description-Content-Type: text/markdown
+
 # Implicant SDK
 
 Python **client** for the Implicant FHE inference platform. Encrypts one row
@@ -251,6 +278,23 @@ docker run --rm -p 8642:8642 \
 # then open the printed URL — including the #token — in your browser
 ```
 
+**Vision Rules** — a third tab with a concept-bottleneck face demo (the 38
+CelebA attributes → a short if-then rulebook → Female/Male, every fired rule
+spelled out in words; gallery faces, photo upload, webcam snapshot and live
+view). It runs the model in the clear on the serving machine and needs the
+optional `[vision]` extra (torch, torchvision, OpenCV, Pillow); without it
+the tab shows an install hint and nothing else changes:
+
+```bash
+pip install "implicant[ui,vision]"                     # macOS / Windows
+# Linux: point pip at PyTorch's CPU index too (the CPU torch wheel is
+# ~200 MB; PyPI's default Linux build pulls ~2 GB of CUDA):
+PIP_EXTRA_INDEX_URL=https://download.pytorch.org/whl/cpu pip install "implicant[ui,vision]"
+```
+
+The Docker image installs the extra already. The camera needs a secure
+page (`localhost` or HTTPS).
+
 By default the page is protected by a per-launch URL token — the printed
 `#fragment` is the credential, so keep the full URL. For a deliberately
 public deployment behind a reverse proxy (e.g. a demo site), start with

implicant-0.7.2/PKG-INFO → implicant-0.7.5/README.md

@@ -1,25 +1,3 @@
-Metadata-Version: 2.5
-Name: implicant
-Version: 0.7.2
-Summary: Python client SDK for the Implicant FHE inference platform
-Author: Implicant
-License: Apache-2.0
-License-File: LICENSE
-Requires-Python: >=3.10
-Requires-Dist: httpx>=0.27
-Requires-Dist: implicant-fhe<0.6,>=0.5
-Requires-Dist: numpy>=1.26
-Requires-Dist: pydantic>=2.6
-Requires-Dist: rich>=13.8
-Requires-Dist: typer>=0.12
-Provides-Extra: dev
-Requires-Dist: build>=1; extra == 'dev'
-Requires-Dist: pytest>=8; extra == 'dev'
-Provides-Extra: ui
-Requires-Dist: fastapi>=0.115; extra == 'ui'
-Requires-Dist: uvicorn>=0.30; extra == 'ui'
-Description-Content-Type: text/markdown
-
 # Implicant SDK
 
 Python **client** for the Implicant FHE inference platform. Encrypts one row
@@ -273,6 +251,23 @@ docker run --rm -p 8642:8642 \
 # then open the printed URL — including the #token — in your browser
 ```
 
+**Vision Rules** — a third tab with a concept-bottleneck face demo (the 38
+CelebA attributes → a short if-then rulebook → Female/Male, every fired rule
+spelled out in words; gallery faces, photo upload, webcam snapshot and live
+view). It runs the model in the clear on the serving machine and needs the
+optional `[vision]` extra (torch, torchvision, OpenCV, Pillow); without it
+the tab shows an install hint and nothing else changes:
+
+```bash
+pip install "implicant[ui,vision]"                     # macOS / Windows
+# Linux: point pip at PyTorch's CPU index too (the CPU torch wheel is
+# ~200 MB; PyPI's default Linux build pulls ~2 GB of CUDA):
+PIP_EXTRA_INDEX_URL=https://download.pytorch.org/whl/cpu pip install "implicant[ui,vision]"
+```
+
+The Docker image installs the extra already. The camera needs a secure
+page (`localhost` or HTTPS).
+
 By default the page is protected by a per-launch URL token — the printed
 `#fragment` is the credential, so keep the full URL. For a deliberately
 public deployment behind a reverse proxy (e.g. a demo site), start with

{implicant-0.7.2 → implicant-0.7.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "implicant"
-version = "0.7.2"
+version = "0.7.5"
 description = "Python client SDK for the Implicant FHE inference platform"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -56,6 +56,24 @@ ui = [
     "fastapi>=0.115",
     "uvicorn>=0.30",
 ]
+# The Vision Rules page (`implicant ui`, third tab): a concept-bottleneck
+# face model that runs in the clear on the serving machine. Heavy on
+# purpose, so it is its own extra — `implicant ui` starts and every other
+# page works without it (the tab then shows an install hint). The engine
+# is imported lazily on the first analysis. On Linux, PyPI's torch wheel
+# pulls CUDA (~2 GB); point pip at the CPU torch wheels at
+# download.pytorch.org/whl/cpu ON THE PIP COMMAND LINE (as pip's extra
+# index), e.g. `pip install -e ".[ui,vision]"` with that flag. It must
+# never be written into this file: the release gate
+# (scripts/check_no_server_surface.py) rejects any pip index configuration
+# in the shipped sdist/METADATA, and pyproject.toml ships in the sdist.
+# torch/torchvision publish cp310-cp313 wheels; cp314 lags.
+vision = [
+    "torch>=2.2",
+    "torchvision>=0.17",
+    "opencv-python-headless>=4.8",
+    "pillow>=10",
+]
 
 [project.scripts]
 implicant = "implicant.cli.main:app"
@@ -85,6 +103,11 @@ exclude = [
     "docs",
     "tests",
     "scripts",
+    # docker/Dockerfile carries the PyTorch CPU wheel index flag for the
+    # [vision] extra; the release gate (check_no_server_surface.py) rejects
+    # any pip index configuration in the sdist, and the Dockerfile is deploy
+    # infrastructure the published sdist does not need anyway.
+    "docker",
     "demo_handoff.zip",
 ]
 

{implicant-0.7.2 → implicant-0.7.5}/src/implicant/cli/main.py

@@ -115,8 +115,9 @@ def _import_ui():
     from ..ui.events import EventBus
     from ..ui.server import create_app
     from ..ui.service import UiService
+    from ..vision.service import VisionService
 
-    return EventBus, UiService, create_app, uvicorn
+    return EventBus, UiService, VisionService, create_app, uvicorn
 
 
 def _free_port(host: str = "127.0.0.1") -> int:
@@ -336,7 +337,7 @@ def ui(
         )
         raise typer.Exit(code=2)
     try:
-        EventBus, UiService, create_app, uvicorn = _import_ui()
+        EventBus, UiService, VisionService, create_app, uvicorn = _import_ui()
     except ModuleNotFoundError:
         typer.echo(
             "Error: the web UI needs the optional dependencies.\n"
@@ -373,6 +374,10 @@ def ui(
         raise typer.Exit(code=2)
     bus = EventBus()
     service = UiService(bus)
+    # The Vision Rules tab (2026-09-04): the service is always built (it is
+    # light), the engine only loads on the first analysis; without the
+    # [vision] extra the tab shows the install hint and nothing else changes.
+    vision = VisionService()
     if public_demo:
         typer.echo(
             "Warning: public demo mode — no URL token, anyone who can reach "
@@ -380,10 +385,10 @@ def ui(
             err=True,
         )
         token = None
-        app_ = create_app(service, public_demo=True)
+        app_ = create_app(service, public_demo=True, vision=vision)
     else:
         token = secrets.token_urlsafe(16)
-        app_ = create_app(service, token=token)
+        app_ = create_app(service, token=token, vision=vision)
     # `--port 0` is the conventional "pick a free port" idiom. bind(host, 0)
     # always succeeds, so it sails through _can_bind — but uvicorn would then
     # bind an OS-chosen ephemeral port it never announces (log_level=warning)
@@ -405,6 +410,12 @@ def ui(
         )
         raise typer.Exit(code=2)
     typer.echo(f"Implicant UI: {url}", err=True)
+    typer.echo(
+        "Vision Rules: available"
+        if vision.available
+        else 'Vision Rules: not installed (pip install "implicant[vision]")',
+        err=True,
+    )
     if not no_browser:
         opened = False
         try:

{implicant-0.7.2 → implicant-0.7.5}/src/implicant/ui/copy.py

@@ -89,6 +89,7 @@ __all__ = [
     "BOOT_INCOMPLETE",
     "SERVER_GONE",
     "SESSION_STALE",
+    "RESULT_CORE_NOTE",
     "RESULT_LABEL_FALLBACK",
     "REQUEST_FAILED",
     "CIPHER_BYTES",
@@ -117,6 +118,49 @@ __all__ = [
     "HISTORY_LIMIT_NOTE",
     "HISTORY_VIEW_INPUT",
     "HISTORY_HIDE_INPUT",
+    "VISION_INTRO_PARAS",
+    "VISION_PLAIN_NOTE",
+    "VISION_PHOTO_NOTE",
+    "VISION_RULEBOOK_LABEL",
+    "VISION_RULEBOOKS",
+    "VISION_RULEBOOK_HINT",
+    "VISION_GALLERY_TITLE",
+    "VISION_GALLERY_HINT",
+    "VISION_BUTTONS",
+    "VISION_CAMERA_HINT",
+    "VISION_CAMERA_INSECURE",
+    "VISION_CAMERA_DENIED",
+    "VISION_LIVE_WAITING",
+    "VISION_ANALYZING",
+    "VISION_NO_FACE",
+    "VISION_BAD_IMAGE",
+    "VISION_TOO_LARGE",
+    "VISION_BUSY",
+    "VISION_UNAVAILABLE",
+    "VISION_GALLERY_NOT_FOUND",
+    "VISION_LABELS",
+    "VISION_VERDICT_PROB",
+    "VISION_WHY_TITLE",
+    "VISION_WHY_HINT",
+    "VISION_WHY_NONE",
+    "VISION_RULE_ID",
+    "VISION_WEIGHT_TOWARD",
+    "VISION_LEGEND_PUSHES",
+    "VISION_TERM_OR",
+    "VISION_FOOTER",
+    "VISION_CONCEPTS_TITLE",
+    "VISION_GAUGE_TITLE",
+    "VISION_HESITANT_NOTE",
+    "VISION_THUMB_CAPTION",
+    "VISION_SOURCE_CAPTION",
+    "VISION_CONCEPT_NAMES",
+    "VISION_CONCEPT_PHRASES",
+    "VISION_EXEC_ZONE",
+    "VISION_STEP_LABELS",
+    "VISION_FEED_TITLE",
+    "VISION_FEED_EMPTY",
+    "VISION_FEED_LIMIT_NOTE",
+    "VISION_FEED_SOURCES",
     "format_duration_ns",
     "format_expansion_ratio",
     "friendly_error",
@@ -142,6 +186,7 @@ NAV_BACK = "← Back"
 NAV_TABS: dict[str, str] = {
     "technology": "Technology",
     "models": "Models",
+    "vision": "Vision Rules",
     "contact": "Contact us",
     "website": "implicant.ai",
     "linkedin": "LinkedIn",
@@ -291,6 +336,8 @@ ACT_TITLES: dict[str, str] = {
     "act2": "1. Generate your keys",
     "act3": "Input data",
     "act4": "Result",
+    "vision": "Vision Rules",
+    "vision_result": "Result",
 }
 
 # Display-name overrides for model slugs (owner, 2026-09-04): the page's
@@ -801,6 +848,202 @@ HISTORY_VIEW_INPUT = "View input"
 HISTORY_HIDE_INPUT = "Hide input"
 
 
+# ---- Vision Rules (the third header tab, 2026-09-04) -----------------------
+# The concept-bottleneck FACE demo ported from get_concept_into_rules: a
+# model whose every decision goes through 38 named CelebA attributes and a
+# short TT-Sparse rulebook. It runs IN THE CLEAR on the machine serving the
+# demo — the page says so plainly (VISION_PLAIN_NOTE) and never borrows the
+# Models page's encryption vocabulary. Wording rule (§6.6 + BANNED_CLAIMS):
+# describe what happens to a photo factually (memory only, a session
+# thumbnail), never as a privacy promise.
+VISION_INTRO_PARAS: tuple[str, ...] = (
+    "This face model is fully transparent. Everything it knows about a face "
+    "is its score on 38 human concepts — beard, eyeglasses, smiling, gray "
+    "hair, lipstick — and every decision is a short list of if-then rules "
+    "written over those concepts.",
+    "Pick a face and the page shows the concepts the model saw and exactly "
+    "which rules fired, in plain words. The concepts are the ones we chose "
+    "for this demonstration; a client lists the concepts that matter for "
+    "their own task, and the model and its rules are built over that list.",
+)
+VISION_PLAIN_NOTE = (
+    "This page runs the model in the clear on the machine serving the demo: "
+    "nothing is encrypted and no platform round trip happens. It shows the "
+    "reasoning; the Models page shows the same kind of rulebook evaluated "
+    "on encrypted data."
+)
+VISION_PHOTO_NOTE = (
+    "Photos and camera frames are analyzed in memory and kept only as a small "
+    "thumbnail in this session's list of analyses; nothing is written to disk."
+)
+VISION_RULEBOOK_LABEL = "Rulebook"
+VISION_RULEBOOKS: dict[str, str] = {
+    "compact": "Compact — 6 rules",
+    "accurate": "Accurate — 26 rules",
+}
+VISION_RULEBOOK_HINT = "Fewer rules read easier; more rules are a little more precise."
+VISION_GALLERY_TITLE = "Click a test face"
+VISION_GALLERY_HINT = (
+    "Photos the model never saw during training — click one to see its "
+    "concept scores and exactly which rules fired."
+)
+VISION_BUTTONS: dict[str, str] = {
+    "upload": "Upload a photo",
+    "camera": "Use camera",
+    "camera_stop": "Stop camera",
+    "snap": "Take picture",
+    "another": "Try another face",
+}
+VISION_CAMERA_HINT = (
+    "Your browser owns the camera: the live view shows the face box, the "
+    "verdict and the concept gauges frame by frame. Take picture keeps one "
+    "analysis."
+)
+VISION_CAMERA_INSECURE = (
+    "The camera needs a secure page: open this demo at localhost or over HTTPS."
+)
+VISION_CAMERA_DENIED = "Camera access was refused. Allow the camera and try again."
+VISION_LIVE_WAITING = "Looking for a face…"
+VISION_ANALYZING = "Analyzing…"
+VISION_NO_FACE = "No face was found, so the whole picture was scored instead."
+VISION_BAD_IMAGE = "That file could not be read as an image. Try a JPEG or PNG."
+VISION_TOO_LARGE = "That image is larger than 8 MB. Please use a smaller one."
+VISION_BUSY = "Still analyzing the previous image — give it a moment."
+VISION_UNAVAILABLE = (
+    "The vision demo is not installed on this server. Install it with:  "
+    'pip install "implicant[vision]"'
+)
+VISION_GALLERY_NOT_FOUND = "That gallery face does not exist."
+# Wire label -> display; index 0 = female, 1 = male (the CelebA `male`
+# target, exactly like KNOWN_MODELS.class_names follows the training encoding).
+VISION_LABELS: dict[str, str] = {"female": "Female", "male": "Male"}
+VISION_VERDICT_PROB = "p({label}) {prob} from the rules"
+VISION_WHY_TITLE = "Why {verdict}: {n_fired} of {n_total} rules fired"
+VISION_WHY_HINT = (
+    "Each card is one fired rule and the condition this face met; its "
+    "weight joins the score. Rules that did not fire are not shown."
+)
+VISION_WHY_NONE = (
+    "No rule matched this face — the base score alone decides: {base} → {label}"
+)
+VISION_RULE_ID = "R{rank}"
+VISION_WEIGHT_TOWARD = "{weight} → {label}"
+VISION_LEGEND_PUSHES = "pushes {label}"
+VISION_TERM_OR = "or"
+VISION_FOOTER = (
+    "base {base} + {n_fired} fired rules {fired} = score {score} → "
+    "p({label}) {prob}"
+)
+VISION_CONCEPTS_TITLE = "{n} concept scores — everything the model knows about this face"
+VISION_GAUGE_TITLE = "{name}: {score} (cut {cut})"
+VISION_HESITANT_NOTE = (
+    "Filled: above its cut. Amber: within 0.1 of the cut — a hesitant score."
+)
+VISION_THUMB_CAPTION = "Model input — the 224 px crop the model actually saw"
+VISION_SOURCE_CAPTION = "Your picture with the detected face"
+# Raw CelebA attribute -> display name (chips, gauges).
+VISION_CONCEPT_NAMES: dict[str, str] = {
+    "5_o_Clock_Shadow": "5 o'clock shadow",
+    "Arched_Eyebrows": "arched eyebrows",
+    "Attractive": "attractive",
+    "Bags_Under_Eyes": "bags under the eyes",
+    "Bald": "bald",
+    "Bangs": "bangs",
+    "Big_Lips": "big lips",
+    "Big_Nose": "big nose",
+    "Black_Hair": "black hair",
+    "Blond_Hair": "blond hair",
+    "Blurry": "blurry photo",
+    "Brown_Hair": "brown hair",
+    "Bushy_Eyebrows": "bushy eyebrows",
+    "Chubby": "chubby",
+    "Double_Chin": "double chin",
+    "Eyeglasses": "eyeglasses",
+    "Goatee": "goatee",
+    "Gray_Hair": "gray hair",
+    "Heavy_Makeup": "heavy makeup",
+    "High_Cheekbones": "high cheekbones",
+    "Mouth_Slightly_Open": "mouth slightly open",
+    "Mustache": "mustache",
+    "Narrow_Eyes": "narrow eyes",
+    "No_Beard": "no beard",
+    "Oval_Face": "oval face",
+    "Pale_Skin": "pale skin",
+    "Pointy_Nose": "pointy nose",
+    "Receding_Hairline": "receding hairline",
+    "Rosy_Cheeks": "rosy cheeks",
+    "Sideburns": "sideburns",
+    "Smiling": "smiling",
+    "Straight_Hair": "straight hair",
+    "Wavy_Hair": "wavy hair",
+    "Wearing_Earrings": "earrings",
+    "Wearing_Hat": "hat",
+    "Wearing_Lipstick": "lipstick",
+    "Wearing_Necklace": "necklace",
+    "Wearing_Necktie": "necktie",
+}
+# Plain words for a rule literal: (present, absent). Verbatim from the demo's
+# overlay.py PHRASES — this is what makes a fired rule read as English.
+VISION_CONCEPT_PHRASES: dict[str, tuple[str, str]] = {
+    "5_o_Clock_Shadow": ("5 o'clock shadow", "no 5 o'clock shadow"),
+    "Arched_Eyebrows": ("arched eyebrows", "no arched eyebrows"),
+    "Attractive": ("attractive", "not attractive"),
+    "Bags_Under_Eyes": ("bags under the eyes", "no bags under the eyes"),
+    "Bald": ("bald", "not bald"),
+    "Bangs": ("bangs", "no bangs"),
+    "Big_Lips": ("big lips", "no big lips"),
+    "Big_Nose": ("big nose", "no big nose"),
+    "Black_Hair": ("black hair", "not black hair"),
+    "Blond_Hair": ("blond hair", "not blond hair"),
+    "Blurry": ("blurry photo", "sharp photo"),
+    "Brown_Hair": ("brown hair", "not brown hair"),
+    "Bushy_Eyebrows": ("bushy eyebrows", "no bushy eyebrows"),
+    "Chubby": ("chubby", "not chubby"),
+    "Double_Chin": ("double chin", "no double chin"),
+    "Eyeglasses": ("eyeglasses", "no eyeglasses"),
+    "Goatee": ("goatee", "no goatee"),
+    "Gray_Hair": ("gray hair", "not gray hair"),
+    "Heavy_Makeup": ("heavy makeup", "no heavy makeup"),
+    "High_Cheekbones": ("high cheekbones", "no high cheekbones"),
+    "Mouth_Slightly_Open": ("mouth slightly open", "mouth closed"),
+    "Mustache": ("mustache", "no mustache"),
+    "Narrow_Eyes": ("narrow eyes", "no narrow eyes"),
+    "No_Beard": ("no beard", "beard"),
+    "Oval_Face": ("oval face", "not an oval face"),
+    "Pale_Skin": ("pale skin", "not pale skin"),
+    "Pointy_Nose": ("pointy nose", "no pointy nose"),
+    "Receding_Hairline": ("receding hairline", "no receding hairline"),
+    "Rosy_Cheeks": ("rosy cheeks", "no rosy cheeks"),
+    "Sideburns": ("sideburns", "no sideburns"),
+    "Smiling": ("smiling", "not smiling"),
+    "Straight_Hair": ("straight hair", "not straight hair"),
+    "Wavy_Hair": ("wavy hair", "not wavy hair"),
+    "Wearing_Earrings": ("earrings", "no earrings"),
+    "Wearing_Hat": ("hat", "no hat"),
+    "Wearing_Lipstick": ("lipstick", "no lipstick"),
+    "Wearing_Necklace": ("necklace", "no necklace"),
+    "Wearing_Necktie": ("necktie", "no necktie"),
+}
+# The page's three-step execution strip. Everything runs locally, so there is
+# one zone; steps go pending -> done from the RESPONSE's timings (never a
+# fabricated in-progress state).
+VISION_EXEC_ZONE = "Runs where implicant ui runs — no encryption, no platform round trip"
+VISION_STEP_LABELS: dict[str, str] = {
+    "detect_pending": "Find the face",
+    "detect_done": "Face found",
+    "score_pending": "Score 38 concepts",
+    "score_done": "38 concepts scored",
+    "rules_pending": "Apply the rules",
+    "rules_done": "Rules applied",
+}
+VISION_FEED_TITLE = "Your analyses"
+VISION_FEED_EMPTY = "Nothing yet — pick a face, upload a photo or take a picture."
+VISION_FEED_LIMIT_NOTE = "Showing the latest 20 analyses"
+VISION_FEED_SOURCES: dict[str, str] = {
+    "gallery": "gallery", "upload": "upload", "camera": "camera",
+}
+
+
 def format_duration_ns(ns: int) -> str:
     """Render a raw nanosecond duration per ADD-PERF-7 (display-only rounding).
 
@@ -838,6 +1081,19 @@ def format_expansion_ratio(payload_bytes: int, encoded_bytes: int) -> str:
     return template.replace("{ratio}", text)
 
 
+# Act-4 single-core note (owner, 2026-09-04): a small panel under the
+# buttons saying the demo platform evaluates on one CPU core. Wording is
+# deliberately number-free — the measured thread-scaling of the deployed
+# engine (implicant-fhe/bench/stack1_phoenix_bsgs) caps a SINGLE
+# inference's speedup around 2x regardless of core count, while
+# throughput (parallel inferences) scales with cores; "faster" and
+# "in parallel" are both true, a bold multiplier would not be.
+RESULT_CORE_NOTE = (
+    "This demo's platform evaluates on a single CPU core. A multi-core "
+    "server answers a single encrypted inference faster, and serves many "
+    "inferences in parallel."
+)
+
 # The key id is deliberately NOT shown (product owner, 2026-08-26 — same
 # rule as act 2: nothing hinting at the model's parameters). ADD-RECAP-1
 # only says key_id MAY remain as secondary detail, so dropping it complies.
@@ -888,6 +1144,14 @@ def friendly_error(exc: Exception) -> str:
         # MUST also precede the ValueError arm (NotPreparedError subclasses
         # it): this is a state desync, not a field the participant typed.
         return NOT_PREPARED
+    try:  # local import: the vision package is light (no torch at import)
+        from ..vision.service import VisionImageError
+    except Exception:  # pragma: no cover
+        VisionImageError = ()
+    if VisionImageError and isinstance(exc, VisionImageError):
+        # MUST also precede the ValueError arm (VisionImageError subclasses
+        # it): an unreadable upload is about the file, not a form field.
+        return VISION_BAD_IMAGE
     if isinstance(exc, KeyError):
         return "Please fill in every field before encrypting."
     if isinstance(exc, ValueError):

{implicant-0.7.2 → implicant-0.7.5}/src/implicant/ui/server.py

@@ -33,12 +33,19 @@ from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel, field_validator
 
 from . import copy as ui_copy
+from ..vision.routes import add_vision_routes
+from ..vision.service import (
+    GALLERY_DIR,
+    VisionBusyError,
+    VisionUnavailableError,
+)
 from .events import sse_format
 from .service import BusyError
 
 __all__ = ["create_app"]
 
 _STATIC = Path(__file__).parent / "static"
+_VISION_STATIC = Path(__file__).parent.parent / "vision" / "static"
 _ALLOWED_HOSTS = {"127.0.0.1", "localhost", "::1"}
 _SSE_KEEPALIVE_S = 15.0
 _SSE_POLL_S = 0.05  # imperceptible for the theater; costs no thread at all
@@ -82,10 +89,18 @@ class PredictBody(BaseModel):
 
 
 def create_app(
-    service: Any, *, token: str | None = None, public_demo: bool = False
+    service: Any,
+    *,
+    token: str | None = None,
+    public_demo: bool = False,
+    vision: Any | None = None,
 ) -> FastAPI:
     """Build the app around an injected service (tests pass a fake).
 
+    ``vision`` is the Vision Rules service (``None`` when the ``[vision]``
+    extra is missing: the tab then shows the install hint, nothing else
+    changes).
+
     Exactly one of the two configurations is valid: a non-empty ``token``
     (private mode, the default everywhere) or ``public_demo=True`` with no
     token at all. Anything else refuses to build — public mode is opt-in
@@ -102,6 +117,17 @@ def create_app(
     app = FastAPI(
         title="implicant ui", docs_url=None, redoc_url=None, openapi_url=None
     )
+    # Longer prefixes FIRST: Starlette matches mounts in registration order,
+    # so /static would otherwise swallow /static/vision/... and 404 it. The
+    # gallery photos are ordinary static assets (unguarded, like the page).
+    app.mount(
+        "/static/vision/gallery",
+        StaticFiles(directory=GALLERY_DIR),
+        name="vision-gallery",
+    )
+    app.mount(
+        "/static/vision", StaticFiles(directory=_VISION_STATIC), name="vision-static"
+    )
     app.mount("/static", StaticFiles(directory=_STATIC), name="static")
 
     @app.middleware("http")
@@ -291,6 +317,11 @@ def create_app(
             return fn(*args)
         except BusyError:
             raise HTTPException(status_code=409, detail=ui_copy.BUSY_ERROR)
+        except VisionBusyError:
+            raise HTTPException(status_code=409, detail=ui_copy.VISION_BUSY)
+        except VisionUnavailableError:
+            traceback.print_exc()
+            raise HTTPException(status_code=503, detail=ui_copy.VISION_UNAVAILABLE)
         except ValueError as exc:
             # str(exc) would put raw Python text on screen ("could not convert
             # string to float: 'abc'"); spec §7 wants plain language in the
@@ -341,4 +372,6 @@ def create_app(
             headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
         )
 
+    add_vision_routes(app, vision=vision, guard=_guard, run=_run)
+
     return app

{implicant-0.7.2 → implicant-0.7.5}/src/implicant/ui/static/app.css

@@ -382,6 +382,16 @@ input.invalid { border-color: var(--err); }
 .fhe-fig .cout { fill: var(--cipher); opacity: 0; filter: drop-shadow(0 0 2px var(--cipher)); }
 .fhe-fig .res { fill: var(--result); opacity: 0; }
 .fhe-fig .res line { stroke: var(--result); stroke-width: 3.2; stroke-linecap: round; }
+/* Verdict glyph matches the verdict (owner's bug report 2026-09-04): the
+   cross shows only for Malignant; Benign swaps in the same-box checkmark
+   — before this, Benign rendered a green X. The .res group keeps the
+   opacity timeline; only its children trade places. */
+.fhe-fig .res-v {
+  fill: none; stroke: var(--result); stroke-width: 3.2;
+  stroke-linecap: round; stroke-linejoin: round; display: none;
+}
+.fhe-fig.benign .res-x { display: none; }
+.fhe-fig.benign .res-v { display: inline; }
 .fhe-fig .rec { font-size: 7.5px; font-family: var(--font-display); text-anchor: middle; }
 .fhe-fig .rec-k { fill: var(--ink); }
 .fhe-fig .reslbl {
@@ -969,6 +979,13 @@ input.invalid { border-color: var(--err); }
   from { opacity: 0; transform: translateY(14px) scale(.97); filter: blur(10px); }
 }
 #result-cipher { animation: rise .4s var(--ease-settle) both; animation-delay: .55s; }
+/* Single-core note (owner, 2026-09-04): a small panel under the act-4
+   buttons, in the same card idiom as the tech-page panels. */
+#core-note {
+  background: var(--panel); border-radius: .6rem; box-shadow: var(--ring);
+  padding: .85rem 1.1rem; margin: 1.6rem 0 0; max-width: 44rem;
+  color: var(--dim); font-size: .88rem; line-height: 1.55;
+}
 #stage-line { color: var(--dim); min-height: 1.5rem; }
 /* Replayed by the stage arm on each REAL token change (the .swap class is
    re-added after a reflow): the new label rises in; unknown tokens keep the