splash screen

app/android/app/src/main/res/drawable-night-v21/launch_background.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item>
+        <bitmap android:gravity="fill" android:src="@drawable/background"/>
+    </item>
+    <item>
+        <bitmap android:gravity="center" android:src="@drawable/splash"/>
+    </item>
+</layer-list>

app/android/app/src/main/res/drawable-night/launch_background.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item>
+        <bitmap android:gravity="fill" android:src="@drawable/background"/>
+    </item>
+    <item>
+        <bitmap android:gravity="center" android:src="@drawable/splash"/>
+    </item>
+</layer-list>

app/android/app/src/main/res/values-night-v31/styles.xml

@@ -6,7 +6,7 @@
         <item name="android:windowFullscreen">false</item>
         <item name="android:windowDrawsSystemBarBackgrounds">false</item>
         <item name="android:windowLayoutInDisplayCutoutMode">shortEdges</item>
-        <item name="android:windowSplashScreenBackground">#5B5BD6</item>
+        <item name="android:windowSplashScreenBackground">#181818</item>
         <item name="android:windowSplashScreenAnimatedIcon">@drawable/android12splash</item>
     </style>
     <!-- Theme applied to the Android Window as soon as the process has started.

app/android/app/src/main/res/values-v31/styles.xml

@@ -6,7 +6,7 @@
         <item name="android:windowFullscreen">false</item>
         <item name="android:windowDrawsSystemBarBackgrounds">false</item>
         <item name="android:windowLayoutInDisplayCutoutMode">shortEdges</item>
-        <item name="android:windowSplashScreenBackground">#5B5BD6</item>
+        <item name="android:windowSplashScreenBackground">#F5F0E8</item>
         <item name="android:windowSplashScreenAnimatedIcon">@drawable/android12splash</item>
     </style>
     <!-- Theme applied to the Android Window as soon as the process has started.

app/lib/ui/features/graph/views/graph_screen.dart

@@ -1421,13 +1421,13 @@ class _GraphPainter extends CustomPainter {
 
       double sw;
       if (e.kind == 'reference') {
-        sw = (highlight ? 2.5 : 1.2 + e.weight) * clampedZoom;
+        sw = (highlight ? 1.5 : 0.6 + e.weight * 0.5) * clampedZoom;
       } else if (e.kind == 'tag') {
-        sw = (highlight ? 1.5 : 0.5) * clampedZoom;
+        sw = (highlight ? 0.9 : 0.35) * clampedZoom;
       } else if (e.kind == 'membership') {
-        sw = (highlight ? 2.0 : 1.4) * clampedZoom;
+        sw = (highlight ? 1.2 : 0.7) * clampedZoom;
       } else {
-        sw = (highlight ? 2.2 : 0.6 + e.weight * 1.6) * clampedZoom;
+        sw = (highlight ? 1.4 : 0.35 + e.weight * 0.9) * clampedZoom;
       }
 
       final paint = Paint()

app/pubspec.yaml

@@ -107,11 +107,11 @@ flutter_launcher_icons:
 flutter_native_splash:
   color: "#F5F0E8"
   color_dark: "#181818"
-  image: "assets/brand/splash_logo.png"
+  image: "assets/brand/adaptive_foreground.png"
   android_12:
     color: "#F5F0E8"
     color_dark: "#181818"
-    image: "assets/brand/splash_logo.png"
+    image: "assets/brand/adaptive_foreground.png"
 
   # To add assets to your application, add an assets section, like this:
   # assets:

backend/app/config.py

@@ -42,6 +42,10 @@ class Settings(BaseSettings):
     gemini_api_key: str = ""
     gemini_vision_model: str = "gemini-2.0-flash-lite"
 
+    # NVIDIA NVLM vision (OpenAI-compatible; free credits at integrate.api.nvidia.com)
+    nvidia_api_key: str = ""
+    nvidia_vision_model: str = "nvidia/nvlm-d-72b"
+
     # local Whisper via faster-whisper (no API, no rate limits)
     # tiny=39MB | base=74MB | small=244MB
     local_whisper_model: str = "base"
@@ -93,6 +97,10 @@ class Settings(BaseSettings):
     def gemini_vision_enabled(self) -> bool:
         return bool(self.gemini_api_key.strip())
 
+    @property
+    def nvidia_vision_enabled(self) -> bool:
+        return bool(self.nvidia_api_key.strip())
+
     @property
     def local_whisper_enabled(self) -> bool:
         return self.whisper_backend == "local"

backend/app/logging_config.py

@@ -0,0 +1,115 @@
+"""Clean, colour-coded logging for the Cachy pipeline.
+
+Replaces Python's default ``INFO:logger.name:message`` format with:
+
+  11:42:03  INFO   worker       [card ab12] pipeline start · instagram
+  11:42:08  WARN   extraction   ffmpeg not found; skipping audio extraction
+
+Call ``configure_logging()`` once at startup. Safe to call multiple times
+(idempotent — replaces formatters rather than stacking handlers).
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+
+_RESET = "\033[0m"
+_DIM   = "\033[2m"
+_CYAN  = "\033[36m"
+
+_LEVEL_FMT: dict[int, tuple[str, str]] = {
+    logging.DEBUG:    ("DEBUG", "\033[90m"),
+    logging.INFO:     ("INFO ", "\033[32m"),
+    logging.WARNING:  ("WARN ", "\033[33m"),
+    logging.ERROR:    ("ERROR", "\033[31m"),
+    logging.CRITICAL: ("CRIT ", "\033[1;31m"),
+}
+
+# Third-party libraries whose INFO/DEBUG output is pure noise during development.
+_QUIET_LOGGERS = (
+    "yt_dlp",
+    "instaloader",
+    "httpx",
+    "httpcore",
+    "PIL",
+    "urllib3",
+    "faster_whisper",
+    "filelock",
+    "multipart",
+    "google.auth",
+    "google.api_core",
+    "asyncio",
+)
+
+
+class _PipelineFormatter(logging.Formatter):
+    """Single-line formatter: ``HH:MM:SS  LEVEL  logger_short  message``."""
+
+    def __init__(self, colours: bool) -> None:
+        super().__init__()
+        self._colours = colours
+
+    def _c(self, text: str, code: str) -> str:
+        return f"{code}{text}{_RESET}" if self._colours else text
+
+    def format(self, record: logging.LogRecord) -> str:
+        ts = self.formatTime(record, "%H:%M:%S")
+        label, colour = _LEVEL_FMT.get(record.levelno, ("?????", ""))
+
+        # Last dotted segment of the logger name, fixed-width for alignment.
+        short = record.name.rsplit(".", 1)[-1][:11].ljust(11)
+
+        msg = record.getMessage()
+        if record.exc_info and not record.exc_text:
+            record.exc_text = self.formatException(record.exc_info)
+        if record.exc_text:
+            msg = f"{msg}\n{record.exc_text}"
+        if record.stack_info:
+            msg = f"{msg}\n{self.formatStack(record.stack_info)}"
+
+        if self._colours:
+            return (
+                f"{self._c(ts, _DIM)}  "
+                f"{self._c(label, colour)}  "
+                f"{self._c(short, _CYAN)}  "
+                f"{msg}"
+            )
+        return f"{ts}  {label}  {short}  {msg}"
+
+
+def configure_logging() -> None:
+    """Apply the pipeline formatter and silence third-party noise.
+
+    Designed to be called both at module-import time (before uvicorn applies
+    its own config) and again inside the FastAPI lifespan (after uvicorn has
+    set up its handlers) so the format is always consistent.
+    """
+    colours = sys.stderr.isatty()
+    fmt = _PipelineFormatter(colours=colours)
+
+    # Root logger: add our handler if absent, or reformat existing ones.
+    root = logging.getLogger()
+    root.setLevel(logging.DEBUG)
+    if root.handlers:
+        for h in root.handlers:
+            h.setFormatter(fmt)
+            if h.level == logging.NOTSET:
+                h.setLevel(logging.INFO)
+    else:
+        h = logging.StreamHandler(sys.stderr)
+        h.setLevel(logging.INFO)
+        h.setFormatter(fmt)
+        root.addHandler(h)
+
+    # Override uvicorn's handlers so its startup/error messages look consistent.
+    for name in ("uvicorn", "uvicorn.error"):
+        for h in logging.getLogger(name).handlers:
+            h.setFormatter(fmt)
+
+    # Per-request access log is too noisy during development; silence it.
+    logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
+
+    # Silence chatty third-party libraries.
+    for name in _QUIET_LOGGERS:
+        logging.getLogger(name).setLevel(logging.WARNING)

backend/app/main.py

@@ -15,11 +15,13 @@ from fastapi.staticfiles import StaticFiles
 
 from app import discovery
 from app.api import cards, catalog, collections, concepts, graph, library_chat, search
+from app.logging_config import configure_logging
 from app.models.card import SCHEMA_VERSION
 from app.pipeline import worker
 from app.store import db, media
 
-logging.basicConfig(level=logging.INFO)
+# Apply at import time (catches logs before lifespan runs).
+configure_logging()
 log = logging.getLogger("app.main")
 
 _worker_task: asyncio.Task | None = None
@@ -28,6 +30,8 @@ _worker_task: asyncio.Task | None = None
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     global _worker_task
+    # Re-apply after uvicorn has configured its own handlers so our format wins.
+    configure_logging()
     await db.init_db()
     async with db.session() as s:
         reset_count = await db.reset_orphaned_processing_jobs(s)

backend/app/pipeline/extraction.py

@@ -76,12 +76,20 @@ def _extract_frames(video_path: str, frame_dir: str) -> list[str]:
     out_pattern = os.path.join(frame_dir, "frame_%03d.jpg")
     try:
         # scene-change selection; fall back to ~1 frame/2s via fps if no scenes hit.
-        subprocess.run(
+        # NOTE: exit code 234 from ffmpeg means the vf filter matched zero frames
+        # (common for short clips with no scene changes) — that is NOT an error.
+        # We run without check=True and only warn on genuinely unexpected codes.
+        result = subprocess.run(
             ["ffmpeg", "-y", "-i", video_path,
              "-vf", "select='gt(scene,0.3)',showinfo", "-vsync", "vfr",
              "-frames:v", "30", out_pattern],
-            check=True, capture_output=True, timeout=120,
+            capture_output=True, timeout=120,
         )
+        if result.returncode not in (0, 234):
+            log.debug(
+                "scene-frame extract exited %d; trying fps fallback",
+                result.returncode,
+            )
     except (subprocess.SubprocessError, OSError) as e:
         log.warning("scene-frame extract failed (%s); trying fps fallback", e)
     frames = _list_frames(frame_dir)
@@ -98,6 +106,7 @@ def _extract_frames(video_path: str, frame_dir: str) -> list[str]:
     return frames
 
 
+
 def _list_frames(frame_dir: str) -> list[str]:
     if not os.path.isdir(frame_dir):
         return []
@@ -112,6 +121,14 @@ def _list_frames(frame_dir: str) -> list[str]:
 # Frame dedup (perceptual hash)
 # --------------------------------------------------------------------------- #
 
+def _sample_frames(frames: list[str], n: int) -> list[str]:
+    """Return n evenly-spaced frames from the list (or all if len <= n)."""
+    if len(frames) <= n:
+        return frames
+    step = len(frames) / n
+    return [frames[int(i * step)] for i in range(n)]
+
+
 def _dedup_frames(frames: list[str]) -> list[str]:
     """Drop near-identical frames before OCR. Cheap perceptual-hash comparison."""
     try:
@@ -148,10 +165,13 @@ def _transcribe_local(audio_path: str) -> str:
         log.warning("faster-whisper not installed; skipping local transcription")
         return ""
     settings = get_settings()
+    log.info("transcribe: local whisper (%s) — may take a moment on CPU", settings.local_whisper_model)
     try:
         model = WhisperModel(settings.local_whisper_model, device="cpu", compute_type="int8")
         segments, _ = model.transcribe(audio_path, beam_size=1)
-        return " ".join(s.text for s in segments).strip()
+        result = " ".join(s.text for s in segments).strip()
+        log.info("transcribe: local whisper OK (%d chars)", len(result))
+        return result
     except Exception as e:
         log.warning("local whisper failed: %s", e)
         return ""
@@ -161,15 +181,29 @@ def _transcribe_groq(audio_path: str) -> str:
     settings = get_settings()
     if not settings.groq_enabled:
         return ""
+    log.info("transcribe: Groq Whisper (%s)", settings.groq_whisper_model)
     try:
         from groq import Groq
         client = Groq(api_key=settings.groq_api_key)
         with open(audio_path, "rb") as f:
+            audio_bytes = f.read()
+        # translations endpoint: auto-detects language and outputs English.
+        # For Hindi/non-English audio this is the key difference vs transcriptions.
+        try:
+            resp = client.audio.translations.create(
+                file=(os.path.basename(audio_path), audio_bytes),
+                model=settings.groq_whisper_model,
+            )
+        except Exception:
+            # Some Whisper model variants don't support translation; fall back.
+            import io
             resp = client.audio.transcriptions.create(
-                file=(os.path.basename(audio_path), f.read()),
+                file=(os.path.basename(audio_path), io.BytesIO(audio_bytes)),
                 model=settings.groq_whisper_model,
             )
-        return (getattr(resp, "text", "") or "").strip()
+        result = (getattr(resp, "text", "") or "").strip()
+        log.info("transcribe: Groq Whisper OK (%d chars)", len(result))
+        return result
     except Exception as e:
         log.warning("groq whisper failed: %s", e)
         return ""
@@ -185,7 +219,7 @@ def _transcribe(audio_path: str | None) -> str:
     result = _transcribe_groq(audio_path)
     if result:
         return result
-    # Groq failed (rate limit / no key) — try local as fallback
+    log.info("transcribe: Groq unavailable, falling back to local whisper")
     return _transcribe_local(audio_path)
 
 
@@ -247,44 +281,68 @@ def _ocr(frames: list[str]) -> str:
 # --------------------------------------------------------------------------- #
 
 _VISION_PROMPT = (
-    "This is one slide from a social-media carousel post. Transcribe ALL text "
-    "shown on it verbatim, preserving reading order, and briefly note any key "
-    "visual that carries meaning (chart, diagram, product, place). Output plain "
-    "text only — no preamble, no markdown, no commentary."
+    "These are slides from a social-media carousel post. For each slide shown, "
+    "transcribe ALL text verbatim in reading order and note any key visual that "
+    "carries meaning (chart, diagram, product, place). "
+    "Output plain text only — no preamble, no markdown, no commentary."
+)
+
+_VIDEO_VISION_PROMPT = (
+    "These are keyframes from a short-form social media video (Reel / TikTok / Short). "
+    "Describe what is shown across all frames in plain English: "
+    "(1) what the person is doing or demonstrating; "
+    "(2) all visible text — book/product titles, subtitles, on-screen overlays; "
+    "(3) any recognizable objects, books, products, or brands. "
+    "Output a concise combined summary. No preamble, no markdown."
 )
 
 _VISION_NO_TEXT = {"none", "no text", "no text shown"}
 
 
-def _vision_read_gemini(frames: list[str]) -> str:
-    """Gemini Flash Lite: 1M TPM / 1500 req/day free — primary vision backend."""
+def _vision_read_gemini(frames: list[str], prompt: str = _VISION_PROMPT) -> str:
+    """Gemini Flash Lite: single batched call with all frames — 1 API call instead of N."""
     settings = get_settings()
     if not frames or not settings.gemini_vision_enabled:
         return ""
     try:
-        import google.generativeai as genai
+        import io
+        from google import genai as google_genai
+        from google.genai import types as genai_types
         from PIL import Image
     except Exception:
         return ""
 
-    genai.configure(api_key=settings.gemini_api_key)
-    model = genai.GenerativeModel(settings.gemini_vision_model)
-    chunks: list[str] = []
-    for idx, path in enumerate(frames, 1):
-        try:
+    client = google_genai.Client(api_key=settings.gemini_api_key)
+    try:
+        contents: list = [prompt]
+        for path in frames:
             with Image.open(path) as img:
-                resp = model.generate_content([_VISION_PROMPT, img])
-            text = (resp.text or "").strip()
-        except Exception as e:
-            log.warning("gemini vision failed on slide %d: %s", idx, e)
-            continue
+                buf = io.BytesIO()
+                img.convert("RGB").save(buf, format="JPEG")
+            contents.append(
+                genai_types.Part.from_bytes(data=buf.getvalue(), mime_type="image/jpeg")
+            )
+        resp = client.models.generate_content(
+            model=settings.gemini_vision_model, contents=contents
+        )
+        text = (resp.text or "").strip()
         if text and text.lower() not in _VISION_NO_TEXT:
-            chunks.append(f"[slide {idx}] {text}")
-    return "\n".join(chunks)
+            return text
+        return ""
+    except Exception as e:
+        err_str = str(e)
+        if "429" in err_str or "RESOURCE_EXHAUSTED" in err_str or "quota" in err_str.lower():
+            log.warning("gemini vision: quota exhausted, handing off to Groq fallback")
+        else:
+            log.warning("gemini vision failed: %s", e)
+        return ""
+
+
+_GROQ_VISION_MAX_FRAMES = 5  # Llama-4-scout multi-image limit
 
 
-def _vision_read_groq(frames: list[str]) -> str:
-    """Groq VLM: 30k TPM free — fallback when Gemini unavailable/exhausted."""
+def _vision_read_groq(frames: list[str], prompt: str = _VISION_PROMPT) -> str:
+    """Groq VLM: single batched call (capped at 5 frames — model limit)."""
     settings = get_settings()
     if not frames or not settings.groq_vision_enabled:
         return ""
@@ -295,55 +353,123 @@ def _vision_read_groq(frames: list[str]) -> str:
         return ""
 
     client = Groq(api_key=settings.groq_api_key)
-    chunks: list[str] = []
-    for idx, path in enumerate(frames, 1):
-        try:
+    # Sample evenly across all frames so we get representative coverage even when capped.
+    batch = _sample_frames(frames, _GROQ_VISION_MAX_FRAMES)
+    try:
+        content: list = [{"type": "text", "text": prompt}]
+        for path in batch:
             with open(path, "rb") as f:
                 b64 = base64.b64encode(f.read()).decode()
             ext = os.path.splitext(path)[1].lstrip(".").lower() or "jpeg"
             if ext == "jpg":
                 ext = "jpeg"
-            resp = client.chat.completions.create(
-                model=settings.groq_vision_model,
-                messages=[{
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": _VISION_PROMPT},
-                        {"type": "image_url",
-                         "image_url": {"url": f"data:image/{ext};base64,{b64}"}},
-                    ],
-                }],
-                temperature=0.0,
-                max_tokens=512,
-            )
-            text = (resp.choices[0].message.content or "").strip() if resp.choices else ""
-        except Exception as e:
-            log.warning("groq vision failed on slide %d: %s", idx, e)
-            continue
+            content.append({
+                "type": "image_url",
+                "image_url": {"url": f"data:image/{ext};base64,{b64}"},
+            })
+        resp = client.chat.completions.create(
+            model=settings.groq_vision_model,
+            messages=[{"role": "user", "content": content}],
+            temperature=0.0,
+            max_tokens=1024,
+        )
+        text = (resp.choices[0].message.content or "").strip() if resp.choices else ""
         if text and text.lower() not in _VISION_NO_TEXT:
-            chunks.append(f"[slide {idx}] {text}")
-    return "\n".join(chunks)
+            return text
+        return ""
+    except Exception as e:
+        log.warning("groq vision failed: %s", e)
+        return ""
+
+
+def _vision_read_nvidia(frames: list[str], prompt: str = _VISION_PROMPT) -> str:
+    """NVLM-D-72B via NVIDIA API (OpenAI-compatible, free credits). Multi-image batch."""
+    settings = get_settings()
+    if not frames or not settings.nvidia_vision_enabled:
+        return ""
+    try:
+        import base64
+        import requests as _requests
+    except Exception:
+        return ""
+
+    content: list = [{"type": "text", "text": prompt}]
+    for path in frames:
+        with open(path, "rb") as f:
+            b64 = base64.b64encode(f.read()).decode()
+        ext = os.path.splitext(path)[1].lstrip(".").lower() or "jpeg"
+        if ext == "jpg":
+            ext = "jpeg"
+        content.append({
+            "type": "image_url",
+            "image_url": {"url": f"data:image/{ext};base64,{b64}"},
+        })
+    try:
+        resp = _requests.post(
+            "https://integrate.api.nvidia.com/v1/chat/completions",
+            headers={
+                "Authorization": f"Bearer {settings.nvidia_api_key}",
+                "Accept": "application/json",
+            },
+            json={
+                "model": settings.nvidia_vision_model,
+                "messages": [{"role": "user", "content": content}],
+                "max_tokens": 1024,
+                "temperature": 0.2,
+            },
+            timeout=60,
+        )
+        resp.raise_for_status()
+        text = (resp.json()["choices"][0]["message"]["content"] or "").strip()
+        if text and text.lower() not in _VISION_NO_TEXT:
+            return text
+        return ""
+    except Exception as e:
+        log.warning("nvidia vision failed: %s", e)
+        return ""
 
 
 def _vision_read(frames: list[str]) -> str:
-    """Cascade: Gemini → Groq → empty (caller falls back to Tesseract)."""
+    """Cascade: Gemini → NVLM (NVIDIA) → Groq → empty (caller falls back to Tesseract)."""
     result = _vision_read_gemini(frames)
+    if result:
+        return result
+    result = _vision_read_nvidia(frames)
     if result:
         return result
     return _vision_read_groq(frames)
 
 
+def _vision_read_video(frames: list[str]) -> str:
+    """VLM description of video keyframes: Gemini → NVLM → Groq."""
+    result = _vision_read_gemini(frames, prompt=_VIDEO_VISION_PROMPT)
+    if result:
+        return result
+    result = _vision_read_nvidia(frames, prompt=_VIDEO_VISION_PROMPT)
+    if result:
+        return result
+    return _vision_read_groq(frames, prompt=_VIDEO_VISION_PROMPT)
+
+
 # --------------------------------------------------------------------------- #
 # Aggregate
 # --------------------------------------------------------------------------- #
 
-def _aggregate(caption: str, transcript: str, ocr_text: str, source_line: str) -> str:
+def _aggregate(
+    caption: str,
+    transcript: str,
+    ocr_text: str,
+    source_line: str,
+    visual_context: str = "",
+) -> str:
     parts = [
         f"CAPTION: {caption.strip()}" if caption.strip() else "CAPTION:",
         f"TRANSCRIPT: {transcript.strip()}" if transcript.strip() else "TRANSCRIPT:",
         f"ON-SCREEN TEXT: {ocr_text.strip()}" if ocr_text.strip() else "ON-SCREEN TEXT:",
-        f"SOURCE: {source_line}",
     ]
+    if visual_context.strip():
+        parts.append(f"VISUAL CONTEXT (FRAME DESCRIPTIONS):\n{visual_context.strip()}")
+    parts.append(f"SOURCE PLATFORM: {source_line}")
     return "\n".join(parts)
 
 
@@ -359,7 +485,7 @@ def _aggregate_article(
     ]
     if ocr_text.strip():
         parts.append(f"ATTACHED VISUAL CONTENT / ON-SCREEN TEXT:\n{ocr_text.strip()}")
-    parts.append(f"SOURCE: {source_line}")
+    parts.append(f"SOURCE PLATFORM: {source_line}")
     return "\n".join(parts)
 
 
@@ -451,6 +577,7 @@ def extract(
     # Carousel slides are stylized text-as-image; Tesseract reads them poorly
     # (docs/03 step 5), so prefer the free Groq VLM, falling back to OCR.
     had_visual = False
+    visual_context = ""
     if is_carousel and settings.groq_vision_enabled:
         ocr_text = _vision_read(frames)
         if ocr_text.strip():
@@ -459,10 +586,16 @@ def extract(
             ocr_text = _ocr(frames)
     else:
         ocr_text = _ocr(frames)
+        # For videos, also run VLM on keyframes to capture what's visually shown
+        # (book/product names, on-screen text, speaker context) — Tesseract misses all of this.
+        if frames and (settings.gemini_vision_enabled or settings.groq_vision_enabled):
+            visual_context = _vision_read_video(frames)
+            if visual_context.strip():
+                had_visual = True
 
     thumbnail = frames[0] if frames else None
 
-    aggregated = _aggregate(download.caption or "", transcript, ocr_text, source_line)
+    aggregated = _aggregate(download.caption or "", transcript, ocr_text, source_line, visual_context)
 
     return ExtractionResult(
         aggregated_text=aggregated,

backend/app/pipeline/structuring.py

@@ -176,8 +176,7 @@ Rules for blocks (MOST IMPORTANT):
 
 Other rules:
 - base.one_liner and base.tldr MUST always be non-empty.
-- base.tags: 3-6 short, lowercase, topical keywords.
-- artifacts: include ONLY concrete, named, real-world things the video names. Do NOT invent any.
+- artifacts: include ONLY concrete, named, real-world things the video names (books, tools, products). Do NOT include social media hosting platforms (Instagram, TikTok) or downloading scrapers.
 - Inline references: wrap artifact names and concept names in [[double brackets]] the FIRST time they appear in prose.
 - action_items: concrete doable tasks the video tells the viewer to take. Short imperative phrases, max ~8.
 - depth: "deep" for idea-rich, knowledge-heavy, or argumentative content. "shallow" for procedural/lightweight.
@@ -197,19 +196,20 @@ Extracted text bundle:
 # Bundle preprocessor (Gemini Flash Lite — separate quota pool)
 # --------------------------------------------------------------------------- #
 
-_PREPROCESS_PROMPT = """You clean a noisy text bundle extracted from a short-form video \
+_PREPROCESS_PROMPT = """You clean and prepare a noisy text bundle extracted from a short-form video \
 (caption + audio transcript + on-screen/slide text) before it is turned into a detailed knowledge note.
 
-Your job is ONLY to remove noise, never to reduce information density.
+Your job: remove noise AND translate non-English text to English. Never reduce information density.
 
 Do ONLY this:
+- If the TRANSCRIPT is in a non-English language, translate it fully to English in-place, preserving ALL content, names, examples, and meaning. Update the section label to: "TRANSCRIPT (translated from [Language]):". Keep every detail from the original — do not summarize.
 - Remove EXACT duplicates across channels (e.g. on-screen text word-for-word repeating the transcript). If in doubt, KEEP BOTH.
 - Remove pure engagement bait with zero informational value ("like and subscribe", "link in bio", "follow for more").
 - Remove spoken filler with zero content ("um", "uh", "you know", "so basically").
 - NEVER remove or merge: names, numbers, steps, tips, tools, apps, products, prices, quantities, quotes, claims, or explanations — even partial ones.
 - NEVER summarize, paraphrase, reorder, or shorten any real information.
 - NEVER drop a sentence just because it seems redundant to you — the structuring model will judge relevance.
-- Keep the CAPTION / TRANSCRIPT / ON-SCREEN TEXT / SOURCE section labels and structure intact.
+- Keep the CAPTION / TRANSCRIPT / ON-SCREEN TEXT / VISUAL CONTEXT / SOURCE PLATFORM section labels and structure intact.
 - Output ONLY the cleaned bundle text — no preamble, no explanation, no markdown.
 
 If you are unsure whether something is noise or content, KEEP IT.
@@ -229,19 +229,25 @@ def _preprocess_bundle(bundle: str) -> str:
     settings = get_settings()
     if not settings.gemini_preprocess_enabled:
         return bundle
+    log.info("preprocess: cleaning bundle with Gemini (%s)", settings.gemini_preprocess_model)
     try:
-        import google.generativeai as genai
+        from google import genai as google_genai
 
-        genai.configure(api_key=settings.gemini_api_key)
-        model = genai.GenerativeModel(settings.gemini_preprocess_model)
-        resp = model.generate_content(_PREPROCESS_PROMPT.format(bundle=bundle))
+        client = google_genai.Client(api_key=settings.gemini_api_key)
+        resp = client.models.generate_content(
+            model=settings.gemini_preprocess_model,
+            contents=_PREPROCESS_PROMPT.format(bundle=bundle),
+        )
         cleaned = (resp.text or "").strip()
+        if cleaned:
+            log.info("preprocess: done (%d → %d chars)", len(bundle), len(cleaned))
         return cleaned or bundle
     except Exception as e:
         log.warning("bundle preprocess (gemini) failed: %s; using raw bundle", e)
         return bundle
 
 
+
 # --------------------------------------------------------------------------- #
 # LLM call (Cerebras primary -> Groq fallback)
 # --------------------------------------------------------------------------- #
@@ -269,6 +275,7 @@ def _call_llm(bundle: str) -> str | None:
 
 def _call_cerebras(prompt: str, max_tokens: int, temperature: float) -> str | None:
     settings = get_settings()
+    log.info("llm: calling Cerebras (%s)", settings.cerebras_llm_model)
     try:
         from cerebras.cloud.sdk import Cerebras
 
@@ -280,7 +287,10 @@ def _call_cerebras(prompt: str, max_tokens: int, temperature: float) -> str | No
             max_tokens=max_tokens,
         )
         text = resp.choices[0].message.content if resp.choices else ""
-        return (text or "").strip()
+        result = (text or "").strip()
+        if result:
+            log.info("llm: Cerebras OK (%d chars)", len(result))
+        return result
     except Exception as e:
         log.warning("llm call (cerebras) failed: %s", e)
         return None
@@ -288,6 +298,7 @@ def _call_cerebras(prompt: str, max_tokens: int, temperature: float) -> str | No
 
 def _call_groq(prompt: str, max_tokens: int, temperature: float) -> str | None:
     settings = get_settings()
+    log.info("llm: calling Groq (%s)", settings.groq_llm_model)
     try:
         from groq import Groq
 
@@ -299,7 +310,10 @@ def _call_groq(prompt: str, max_tokens: int, temperature: float) -> str | None:
             max_tokens=max_tokens,  # rich carousels (e.g. 140-item lists) overflow a smaller cap
         )
         text = resp.choices[0].message.content if resp.choices else ""
-        return (text or "").strip()
+        result = (text or "").strip()
+        if result:
+            log.info("llm: Groq OK (%d chars)", len(result))
+        return result
     except Exception as e:
         log.warning("llm call (groq) failed: %s", e)
         return None

backend/app/pipeline/worker.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 import asyncio
 import logging
 from datetime import datetime, timezone
+from typing import Any
 
 from sqlalchemy import or_, select, update
 
@@ -157,14 +158,23 @@ async def _write_media_and_meta(
     await session.commit()
 
 
-async def _persist_artifacts(session, card_id: str, artifacts) -> None:
-    """Aggregate referenced things into the global catalog (docs/12). Each lookup
-    is best-effort and isolated — a failure here never affects the card itself."""
-    for art in artifacts:
+async def _persist_artifacts(session: Any, card_id: str, artifacts: list[Any]) -> None:
+    """Aggregate referenced things into the global catalog (docs/12). Thumbnail
+    lookups run in parallel — each is best-effort and never blocks the card."""
+    async def _resolve_thumb(art: Any) -> tuple[Any, str | None]:
         try:
             thumbnail = await asyncio.to_thread(
                 artifact_images.resolve_thumbnail, art
             )
+            return art, thumbnail
+        except Exception as e:
+            log.warning("thumbnail lookup failed for %r: %s", art.title, str(e), exc_info=True)
+            return art, None
+
+    resolved = await asyncio.gather(*(_resolve_thumb(art) for art in artifacts))
+
+    for art, thumbnail in resolved:
+        try:
             await db.upsert_artifact(
                 session,
                 card_id=card_id,
@@ -174,21 +184,23 @@ async def _persist_artifacts(session, card_id: str, artifacts) -> None:
                 year=art.year,
                 thumbnail=thumbnail,
             )
-        except Exception:  # noqa: BLE001 — catalog is non-critical to the card
-            log.warning("catalog upsert failed for %r", art.title, exc_info=True)
+        except Exception as e:  # noqa: BLE001 — catalog is non-critical to the card
+            await session.rollback()
+            log.warning("catalog upsert failed for %r: %s", art.title, str(e), exc_info=True)
 
 
-async def _persist_concepts(session, card_id: str, concepts: list[str]) -> None:
+async def _persist_concepts(session: Any, card_id: str, concepts: list[str]) -> None:
     """Aggregate evergreen ideas into the global concept store. Best-effort and
     isolated — a failure here never affects the card itself."""
     for name in concepts:
         try:
             await db.upsert_concept(session, card_id=card_id, name=name)
-        except Exception:  # noqa: BLE001 — concepts are non-critical to the card
-            log.warning("concept upsert failed for %r", name, exc_info=True)
+        except Exception as e:  # noqa: BLE001 — concepts are non-critical to the card
+            await session.rollback()
+            log.warning("concept upsert failed for %r: %s", name, str(e), exc_info=True)
 
 
-async def _embed_card(session, card_id: str) -> None:
+async def _embed_card(session: Any, card_id: str) -> None:
     """Compute + store a semantic-search embedding for the card (docs/09).
     Best-effort and isolated: any failure (no HF key, network) leaves the card
     embedding-less, and search degrades to full-text. Reuses the same flattened
@@ -288,7 +300,7 @@ async def _run_job(session, job: db.JobRow) -> None:
     events.publish(card_id, "extracting", "processing", "Extracting audio + frames")
     log.info("%s Step 2/6 extract: transcript + on-screen text from media", tag)
     work_dir = media.job_dir_for_card(card_id)
-    source_line = f"{platform or 'unknown'} / {download.resolver}"
+    source_line = platform.title() if platform else "Short-form video"
     extraction = await extract_async(download, work_dir, source_line)
     log.info(
         "%s Step 2/6 extract OK | frames=%d transcript=%s ocr=%s vision=%s",
@@ -373,8 +385,9 @@ async def _run_job(session, job: db.JobRow) -> None:
                     })
             else:
                 log.info("%s Step 4b deep-analysis: no usable layer produced", tag)
-        except Exception:  # noqa: BLE001 — insight is non-critical to the card
-            log.warning("%s Step 4b deep-analysis failed", tag, exc_info=True)
+        except Exception as e:  # noqa: BLE001 — insight is non-critical to the card
+            await session.rollback()
+            log.warning("%s Step 4b deep-analysis failed: %s", tag, str(e), exc_info=True)
     else:
         log.info("%s Step 4b deep-analysis: depth=shallow, skipping", tag)
 
@@ -399,9 +412,10 @@ async def _run_job(session, job: db.JobRow) -> None:
     log.info("%s Step 6/6 index: embedding card for semantic search", tag)
     try:
         await _embed_card(session, card_id)
-    except Exception:  # noqa: BLE001 — semantic index is non-critical to the card
+    except Exception as e:  # noqa: BLE001 — semantic index is non-critical to the card
+        await session.rollback()
         log.warning("%s Step 6/6 index: embedding failed (search degrades to "
-                    "full-text)", tag, exc_info=True)
+                    "full-text): %s", tag, str(e), exc_info=True)
 
     # Optionally discard the source video, keep keyframes+thumbnail (docs/11)
     if get_settings().discard_source_video and download.media_type == "video":
@@ -428,20 +442,24 @@ async def run_worker_loop() -> None:
                 if job is None:
                     await asyncio.sleep(settings.worker_poll_seconds)
                     continue
+                job_id = job.id
+                card_id = job.card_id
                 try:
                     await asyncio.wait_for(
                         _run_job(session, job),
                         timeout=settings.job_timeout_seconds,
                     )
-                except asyncio.TimeoutError:
+                except asyncio.TimeoutError as e:
+                    await session.rollback()
                     await _fail(
-                        session, job.card_id, job, FailureReason.TIMEOUT, "job timed out"
+                        session, card_id, job, FailureReason.TIMEOUT, f"job timed out: {e}"
                     )
-                    events.publish(job.card_id, "failed", "failed", "Timed out",
+                    events.publish(card_id, "failed", "failed", "Timed out",
                                    FailureReason.TIMEOUT.value)
                 except Exception as e:  # noqa: BLE001 — pipeline must never crash the loop
-                    log.exception("job %s failed", job.id)
-                    await _fail(session, job.card_id, job, FailureReason.UNAVAILABLE, str(e))
+                    await session.rollback()
+                    log.exception("job %s failed: %s", job_id, str(e))
+                    await _fail(session, card_id, job, FailureReason.UNAVAILABLE, str(e))
         except Exception:  # noqa: BLE001
             log.exception("worker loop iteration error")
             await asyncio.sleep(settings.worker_poll_seconds)

backend/app/services/artifact_images.py

@@ -23,7 +23,15 @@ from app.models.artifact import Artifact, ArtifactType
 log = logging.getLogger("services.artifact_images")
 
 _TIMEOUT = httpx.Timeout(8.0)
-_HEADERS = {"User-Agent": "Cachy/0.1 (catalog thumbnail lookup)"}
+# Wikimedia policy requires a descriptive User-Agent with a contact URL/email.
+# Without this, their API returns 403. See: https://meta.wikimedia.org/wiki/User-Agent_policy
+_HEADERS = {
+    "User-Agent": (
+        "Cachy/1.0 (personal knowledge library; "
+        "https://github.com/Vatsal057/Cachy) httpx/python"
+    )
+}
+
 
 # iTunes Search `entity` per artifact type (covers most media).
 _ITUNES_ENTITY: dict[ArtifactType, str] = {
@@ -43,21 +51,28 @@ def resolve_thumbnail(artifact: Artifact) -> str | None:
                 _from_open_library(artifact)
                 or _from_google_books(artifact)
                 or _from_wikipedia(artifact)
+                or _from_wikimedia_commons(artifact)
             )
         if artifact.type == ArtifactType.MUSIC:
             return (
                 _from_itunes(artifact)
                 or _from_musicbrainz(artifact)
                 or _from_wikipedia(artifact)
+                or _from_wikimedia_commons(artifact)
             )
         if artifact.type in _ITUNES_ENTITY:
             return (
                 _from_itunes(artifact)
                 or _from_wikidata(artifact)
                 or _from_wikipedia(artifact)
+                or _from_wikimedia_commons(artifact)
             )
-        # product / place / other
-        return _from_wikidata(artifact) or _from_wikipedia(artifact)
+        # product / place / other / software / web
+        return (
+            _from_wikidata(artifact)
+            or _from_wikipedia(artifact)
+            or _from_wikimedia_commons(artifact)
+        )
     except Exception as e:  # noqa: BLE001 — thumbnail lookup must never break a card
         log.info("thumbnail lookup failed for %r: %s", artifact.title, e)
         return None
@@ -70,20 +85,38 @@ def _query(artifact: Artifact) -> str:
     return " ".join(parts)
 
 
+def _queries(artifact: Artifact) -> list[str]:
+    qs = []
+    full = _query(artifact)
+    qs.append(full)
+    if artifact.creator and artifact.title != full:
+        qs.append(artifact.title)
+    return qs
+
+
+def _words_overlap(query: str, title: str) -> bool:
+    """Return True if at least one significant word (>3 chars) from the query
+    appears in the matched Wikipedia article title (case-insensitive).
+    Prevents clearly wrong fuzzy matches (e.g. 'SkyKit Learn' -> 'A Discovery of Witches').
+    """
+    q_words = {w.lower() for w in query.split() if len(w) > 3}
+    t_lower = title.lower()
+    return any(w in t_lower for w in q_words)
+
+
 def _from_itunes(artifact: Artifact) -> str | None:
     entity = _ITUNES_ENTITY[artifact.type]
-    params = {"term": _query(artifact), "entity": entity, "limit": 1}
-    with httpx.Client(timeout=_TIMEOUT, headers=_HEADERS) as client:
-        resp = client.get("https://itunes.apple.com/search", params=params)
-        resp.raise_for_status()
-        results = resp.json().get("results") or []
-    if not results:
-        return None
-    art = results[0].get("artworkUrl100")
-    if not art:
-        return None
-    # Upscale the 100px thumbnail iTunes returns to a crisper catalog cover.
-    return art.replace("100x100bb", "400x400bb")
+    for query in _queries(artifact):
+        params = {"term": query, "entity": entity, "limit": 1}
+        with httpx.Client(timeout=_TIMEOUT, headers=_HEADERS) as client:
+            resp = client.get("https://itunes.apple.com/search", params=params)
+            resp.raise_for_status()
+            results = resp.json().get("results") or []
+        if results:
+            art = results[0].get("artworkUrl100")
+            if art:
+                return art.replace("100x100bb", "400x400bb")
+    return None
 
 
 def _from_open_library(artifact: Artifact) -> str | None:
@@ -106,17 +139,74 @@ def _from_open_library(artifact: Artifact) -> str | None:
 
 
 def _from_wikipedia(artifact: Artifact) -> str | None:
-    title = quote(artifact.title.replace(" ", "_"))
-    url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{title}"
-    with httpx.Client(
-        timeout=_TIMEOUT, headers=_HEADERS, follow_redirects=True
-    ) as client:
-        resp = client.get(url)
-        if resp.status_code != 200:
-            return None
-        data = resp.json()
-    thumb = data.get("thumbnail") or {}
-    return thumb.get("source")
+    """Two-step fuzzy lookup: search Wikipedia first (handles typos/alt names),
+    then fetch the summary of the best match to get its thumbnail."""
+    for query in _queries(artifact):
+        with httpx.Client(timeout=_TIMEOUT, headers=_HEADERS) as client:
+            search_resp = client.get(
+                "https://en.wikipedia.org/w/api.php",
+                params={
+                    "action": "query",
+                    "list": "search",
+                    "srsearch": query,
+                    "format": "json",
+                    "srlimit": 1,
+                    "srprop": "",
+                },
+            )
+            if search_resp.status_code != 200:
+                continue
+            hits = search_resp.json().get("query", {}).get("search", [])
+        if not hits:
+            continue
+        matched_title = hits[0]["title"]
+        if not _words_overlap(query, matched_title):
+            continue
+        page_title = quote(matched_title.replace(" ", "_"))
+        with httpx.Client(
+            timeout=_TIMEOUT, headers=_HEADERS, follow_redirects=True
+        ) as client:
+            summary_resp = client.get(
+                f"https://en.wikipedia.org/api/rest_v1/page/summary/{page_title}"
+            )
+            if summary_resp.status_code == 200:
+                thumb = summary_resp.json().get("thumbnail") or {}
+                source = thumb.get("source")
+                if source:
+                    return source
+    return None
+
+
+def _from_wikimedia_commons(artifact: Artifact) -> str | None:
+    """Search Wikimedia Commons directly for logos or icons."""
+    for query in _queries(artifact):
+        search_q = f"{query} logo"
+        with httpx.Client(timeout=_TIMEOUT, headers=_HEADERS) as client:
+            resp = client.get(
+                "https://commons.wikimedia.org/w/api.php",
+                params={
+                    "action": "query",
+                    "list": "search",
+                    "srsearch": search_q,
+                    "format": "json",
+                    "srnamespace": 6,
+                    "srlimit": 1,
+                },
+            )
+            if resp.status_code != 200:
+                continue
+            hits = resp.json().get("query", {}).get("search", [])
+        if not hits:
+            continue
+        matched_title = hits[0]["title"]
+        if not _words_overlap(query, matched_title):
+            continue
+        filename = matched_title.replace("File:", "").strip()
+        encoded = filename.replace(" ", "_")
+        return f"https://commons.wikimedia.org/wiki/Special:FilePath/{encoded}?width=400"
+    return None
+
+
 
 
 def _from_google_books(artifact: Artifact) -> str | None:
@@ -162,32 +252,54 @@ def _from_musicbrainz(artifact: Artifact) -> str | None:
 
 
 def _from_wikidata(artifact: Artifact) -> str | None:
-    search_params = {
-        "action": "wbsearchentities",
-        "search": _query(artifact),
-        "language": "en",
-        "format": "json",
-        "limit": 1,
-    }
-    with httpx.Client(timeout=_TIMEOUT, headers=_HEADERS) as client:
-        resp = client.get("https://www.wikidata.org/w/api.php", params=search_params)
-        resp.raise_for_status()
-        results = resp.json().get("search") or []
+    results = []
+    for query in _queries(artifact):
+        search_params = {
+            "action": "wbsearchentities",
+            "search": query,
+            "language": "en",
+            "format": "json",
+            "limit": 3,
+        }
+        with httpx.Client(timeout=_TIMEOUT, headers=_HEADERS) as client:
+            resp = client.get("https://www.wikidata.org/w/api.php", params=search_params)
+            resp.raise_for_status()
+            results = resp.json().get("search") or []
+        if results:
+            break
     if not results:
         return None
-    qid = results[0].get("id")
-    if not qid:
-        return None
+
+    best_fallback = None
     with httpx.Client(timeout=_TIMEOUT, headers=_HEADERS) as client:
-        entity_resp = client.get(f"https://www.wikidata.org/wiki/Special:EntityData/{qid}.json")
-        entity_resp.raise_for_status()
-        entities = entity_resp.json().get("entities", {})
-    claims = entities.get(qid, {}).get("claims", {})
-    p18 = claims.get("P18", [])  # P18 = image
-    if not p18:
-        return None
-    filename = p18[0].get("mainsnak", {}).get("datavalue", {}).get("value")
-    if not filename:
-        return None
-    encoded = filename.replace(" ", "_")
-    return f"https://commons.wikimedia.org/wiki/Special:FilePath/{encoded}?width=400"
+        for hit in results[:3]:
+            qid = hit.get("id")
+            if not qid:
+                continue
+            try:
+                entity_resp = client.get(f"https://www.wikidata.org/wiki/Special:EntityData/{qid}.json")
+                entity_resp.raise_for_status()
+                entities = entity_resp.json().get("entities", {})
+            except Exception:
+                continue
+            claims = entities.get(qid, {}).get("claims", {})
+            for prop in ("P154", "P18"):
+                entries = claims.get(prop, [])
+                if entries:
+                    filename = entries[0].get("mainsnak", {}).get("datavalue", {}).get("value")
+                    if filename:
+                        encoded = filename.replace(" ", "_")
+                        url = f"https://commons.wikimedia.org/wiki/Special:FilePath/{encoded}?width=400"
+                        if prop == "P154":
+                            return url
+                        if not best_fallback:
+                            best_fallback = url
+            p856 = claims.get("P856", [])
+            if p856:
+                website_url = p856[0].get("mainsnak", {}).get("datavalue", {}).get("value")
+                if website_url:
+                    from urllib.parse import urlparse
+                    domain = urlparse(website_url).netloc
+                    if domain:
+                        return f"https://www.google.com/s2/favicons?domain={domain}&sz=256"
+    return best_fallback

backend/tests/conftest.py

@@ -18,6 +18,8 @@ os.environ["MEDIA_DIR"] = f"{_TMP}/media"
 os.environ["LLM_BACKEND"] = "none"
 os.environ["HF_API_KEY"] = ""
 os.environ["GROQ_API_KEY"] = ""
+os.environ["CEREBRAS_API_KEY"] = ""
+os.environ["GEMINI_API_KEY"] = ""
 os.environ["WHISPER_BACKEND"] = "none"
 os.environ["MAX_ATTEMPTS"] = "2"
 

backend/tests/test_pipeline.py

@@ -5,6 +5,7 @@ import os
 
 import pytest
 
+from app.models.artifact import Artifact, ArtifactType
 from app.models.card import CardState
 from app.models.job import JobState
 from app.pipeline import worker
@@ -159,3 +160,45 @@ async def test_preserve_custom_collection(database, stub_pipeline):
         col = await s.get(db.CollectionRow, row.collection_id)
         assert col.name == "My Custom Folder"
 
+
+async def test_persist_artifacts_sequential_and_rollback(database, monkeypatch):
+    """Verify that multiple artifacts resolve thumbnails in parallel but upsert
+    sequentially, and any individual failure triggers session rollback so the
+    session remains valid for subsequent operations."""
+    card_id, _ = await _make_card_and_job("https://instagram.com/reel/artifacts_test")
+    artifacts = [
+        Artifact(type=ArtifactType.BOOK, title=f"Book {i}") for i in range(5)
+    ]
+
+    def fake_thumb(art):
+        return f"https://img/{art.title}.jpg"
+
+    monkeypatch.setattr(worker.artifact_images, "resolve_thumbnail", fake_thumb)
+
+    orig_upsert = db.upsert_artifact
+
+    async def flaky_upsert(session, **kwargs):
+        if kwargs["title"] == "Book 2":
+            raise RuntimeError("simulated DB constraint failure")
+        return await orig_upsert(session, **kwargs)
+
+    monkeypatch.setattr(db, "upsert_artifact", flaky_upsert)
+
+    async with db.session() as s:
+        await worker._persist_artifacts(s, card_id, artifacts)
+        # Session must still be usable (not in PendingRollbackError state)
+        row = await db.get_card_row(s, card_id)
+        assert row is not None
+
+    async with db.session() as s:
+        from sqlalchemy import select
+        res = await s.execute(select(db.ArtifactRow).order_by(db.ArtifactRow.title))
+        rows = res.scalars().all()
+        titles = [r.title for r in rows]
+        assert "Book 0" in titles
+        assert "Book 1" in titles
+        assert "Book 2" not in titles
+        assert "Book 3" in titles
+        assert "Book 4" in titles
+
+