refactor: reformat tg_filter.py and clean up

- Add video_notes table and agent_queue table for persistent notes and AI agent tasks
- Add API endpoints: POST/GET /api/notes/{id}, POST /api/notes/migrate, agent queue endpoints
- Rebuild frontend: fix duplicate loadVideos(), non-blocking localStorage migration, notes UI
- Switch pip install to Tsinghua mirror for faster downloads in China
- Add backend/sync_rotation.json to .gitignore (runtime state)

.gitea/workflows/deploy.yml

@@ -0,0 +1,47 @@
+name: Deploy t-youtube
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'backend/**'
+      - 'frontend/**'
+      - 'Dockerfile'
+      - '.gitea/workflows/deploy.yml'
+  workflow_dispatch:
+
+jobs:
+  build-and-deploy:
+    name: Build & Deploy
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        run: |
+          git clone --depth=1 http://gitea:3000/jimmy/t-youtube.git /volume1/docker/t-youtube-build 2>&1
+
+      - name: Build Docker image
+        run: |
+          export DOCKER_API_VERSION=1.43
+          docker build -t t-youtube:latest /volume1/docker/t-youtube-build 2>&1
+
+      - name: Save & Load image on host
+        run: |
+          export DOCKER_API_VERSION=1.43
+          docker save t-youtube:latest | /volume1/@appstore/ContainerManager/usr/bin/docker load 2>&1
+
+      - name: Swap container on host
+        run: |
+          /volume1/@appstore/ContainerManager/usr/bin/docker stop t-youtube 2>/dev/null || true
+          /volume1/@appstore/ContainerManager/usr/bin/docker rm t-youtube 2>/dev/null || true
+          /volume1/@appstore/ContainerManager/usr/bin/docker run -d --name t-youtube --restart unless-stopped \
+            -p 8001:8000 \
+            --env-file /volume1/docker/t-youtube/.env \
+            -v /volume1/docker/t-youtube/data:/app/data \
+            -v /volume1/docker/t-youtube/config:/app/config \
+            t-youtube:latest 2>&1
+
+      - name: Verify
+        run: |
+          export DOCKER_API_VERSION=1.43
+          sleep 3
+          docker ps --filter name=t-youtube --format "{{.Status}}"
+          echo "OK: deploy complete"

.gitignore

@@ -22,3 +22,5 @@ config/cookies.txt
 token.pickle
 config/client_secret.json
 config/token.pickle
+backend/sync_rotation.json
+._*

CLAUDE.md

@@ -0,0 +1,38 @@
+# T YouTube — Text-Based YouTube Digest
+
+## PDD Workflow
+
+This project follows **PDD (Product Definition Document)** development.
+
+**Always read these files before writing code:**
+- `docs/PDD.md` — product vision, goals, targets (the north star)
+- `docs/specs/active.md` — current sprint spec (what we're building now)
+
+**Workflow:**
+1. PDD → Sprint Spec → Implementation → Validate ACs
+2. Scope changes update the sprint spec first, code second
+3. Never ship without ACs passing
+
+## Dev Commands
+
+- **Build:** `docker compose up -d --build`
+- **Test:** `./run_tests.sh`
+- **Run locally:** `uvicorn backend.main:app --reload` (backend) + `npm run dev` (frontend)
+- **Sync subscriptions:** `python run_sync.py`
+
+## Architecture
+
+- **Frontend:** Svelte 5 + Vite (`frontend/`)
+- **Backend:** FastAPI + SQLite (`backend/`)
+- **Deployment:** Docker container on NAS DS224+, port 8001
+- **Sync:** `run_sync.py` fetches YouTube subscriptions + transcripts via yt-dlp
+- **Auth:** Authelia SSO in front, cookie-based session
+- **Proxy:** YouTube blocked from China — sync runs via VPS (Oracle Tokyo) or proxy
+
+## Key Files
+
+- `docs/architecture.md` — full architecture reference
+- `Dockerfile` — multi-stage build (node → python)
+- `docker-compose.yml` — deployment config
+- `run_sync.py` — subscription sync entry point
+- `config/cookies.txt` — YouTube auth cookies (not committed)

Dockerfile

@@ -13,16 +13,12 @@ WORKDIR /app
 # Install system dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends \
     curl \
-    ffmpeg \
     && rm -rf /var/lib/apt/lists/*
 
-# Download latest official yt-dlp to ensure subscription scrapers do not break
-RUN curl -L https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp -o /usr/local/bin/yt-dlp && \
-    chmod a+rx /usr/local/bin/yt-dlp
 
 # Install python packages
 COPY backend/requirements.txt ./
-RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt
 
 # Copy built static frontend
 COPY --from=frontend-builder /app/frontend/dist ./frontend/dist

README.md

@@ -63,4 +63,44 @@ t-youtube/
     *   **Key Takeaways (Bullet list)**
     *   **Actionable Verdict**
 3.  **Read/Skip State**: Mark videos as **Read** or **Skip** to clear them from your pending queue, allowing you to only keep track of what's unread.
-4.  **View Full Transcript**: Expand the accordion at the bottom of the digest to read the raw transcripts if needed.
+4. **View Full Transcript**: Expand the accordion at the bottom of the digest to read the raw transcripts if needed.
+5. **Agent Queue**: Save videos with notes to a queue for Hermes agents to process (create skills, open issues, etc.)
+
+---
+
+## 📚 Documentation
+
+Comprehensive documentation for this project is available in the `docs/` folder:
+
+- **[Architecture](docs/architecture.md)** - System overview, components, API endpoints, database schema
+- **[Progress](docs/progress.md)** - Session history, completed tasks, planned features, metrics
+- **[Configuration](docs/configuration.md)** - Environment variables, API tokens, database, Authelia, Caddy setup
+- **[Troubleshooting](docs/troubleshooting.md)** - Common issues, recovery procedures, monitoring
+
+---
+
+## 🚀 Setup Instructions
+
+### 1. Extract your YouTube browser cookies
+Since YouTube restricts subscription feeds to logged-in users, you need to export your logged-in cookies so `yt-dlp` can request the feed on your behalf:
+1. Install a browser extension like **Get cookies.txt LOCALLY** (Chrome/Edge) or **cookies.txt** (Firefox).
+2. Open YouTube in your browser and ensure you are logged in to your account.
+3. Click the extension icon and export the cookies for `youtube.com` as a Netscape-formatted text file.
+4. Create a folder named `config` in your project root, rename the exported file to `cookies.txt`, and save it inside:
+   ```text
+   t-youtube/config/cookies.txt
+   ```
+
+### 2. Configure Environment Variables
+Create a `.env` file in the root directory:
+```env
+# Optional: Override the fallback OpenAI / Anthropic key
+OPENAI_API_KEY=sk-Kq5...rOlx
+```
+
+### 3. Build & Deploy using Docker Compose
+Run the following command to build the multi-stage image (compiles frontend static assets using Node, then packages backend with Python) and start the container:
+```bash
+docker compose up -d --build
+```
+The server will boot up and listen on port `8000`.

backend/agent_worker.py

@@ -0,0 +1,166 @@
+"""
+Agent Queue Worker — polls agent_queue for pending items and
+processes them against the local Qwen27B API (:8080).
+"""
+import asyncio
+import json
+import logging
+import os
+import aiosqlite
+import httpx
+
+import db
+
+log = logging.getLogger(__name__)
+
+QWEN_BASE_URL = os.environ.get("QWEN_BASE_URL", "http://localhost:8080")
+QWEN_MODEL = os.environ.get("QWEN_MODEL", "current")
+POLL_INTERVAL = int(os.environ.get("AGENT_POLL_INTERVAL", "30"))
+MAX_CONCURRENT = int(os.environ.get("AGENT_MAX_CONCURRENT", "3"))
+SYSTEM_PROMPT = os.environ.get(
+    "AGENT_SYSTEM_PROMPT",
+    "You are a helpful AI assistant. The user has watched a YouTube video and "
+    "left you instructions. Read the video info below and respond to their "
+    "prompt. Be concise and actionable."
+)
+
+semaphore = asyncio.Semaphore(MAX_CONCURRENT)
+
+
+async def _call_qwen(prompt: str, video_title: str, video_context: str) -> str:
+    """Call the local Qwen27B API with video context + user prompt."""
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {
+            "role": "user",
+            "content": (
+                f"## Video Title\n{video_title}\n\n"
+                f"## Video Context\n{video_context}\n\n"
+                f"## User's Request\n{prompt}"
+            ),
+        },
+    ]
+
+    http_proxy = os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy")
+    https_proxy = os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy")
+    proxies = http_proxy or https_proxy
+
+    async with httpx.AsyncClient(proxy=proxies, timeout=180) as client:
+        resp = await client.post(
+            f"{QWEN_BASE_URL}/v1/chat/completions",
+            json={
+                "model": QWEN_MODEL,
+                "messages": messages,
+                "max_tokens": 2048,
+                "temperature": 0.3,
+            },
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        return data["choices"][0]["message"]["content"]
+
+
+async def _process_item(item: dict) -> None:
+    """Process a single agent_queue item."""
+    video_id = item["video_id"]
+    user_prompt = item["user_prompt"]
+
+    async with aiosqlite.connect(db.DB_PATH) as conn:
+        conn.row_factory = aiosqlite.Row
+
+        # Mark as processing
+        await conn.execute(
+            "UPDATE agent_queue SET status = 'processing' WHERE id = ?",
+            (item["id"],),
+        )
+        await conn.commit()
+
+        # Get video info
+        cursor = await conn.execute(
+            "SELECT title, channel_name, summary, transcript FROM videos WHERE video_id = ?",
+            (video_id,),
+        )
+        video = await cursor.fetchone()
+
+    if not video:
+        async with aiosqlite.connect(db.DB_PATH) as conn:
+            await conn.execute(
+                "UPDATE agent_queue SET status = 'failed', result = 'Video not found in DB' WHERE id = ?",
+                (item["id"],),
+            )
+            await conn.commit()
+        return
+
+    # Build video context from whatever we have
+    context_parts = []
+    if video["channel_name"]:
+        context_parts.append(f"Channel: {video['channel_name']}")
+    if video["summary"] and not video["summary"].startswith("📺 Short clip"):
+        context_parts.append(f"Summary:\n{video['summary']}")
+    if video["transcript"] and video["transcript"] != "No transcript available":
+        context_parts.append(f"Transcript (first 4000 chars):\n{video['transcript'][:4000]}")
+    video_context = "\n\n".join(context_parts) if context_parts else "No additional context available."
+
+    try:
+        result = await _call_qwen(user_prompt, video["title"], video_context)
+        status = "done"
+    except Exception as e:
+        log.warning(f"Qwen API call failed for item {item['id']}: {e}")
+        result = f"Error: {e}"
+        status = "failed"
+
+    async with aiosqlite.connect(db.DB_PATH) as conn:
+        await conn.execute(
+            "UPDATE agent_queue SET status = ?, result = ?, processed_at = CURRENT_TIMESTAMP WHERE id = ?",
+            (status, result, item["id"]),
+        )
+        await conn.commit()
+
+
+async def process_queue_loop() -> None:
+    """Main polling loop — runs forever."""
+    log.info(
+        f"Agent worker started: Qwen at {QWEN_BASE_URL}, "
+        f"poll every {POLL_INTERVAL}s, max {MAX_CONCURRENT} concurrent"
+    )
+
+    while True:
+        try:
+            async with aiosqlite.connect(db.DB_PATH) as conn:
+                conn.row_factory = aiosqlite.Row
+                cursor = await conn.execute(
+                    "SELECT id, video_id, user_prompt FROM agent_queue WHERE status = 'pending' ORDER BY created_at ASC LIMIT ?",
+                    (MAX_CONCURRENT,),
+                )
+                items = await cursor.fetchall()
+
+            if items:
+                log.info(f"Agent queue: processing {len(items)} item(s)")
+                tasks = [_process_item(dict(item)) for item in items]
+                await asyncio.gather(*tasks)
+
+        except Exception as e:
+            log.error(f"Agent worker loop error: {e}")
+
+        await asyncio.sleep(POLL_INTERVAL)
+
+
+async def start_worker():
+    """Entry point — called from main.py startup."""
+    task = asyncio.create_task(process_queue_loop())
+    log.info("Agent queue worker scheduled")
+    return task
+
+
+if __name__ == "__main__":
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+    )
+
+    async def main():
+        from db import init_db
+        await init_db()
+        log.info("Agent worker running in foreground. Ctrl+C to stop.")
+        await process_queue_loop()
+
+    asyncio.run(main())

backend/db.py

@@ -17,12 +17,60 @@ async def init_db():
                 thumbnail_url TEXT,
                 publish_date TEXT,
                 duration INTEGER,
+                view_count INTEGER DEFAULT 0,
                 transcript TEXT,
                 summary TEXT,
                 status TEXT DEFAULT 'pending',
                 created_at TEXT DEFAULT CURRENT_TIMESTAMP
             )
         """)
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS video_notes (
+                video_id TEXT PRIMARY KEY,
+                note_text TEXT NOT NULL,
+                updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (video_id) REFERENCES videos(video_id)
+            )
+        """)
+        await db.execute("""
+            CREATE TABLE IF NOT EXISTS agent_queue (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                video_id TEXT NOT NULL,
+                user_prompt TEXT NOT NULL,
+                status TEXT DEFAULT 'pending',
+                created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                processed_at TEXT,
+                FOREIGN KEY (video_id) REFERENCES videos(video_id)
+            )
+        """)
+        # FTS5 virtual table for full-text search on title + summary
+        await db.execute("""
+            CREATE VIRTUAL TABLE IF NOT EXISTS videos_fts USING fts5(
+                title, summary,
+                content='videos',
+                content_rowid='rowid'
+            )
+        """)
+        # Trigger to keep FTS5 index in sync
+        await db.execute("""
+            CREATE TRIGGER IF NOT EXISTS videos_fts_insert AFTER INSERT ON videos
+            BEGIN
+                INSERT INTO videos_fts(rowid, title, summary) VALUES (new.rowid, new.title, new.summary);
+            END;
+        """)
+        await db.execute("""
+            CREATE TRIGGER IF NOT EXISTS videos_fts_update AFTER UPDATE ON videos
+            BEGIN
+                INSERT INTO videos_fts(videos_fts, rowid, title, summary) VALUES ('delete', old.rowid, old.title, old.summary);
+                INSERT INTO videos_fts(rowid, title, summary) VALUES (new.rowid, new.title, new.summary);
+            END;
+        """)
+        await db.execute("""
+            CREATE TRIGGER IF NOT EXISTS videos_fts_delete AFTER DELETE ON videos
+            BEGIN
+                INSERT INTO videos_fts(videos_fts, rowid, title, summary) VALUES ('delete', old.rowid, old.title, old.summary);
+            END;
+        """)
         await db.commit()
 
 async def get_db():

backend/fetcher.py

@@ -1,6 +1,11 @@
 import asyncio
+import os
+import json
+import html
 import logging
 import aiosqlite
+import httpx
+import xml.etree.ElementTree as ET
 from googleapiclient.discovery import build
 from googleapiclient.errors import HttpError
 from auth import get_credentials
@@ -8,28 +13,72 @@ from db import DB_PATH
 
 log = logging.getLogger(__name__)
 
+ATOM_NS = "http://www.w3.org/2005/Atom"
+
+CHANNELS_PER_SYNC = 50  # Rotate through all channels — N per sync
+_ROTATION_FILE = os.path.join(os.environ.get("DB_DIR", os.path.dirname(os.path.abspath(__file__))), "sync_rotation.json")
+
+
+def _get_rotation_slice(total: int) -> tuple[int, int]:
+    """Return (start, end) indices for this sync's channel slice."""
+    state = {"offset": 0, "total": total}
+    if os.path.exists(_ROTATION_FILE):
+        try:
+            with open(_ROTATION_FILE) as f:
+                state = json.load(f)
+        except (json.JSONDecodeError, OSError):
+            pass
+    # If total changed (subscribed/unsubscribed), reset
+    if state.get("total") != total:
+        state = {"offset": 0, "total": total}
+    start = state["offset"]
+    end = min(start + CHANNELS_PER_SYNC, total)
+    return start, end
+
+
+def _save_rotation_slice(total: int, start: int, end: int):
+    """Persist next sync offset."""
+    next_offset = end  # Continue from where we left off
+    if next_offset >= total:
+        next_offset = 0  # Wrap around — full cycle complete
+    os.makedirs(os.path.dirname(_ROTATION_FILE), exist_ok=True)
+    with open(_ROTATION_FILE, "w") as f:
+        json.dump({"offset": next_offset, "total": total}, f)
+
+async def _fetch_rss(client, channel_id):
+    """Fetch latest videos from a channel's RSS feed (free). Returns list of (video_id, title)."""
+    url = f"https://www.youtube.com/feeds/videos.xml?channel_id={channel_id}"
+    try:
+        resp = await client.get(url, timeout=15)
+        if resp.status_code != 200:
+            return []
+        root = ET.fromstring(resp.text)
+        entries = []
+        for entry in root.findall(f"{{{ATOM_NS}}}entry"):
+            vid = entry.find(f"{{{ATOM_NS}}}link").get("href").split("=")[-1]
+            title_el = entry.find(f"{{{ATOM_NS}}}title")
+            title = html.unescape(title_el.text) if title_el is not None and title_el.text else "Untitled"
+            entries.append((vid, title))
+        return entries
+    except Exception as e:
+        log.warning(f"RSS error for {channel_id}: {e}")
+        return []
+
+
 async def fetch_subscriptions():
-    """Fetch latest videos from subscribed channels using YouTube Data API v3."""
+    """Fetch latest videos from subscribed channels using RSS + YouTube Data API v3."""
     try:
         creds = get_credentials()
-    except FileNotFoundError as e:
-        log.error(f"OAuth setup incomplete: {e}")
-        return 0
     except Exception as e:
         log.error(f"OAuth credential error: {e}")
         return 0
 
     youtube = build("youtube", "v3", credentials=creds)
 
-    # Step 1: Get subscribed channel IDs
+    # Step 1: Get subscribed channel IDs (1 unit)
     channel_ids = []
     try:
-        request = youtube.subscriptions().list(
-            part="snippet",
-            mine=True,
-            maxResults=50,
-            order="alphabetical"
-        )
+        request = youtube.subscriptions().list(part="snippet", mine=True, maxResults=50, order="alphabetical")
         while request:
             response = request.execute()
             for item in response.get("items", []):
@@ -38,61 +87,94 @@ async def fetch_subscriptions():
                     channel_ids.append(cid)
             request = youtube.subscriptions().list_next(request, response)
     except HttpError as e:
-        log.error(f"YouTube API error fetching subscriptions: {e}")
+        log.error(f"YouTube API error: {e}")
         return 0
 
     log.info(f"Found {len(channel_ids)} subscribed channels")
 
-    if not channel_ids:
-        log.warning("No subscribed channels found. Make sure the authenticated account has subscriptions.")
+    # Step 2: Rotate — only process CHANNELS_PER_SYNC channels per sync
+    start, end = _get_rotation_slice(len(channel_ids))
+    slice_ids = channel_ids[start:end]
+    log.info(f"Processing channels {start+1}–{end} of {len(channel_ids)} ({len(slice_ids)} this sync)")
+
+    # Step 3: Fetch RSS from slice channels (free, parallel)
+    rss_videos = {}
+    async with httpx.AsyncClient(
+        proxy=os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy") or
+              os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy") or None,
+        timeout=20
+    ) as client:
+        tasks = [_fetch_rss(client, cid) for cid in slice_ids]
+        results = await asyncio.gather(*tasks)
+        for cid, entries in zip(slice_ids, results):
+            if entries:
+                rss_videos[cid] = entries
+
+    all_video_ids = []
+    rss_map = {}
+    for cid, entries in rss_videos.items():
+        for vid, title in entries:
+            if vid not in all_video_ids:
+                all_video_ids.append(vid)
+            rss_map[vid] = (cid, title)
+
+    log.info(f"RSS discovered {len(all_video_ids)} videos from {len(rss_videos)} channels")
+
+    if not all_video_ids:
+        _save_rotation_slice(len(channel_ids), start, end)
         return 0
 
-    # Step 2: For each channel, get latest videos
+    # Step 3: Check which videos are new (in SQLite)
+    async with aiosqlite.connect(DB_PATH) as db:
+        new_ids = []
+        for vid in all_video_ids:
+            cursor = await db.execute("SELECT 1 FROM videos WHERE video_id = ?", (vid,))
+            if not await cursor.fetchone():
+                new_ids.append(vid)
+
+    log.info(f"{len(new_ids)} new videos to fetch metadata for")
+
+    if not new_ids:
+        _save_rotation_slice(len(channel_ids), start, end)
+        return 0
+
+    # Step 4: Fetch metadata via videos.list (1 unit per 50 videos)
     new_count = 0
     async with aiosqlite.connect(DB_PATH) as db:
-        for cid in channel_ids[:20]:
+        for i in range(0, len(new_ids), 50):
+            batch = new_ids[i:i+50]
             try:
-                req = youtube.search().list(
-                    part="snippet",
-                    channelId=cid,
-                    maxResults=10,
-                    order="date",
-                    type="video"
-                )
-                resp = req.execute()
+                resp = youtube.videos().list(part="snippet", id=",".join(batch)).execute()
                 for item in resp.get("items", []):
-                    vid = item["id"]["videoId"]
+                    vid = item["id"]
                     snippet = item["snippet"]
+                    cid, rss_title = rss_map.get(vid, (snippet.get("channelId", ""), snippet.get("title", "")))
 
-                    cursor = await db.execute(
-                        "SELECT 1 FROM videos WHERE video_id = ?", (vid,)
-                    )
-                    if await cursor.fetchone():
-                        continue
-
-                    pub_time = snippet.get("publishTime", "")
                     await db.execute("""
                         INSERT INTO videos
                         (video_id, title, channel_name, channel_id, url, thumbnail_url, publish_date)
                         VALUES (?, ?, ?, ?, ?, ?, ?)
                     """, (
                         vid,
-                        snippet.get("title", "Untitled"),
-                        snippet.get("channelTitle", "Unknown"),
+                        html.unescape(snippet.get("title", rss_title)),
+                        html.unescape(snippet.get("channelTitle", "Unknown")),
                         snippet.get("channelId", cid),
                         f"https://www.youtube.com/watch?v={vid}",
                         snippet.get("thumbnails", {}).get("high", {}).get("url", ""),
-                        pub_time[:10] if pub_time else None
+                        (snippet.get("publishTime") or "")[:10]
                     ))
                     new_count += 1
-                    log.debug(f"New video: {snippet.get('title', 'Untitled')[:50]}")
             except HttpError as e:
-                log.warning(f"Channel {cid} fetch error: {e}")
+                log.warning(f"videos.list error: {e}")
                 continue
 
         await db.commit()
 
     log.info(f"Ingestion completed. Found {new_count} new videos.")
+
+    # Save rotation state for next sync
+    _save_rotation_slice(len(channel_ids), start, end)
+
     return new_count
 
 

backend/main.py

@@ -1,6 +1,9 @@
 import os
+import json
 import logging
-from fastapi import FastAPI, BackgroundTasks, Depends, HTTPException, Query
+from fastapi import FastAPI, BackgroundTasks, Depends, HTTPException, Query, Response
+from fastapi import Request
+from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
@@ -10,33 +13,91 @@ import aiosqlite
 from db import init_db, get_db
 from fetcher import fetch_subscriptions
 from summarizer import summarize_video, summarize_all_pending
+from agent_worker import start_worker
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 log = logging.getLogger(__name__)
 
 app = FastAPI(title="T YouTube", description="Text-based YouTube Summarizer")
 
-# Enable CORS for development
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
+
 )
 
+# API token validation — disabled. Authelia (Caddy forward_auth) handles auth upstream.
+API_TOKEN=""
+
+async def validate_api_token(request: Request, call_next):
+    path = request.url.path
+    method = request.method
+    # Only check auth for write operations on /api/*
+    # Skip token check if Authelia/Caddy already authenticated the user
+    if path.startswith("/api/") and method in ("POST", "PATCH", "DELETE") and API_TOKEN:
+        # Check if request came through Authelia (Remote-User header set by Caddy forward_auth)
+        if request.headers.get("Remote-User"):
+            return await call_next(request)
+        auth_header = request.headers.get("Authorization", "")
+        if not auth_header.startswith("Bearer ") or auth_header[7:] != API_TOKEN:
+            return JSONResponse(status_code=401, content={"detail": "Unauthorized"})
+    return await call_next(request)
+
+app.middleware("http")(validate_api_token)
+
+
 class StatusUpdate(BaseModel):
     status: str
 
-# Database Startup Hook
+class NoteUpdate(BaseModel):
+    note_text: str
+    queue_to_agent: bool = False
+
+class NoteMigrate(BaseModel):
+    notes: dict
+
+class AgentQueueItem(BaseModel):
+    video_id: str
+    user_prompt: str
+
+class AgentQueueUpdate(BaseModel):
+    status: str
+
 @app.on_event("startup")
 async def startup():
     await init_db()
+    if os.environ.get("AGENT_ENABLED", "").lower() == "true":
+        await start_worker()
+        log.info("Agent queue worker enabled")
+    else:
+        log.info("Agent queue worker disabled (set AGENT_ENABLED=true to enable)")
 
 @app.get("/api/health")
 async def health():
     return {"status": "ok"}
 
+@app.get("/api/config")
+async def api_config():
+    """Return API config without exposing the token."""
+    return {"auth_enabled": bool(API_TOKEN)}
+
+@app.get("/auto_categories.json")
+async def auto_categories():
+    path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "frontend", "src", "auto_categories.json")
+    if os.path.exists(path):
+        with open(path) as f:
+            return json.load(f)
+    return {}
+
+@app.get("/api/channels")
+async def get_channels(db: aiosqlite.Connection = Depends(get_db)):
+    cursor = await db.execute("SELECT DISTINCT channel_name, channel_id FROM videos ORDER BY channel_name")
+    rows = await cursor.fetchall()
+    return [dict(row) for row in rows]
+
 @app.get("/")
 async def root():
     from fastapi.responses import FileResponse
@@ -46,10 +107,50 @@ async def root():
 async def get_videos(
     status: Optional[str] = "pending",
     limit: int = 50,
+    channel: Optional[str] = None,
+    search: Optional[str] = None,
     db: aiosqlite.Connection = Depends(get_db)
 ):
-    query = "SELECT * FROM videos WHERE status = ? ORDER BY publish_date DESC, created_at DESC LIMIT ?"
-    cursor = await db.execute(query, (status, limit))
+    """Get videos with optional search filter."""
+    if search and len(search) >= 2:
+        # Use search endpoint logic
+        q = search.replace('"', '\\"')
+        base_query = "SELECT v.* FROM videos_fts f JOIN videos v ON f.rowid = v.rowid WHERE videos_fts MATCH ?"
+        params = [q]
+        if status:
+            base_query += " AND v.status = ?"
+            params.append(status)
+        if channel:
+            base_query += " AND v.channel_name = ?"
+            params.append(channel)
+        base_query += " ORDER BY rank LIMIT ?"
+        params.append(limit)
+    else:
+        if channel:
+            query = "SELECT * FROM videos WHERE status = ? AND channel_name = ? ORDER BY publish_date DESC, created_at DESC LIMIT ?"
+            cursor = await db.execute(query, (status, channel, limit))
+        else:
+            query = "SELECT * FROM videos WHERE status = ? ORDER BY publish_date DESC, created_at DESC LIMIT ?"
+            cursor = await db.execute(query, (status, limit))
+        rows = await cursor.fetchall()
+        return [dict(row) for row in rows]
+    
+    try:
+        cursor = await db.execute(base_query, params)
+    except Exception:
+        # Fallback to LIKE search
+        like_query = "SELECT * FROM videos WHERE title LIKE ?"
+        params = [f"%{search}%"]
+        if status:
+            like_query += " AND status = ?"
+            params.append(status)
+        if channel:
+            like_query += " AND channel_name = ?"
+            params.append(channel)
+        like_query += " ORDER BY publish_date DESC LIMIT ?"
+        params.append(limit)
+        cursor = await db.execute(like_query, params)
+    
     rows = await cursor.fetchall()
     return [dict(row) for row in rows]
 
@@ -73,7 +174,6 @@ async def trigger_summarize(video_id: str, background_tasks: BackgroundTasks, db
     exists = await cursor.fetchone()
     if not exists:
         raise HTTPException(status_code=404, detail="Video not found")
-
     background_tasks.add_task(summarize_video, video_id)
     return {"message": f"Summarization for video {video_id} queued."}
 
@@ -85,17 +185,285 @@ async def update_status(
 ):
     if update.status not in ["pending", "read", "skipped"]:
         raise HTTPException(status_code=400, detail="Invalid status value")
-
     cursor = await db.execute("SELECT 1 FROM videos WHERE video_id = ?", (video_id,))
     exists = await cursor.fetchone()
     if not exists:
         raise HTTPException(status_code=404, detail="Video not found")
-
     await db.execute("UPDATE videos SET status = ? WHERE video_id = ?", (update.status, video_id))
     await db.commit()
     return {"message": f"Video {video_id} status updated to {update.status}."}
 
-# Mount frontend built files for production if they exist
+# ---- Notes (server-side, replaces localStorage) ----
+
+
+
+@app.get("/api/notes")
+async def list_notes(db: aiosqlite.Connection = Depends(get_db)):
+    cursor = await db.execute("SELECT video_id, note_text, updated_at FROM video_notes ORDER BY updated_at DESC")
+    rows = await cursor.fetchall()
+    return [dict(row) for row in rows]
+
+@app.get("/api/notes/{video_id}")
+async def get_note(video_id: str, db: aiosqlite.Connection = Depends(get_db)):
+    cursor = await db.execute("SELECT note_text, updated_at FROM video_notes WHERE video_id = ?", (video_id,))
+    row = await cursor.fetchone()
+    if not row:
+        return {"note_text": "", "updated_at": None}
+    return dict(row)
+
+@app.post("/api/notes/{video_id}")
+async def save_note(video_id: str, update: NoteUpdate, db: aiosqlite.Connection = Depends(get_db)):
+    await db.execute("""
+        INSERT INTO video_notes (video_id, note_text, updated_at)
+        VALUES (?, ?, CURRENT_TIMESTAMP)
+        ON CONFLICT(video_id) DO UPDATE SET
+            note_text = excluded.note_text,
+            updated_at = CURRENT_TIMESTAMP
+    """, (video_id, update.note_text))
+    await db.commit()
+
+    if update.queue_to_agent and update.note_text.strip():
+        await db.execute("""
+            INSERT INTO agent_queue (video_id, user_prompt, status)
+            VALUES (?, ?, 'pending')
+        """, (video_id, update.note_text.strip()))
+        await db.commit()
+        log.info(f"Queued video {video_id} for agent: {update.note_text[:80]}")
+
+    return {"message": "Note saved"}
+
+@app.post("/api/notes/migrate")
+async def migrate_notes(migration: NoteMigrate, db: aiosqlite.Connection = Depends(get_db)):
+    count = 0
+    for video_id, note_text in migration.notes.items():
+        if not note_text.strip():
+            continue
+        await db.execute("""
+            INSERT INTO video_notes (video_id, note_text, updated_at)
+            VALUES (?, ?, CURRENT_TIMESTAMP)
+            ON CONFLICT(video_id) DO UPDATE SET
+                note_text = excluded.note_text,
+                updated_at = CURRENT_TIMESTAMP
+        """, (video_id, note_text))
+        count += 1
+    await db.commit()
+    return {"message": f"{count} notes migrated"}
+
+# ---- Agent Queue ----
+
+@app.get("/api/agent-queue")
+async def list_agent_queue(
+    status: Optional[str] = None,
+    limit: int = 50,
+    db: aiosqlite.Connection = Depends(get_db)
+):
+    if status:
+        query = """
+            SELECT q.id, q.video_id, q.user_prompt, q.status, q.created_at, q.processed_at,
+                   v.title, v.channel_name, v.url, v.summary
+            FROM agent_queue q
+            LEFT JOIN videos v ON q.video_id = v.video_id
+            WHERE q.status = ?
+            ORDER BY q.created_at DESC LIMIT ?
+        """
+        cursor = await db.execute(query, (status, limit))
+    else:
+        query = """
+            SELECT q.id, q.video_id, q.user_prompt, q.status, q.created_at, q.processed_at,
+                   v.title, v.channel_name, v.url, v.summary
+            FROM agent_queue q
+            LEFT JOIN videos v ON q.video_id = v.video_id
+            ORDER BY q.created_at DESC LIMIT ?
+        """
+        cursor = await db.execute(query, (limit,))
+    rows = await cursor.fetchall()
+    return [dict(row) for row in rows]
+
+@app.post("/api/agent-queue")
+async def add_to_agent_queue(item: AgentQueueItem, db: aiosqlite.Connection = Depends(get_db)):
+    cursor = await db.execute("SELECT 1 FROM videos WHERE video_id = ?", (item.video_id,))
+    exists = await cursor.fetchone()
+    if not exists:
+        raise HTTPException(status_code=404, detail="Video not found")
+    await db.execute("""
+        INSERT INTO agent_queue (video_id, user_prompt, status)
+        VALUES (?, ?, 'pending')
+    """, (item.video_id, item.user_prompt))
+    await db.commit()
+    return {"message": "Item queued for agent"}
+
+@app.patch("/api/agent-queue/{item_id}")
+async def update_agent_queue(item_id: int, update: AgentQueueUpdate, db: aiosqlite.Connection = Depends(get_db)):
+    valid_statuses = ["pending", "processing", "done", "failed"]
+    if update.status not in valid_statuses:
+        raise HTTPException(status_code=400, detail=f"Invalid status. Must be one of: {valid_statuses}")
+    cursor = await db.execute("SELECT 1 FROM agent_queue WHERE id = ?", (item_id,))
+    exists = await cursor.fetchone()
+    if not exists:
+        raise HTTPException(status_code=404, detail="Queue item not found")
+    if update.status in ("done", "failed"):
+        await db.execute("""
+            UPDATE agent_queue SET status = ?, processed_at = CURRENT_TIMESTAMP WHERE id = ?
+        """, (update.status, item_id))
+    else:
+        await db.execute("UPDATE agent_queue SET status = ? WHERE id = ?", (update.status, item_id))
+    await db.commit()
+    return {"message": f"Queue item {item_id} updated to {update.status}"}
+
+@app.delete("/api/agent-queue/{item_id}")
+async def remove_from_agent_queue(item_id: int, db: aiosqlite.Connection = Depends(get_db)):
+    cursor = await db.execute("SELECT 1 FROM agent_queue WHERE id = ?", (item_id,))
+    exists = await cursor.fetchone()
+    if not exists:
+        raise HTTPException(status_code=404, detail="Queue item not found")
+    await db.execute("DELETE FROM agent_queue WHERE id = ?", (item_id,))
+    await db.commit()
+    return {"message": f"Queue item {item_id} removed"}
+
+# ---- Search (FTS5) ----
+
+@app.get("/api/videos/search")
+async def search_videos(
+    q: str = "",
+    status: Optional[str] = None,
+    limit: int = 50,
+    channel: Optional[str] = None,
+    db: aiosqlite.Connection = Depends(get_db)
+):
+    """Full-text search across video titles and summaries using FTS5."""
+    if not q or len(q) < 2:
+        return []
+    
+    # Try FTS5 first
+    fts_query = q.replace('"', '\"')
+    base_query = "SELECT v.* FROM videos_fts f JOIN videos v ON f.rowid = v.rowid WHERE videos_fts MATCH ?"
+    params = [fts_query]
+    
+    if status:
+        base_query += " AND v.status = ?"
+        params.append(status)
+    if channel:
+        base_query += " AND v.channel_name = ?"
+        params.append(channel)
+    base_query += " ORDER BY rank LIMIT ?"
+    params.append(limit)
+    
+    try:
+        cursor = await db.execute(base_query, params)
+    except Exception:
+        # Fallback to LIKE if FTS5 not available
+        like_query = "SELECT * FROM videos WHERE title LIKE ?"
+        params = [f"%{q}%"]
+        if status:
+            like_query += " AND status = ?"
+            params.append(status)
+        if channel:
+            like_query += " AND channel_name = ?"
+            params.append(channel)
+        like_query += " LIMIT ?"
+        params.append(limit)
+        cursor = await db.execute(like_query, params)
+    
+    rows = await cursor.fetchall()
+    return [dict(row) for row in rows]
+
+# ---- Batch Operations ----
+
+class BatchUpdate(BaseModel):
+    video_ids: list[str]
+    status: str
+
+@app.post("/api/videos/batch")
+async def batch_update(
+    batch: BatchUpdate,
+    db: aiosqlite.Connection = Depends(get_db)
+):
+    """Batch update video statuses."""
+    if not batch.video_ids:
+        return {"message": "No video IDs provided"}
+    if batch.status not in ["pending", "read", "skipped"]:
+        raise HTTPException(status_code=400, detail="Invalid status")
+    
+    placeholders = ",".join(["?" for _ in batch.video_ids])
+    await db.execute(f"UPDATE videos SET status = ? WHERE video_id IN ({placeholders})", 
+                     [batch.status] + batch.video_ids)
+    await db.commit()
+    
+    return {"message": f"Updated {len(batch.video_ids)} videos"}
+
+# ---- Stats Dashboard ----
+
+@app.get("/api/stats")
+async def get_stats(db: aiosqlite.Connection = Depends(get_db)):
+    """Return dashboard statistics."""
+    stats = {}
+    
+    # Total videos
+    cursor = await db.execute("SELECT COUNT(*) FROM videos")
+    stats["total"] = (await cursor.fetchone())[0]
+    
+    # Status breakdown
+    cursor = await db.execute("SELECT status, COUNT(*) FROM videos GROUP BY status")
+    stats["status_breakdown"] = {row[0]: row[1] for row in await cursor.fetchall()}
+    
+    # Channels
+    cursor = await db.execute("SELECT COUNT(DISTINCT channel_name) FROM videos")
+    stats["channels"] = (await cursor.fetchone())[0]
+    
+    # Videos with summaries vs without
+    cursor = await db.execute("SELECT COUNT(*) FROM videos WHERE summary IS NOT NULL AND summary != ''")
+    stats["with_summary"] = (await cursor.fetchone())[0]
+    
+    # Recent activity (last 7 days)
+    cursor = await db.execute("SELECT COUNT(*) FROM videos WHERE created_at >= datetime('now', '-7 days')")
+    stats["last_7_days"] = (await cursor.fetchone())[0]
+    
+    # Top channels by video count
+    cursor = await db.execute("SELECT channel_name, COUNT(*) as cnt FROM videos GROUP BY channel_name ORDER BY cnt DESC LIMIT 10")
+    stats["top_channels"] = [{"name": row[0], "count": row[1]} for row in await cursor.fetchall()]
+    
+    # Summary rate
+    if stats["total"] > 0:
+        stats["summary_rate"] = round(stats["with_summary"] / stats["total"] * 100, 1)
+    else:
+        stats["summary_rate"] = 0
+    
+    return stats
+
+# ---- Duration + View Count Update ----
+
+class VideoMetaUpdate(BaseModel):
+    duration: Optional[int] = None
+    view_count: Optional[int] = None
+
+@app.patch("/api/videos/{video_id}/meta")
+async def update_video_meta(
+    video_id: str,
+    meta: VideoMetaUpdate,
+    db: aiosqlite.Connection = Depends(get_db)
+):
+    """Update video metadata (duration, view count)."""
+    updates = []
+    params = []
+    if meta.duration is not None:
+        updates.append("duration = ?")
+        params.append(meta.duration)
+    if meta.view_count is not None:
+        updates.append("view_count = ?")
+        params.append(meta.view_count)
+    
+    if not updates:
+        return {"message": "No updates provided"}
+    
+    params.append(video_id)
+    await db.execute(f"UPDATE videos SET {', '.join(updates)} WHERE video_id = ?", params)
+    await db.commit()
+    return {"message": "Metadata updated"}
+
+# ---- Include view_count in video list ----
+
+# ---- Static frontend ----
+
 frontend_build_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "frontend/dist")
 if os.path.exists(frontend_build_path):
     app.mount("/", StaticFiles(directory=frontend_build_path, html=True), name="frontend")

backend/requirements.txt

@@ -1,6 +1,5 @@
 fastapi>=0.100.0
 uvicorn>=0.20.0
-yt-dlp>=2023.0.0
 youtube-transcript-api>=0.6.0
 aiosqlite>=0.18.0
 httpx>=0.24.0

backend/run_sync.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+set -e
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR/.."
+source "$SCRIPT_DIR/../.env"
+"$SCRIPT_DIR/.venv/bin/python3" -c "
+import asyncio, sys, logging
+sys.path.insert(0, '$SCRIPT_DIR')
+from db import init_db
+from fetcher import fetch_subscriptions
+from summarizer import summarize_all_pending
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
+
+async def main():
+    await init_db()
+    count = await fetch_subscriptions()
+    print(f'Fetched {count} new videos')
+    if count > 0:
+        print(f'Summarizing {count} videos...')
+        await summarize_all_pending()
+    print('Done')
+
+asyncio.run(main())
+"

backend/summarizer.py

@@ -9,6 +9,11 @@ from db import DB_PATH
 
 log = logging.getLogger(__name__)
 
+def proxy_from_env():
+    """Return proxy URL from HTTP_PROXY/HTTPS_PROXY env vars, or None."""
+    return os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy") or \
+           os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy") or None
+
 # Fallback pattern to retrieve the correct bytecatcode credentials
 API_KEY = os.environ.get("DEEPSEEK_API_KEY", os.environ.get("OPENAI_API_KEY", ""))
 BASE_URL = os.environ.get("DEEPSEEK_BASE_URL", "https://api.deepseek.com")
@@ -39,6 +44,10 @@ for p in [os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__)
 def download_transcript(video_id: str) -> str:
     try:
         session = requests.Session()
+        # Respect HTTP_PROXY/HTTPS_PROXY env vars
+        proxy = proxy_from_env()
+        if proxy:
+            session.proxies = {"http": proxy, "https": proxy}
         session.headers.update({
             "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
             "Accept-Language": "en-US,en;q=0.9"
@@ -62,9 +71,9 @@ def download_transcript(video_id: str) -> str:
         log.warning(f"Failed to fetch transcript for {video_id}: {e}")
         return None
 
-async def summarize_video(video_id: str) -> str:
-    # 1. Try transcript, fall back to description
-    transcript = download_transcript(video_id)
+async def summarize_video(video_id: str) -> str | None:
+    # 1. Try transcript, fall back to description (offload sync call to thread)
+    transcript = await asyncio.to_thread(download_transcript, video_id)
     
     if not transcript:
         # Fallback: use video description from YouTube API
@@ -108,7 +117,7 @@ async def summarize_video(video_id: str) -> str:
         ]
     }
 
-    async with httpx.AsyncClient(timeout=120) as client:
+    async with httpx.AsyncClient(proxy=proxy_from_env(), timeout=120) as client:
         try:
             resp = await client.post(
                 f"{BASE_URL}/v1/chat/completions",
@@ -120,7 +129,7 @@ async def summarize_video(video_id: str) -> str:
             summary = data["choices"][0]["message"]["content"]
         except Exception as e:
             log.error(f"DeepSeek API request failed for {video_id}: {e}")
-            summary = f"Error generating summary: {e}"
+            return None  # Leave summary NULL for retry on next sync
 
     # 3. Save transcript & summary to db
     async with aiosqlite.connect(DB_PATH) as db:

backend/tests/test_agent_worker.py

@@ -0,0 +1,112 @@
+"""Tests for agent_worker.py — mocks Qwen API."""
+import pytest
+import os
+import json
+import aiosqlite
+import httpx
+from unittest.mock import patch, AsyncMock, MagicMock
+
+
+@pytest.mark.asyncio
+async def test_agent_worker_polls_and_processes(test_db, monkeypatch):
+    """Worker picks up a pending item, calls Qwen, marks it done."""
+    from agent_worker import _process_item
+
+    # Seed a pending queue item + video
+    await test_db.execute("""
+        INSERT INTO videos (video_id, title, channel_name, url, summary, status)
+        VALUES ('ag_vid', 'Test Video', 'Test Channel', 'https://youtube.com/watch?v=ag_vid',
+                '**Summary**\n- Point 1\n- Point 2\nVerdict.', 'pending')
+    """)
+    await test_db.execute("""
+        INSERT INTO agent_queue (video_id, user_prompt, status)
+        VALUES ('ag_vid', 'Save this as a skill', 'pending')
+    """)
+    await test_db.commit()
+
+    # Get the item
+    cursor = await test_db.execute(
+        "SELECT id, video_id, user_prompt FROM agent_queue WHERE status = 'pending'"
+    )
+    item = dict(await cursor.fetchone())
+
+    # Mock Qwen API
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.status_code = 200
+    mock_response.json.return_value = {
+        "choices": [{"message": {"content": "I've saved the skill. Done."}}]
+    }
+
+    with patch("httpx.AsyncClient.post", new_callable=AsyncMock, return_value=mock_response):
+        await _process_item(item)
+
+    # Verify
+    cursor = await test_db.execute(
+        "SELECT status, result FROM agent_queue WHERE id = ?", (item["id"],)
+    )
+    row = await cursor.fetchone()
+    assert row["status"] == "done"
+    assert "I've saved the skill" in row["result"]
+
+
+@pytest.mark.asyncio
+async def test_agent_worker_handles_missing_video(test_db):
+    """When video doesn't exist, marks as failed gracefully."""
+    from agent_worker import _process_item
+
+    await test_db.execute("""
+        INSERT INTO agent_queue (video_id, user_prompt, status)
+        VALUES ('missing_vid', 'Do something', 'pending')
+    """)
+    await test_db.commit()
+
+    cursor = await test_db.execute(
+        "SELECT id, video_id, user_prompt FROM agent_queue WHERE status = 'pending'"
+    )
+    item = dict(await cursor.fetchone())
+
+    await _process_item(item)
+
+    cursor = await test_db.execute(
+        "SELECT status, result FROM agent_queue WHERE id = ?", (item["id"],)
+    )
+    row = await cursor.fetchone()
+    assert row["status"] == "failed"
+    assert "not found" in row["result"].lower()
+
+
+@pytest.mark.asyncio
+async def test_agent_worker_qwen_error_marks_failed(test_db):
+    """Qwen API failure should mark as failed, not crash."""
+    from agent_worker import _process_item
+
+    await test_db.execute("""
+        INSERT INTO videos (video_id, title, channel_name, url, status)
+        VALUES ('err_vid', 'Error Video', 'Test', 'https://youtube.com/watch?v=err_vid', 'pending')
+    """)
+    await test_db.execute("""
+        INSERT INTO agent_queue (video_id, user_prompt, status)
+        VALUES ('err_vid', 'Do it', 'pending')
+    """)
+    await test_db.commit()
+
+    cursor = await test_db.execute(
+        "SELECT id, video_id, user_prompt FROM agent_queue WHERE status = 'pending'"
+    )
+    item = dict(await cursor.fetchone())
+
+    # Mock HTTP error
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.status_code = 503
+    mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
+        "503 Service Unavailable", request=MagicMock(), response=mock_response
+    )
+
+    with patch("httpx.AsyncClient.post", new_callable=AsyncMock, return_value=mock_response):
+        await _process_item(item)
+
+    cursor = await test_db.execute(
+        "SELECT status FROM agent_queue WHERE id = ?", (item["id"],)
+    )
+    row = await cursor.fetchone()
+    assert row["status"] == "failed"

backend/tests/test_fetcher.py

@@ -1,112 +1,186 @@
+"""Tests for fetcher.py — mocks YouTube Data API v3 + RSS."""
 import pytest
 import os
 import json
 import aiosqlite
 import fetcher
-import asyncio
-from unittest.mock import patch, AsyncMock
+from unittest.mock import patch, AsyncMock, MagicMock
 
-class MockProcess:
-    def __init__(self, stdout_data, returncode=0, stderr_data=b""):
-        self.stdout_data = stdout_data
-        self.stderr_data = stderr_data
-        self.returncode = returncode
 
-    async def communicate(self):
-        return self.stdout_data, self.stderr_data
+def _clean_rotation_file():
+    """Remove rotation state file if it exists."""
+    path = getattr(fetcher, "_ROTATION_FILE", None)
+    if path and os.path.exists(path):
+        os.remove(path)
+
+
+@pytest.fixture(autouse=True)
+def auto_clean_rotation():
+    _clean_rotation_file()
+    yield
+    _clean_rotation_file()
+
+
+def _mock_youtube_build(sub_channels=None, video_data=None):
+    """Build a mock YouTube API service that returns canned responses."""
+    sub_channels = sub_channels or [
+        {"snippet": {"resourceId": {"channelId": "chan001"}}},
+        {"snippet": {"resourceId": {"channelId": "chan002"}}},
+    ]
+    video_data = video_data or {}
+
+    def mock_subscriptions_list(**kwargs):
+        return MagicMock(execute=MagicMock(return_value={"items": sub_channels}))
+
+    def mock_videos_list(**kwargs):
+        vid_str = kwargs.get("id", "")
+        ids = [v for v in vid_str.split(",") if v]
+        items = []
+        for vid in ids:
+            data = video_data.get(vid, {
+                "title": f"Video {vid}",
+                "channelTitle": "Test Channel",
+                "channelId": "chan001",
+                "thumbnails": {"high": {"url": f"https://img.youtube.com/vi/{vid}/hqdefault.jpg"}},
+                "publishTime": "2026-06-01T00:00:00Z",
+            })
+            items.append({"id": vid, "snippet": data})
+        return MagicMock(execute=MagicMock(return_value={"items": items}))
+
+    svc = MagicMock()
+    svc.subscriptions = MagicMock(return_value=MagicMock(list=mock_subscriptions_list, list_next=MagicMock(return_value=None)))
+    svc.videos = MagicMock(return_value=MagicMock(list=mock_videos_list))
+    return svc
+
+
+def _mock_rss_response(videos):
+    """Build RSS XML string for a list of (video_id, title) tuples."""
+    entries = []
+    for vid, title in videos:
+        entries.append(f"""<entry>
+      <id>yt:video:{vid}</id>
+      <link href="https://www.youtube.com/watch?v={vid}"/>
+      <title>{title}</title>
+    </entry>""")
+    return f"""<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  {''.join(entries)}
+</feed>"""
+
 
 @pytest.mark.asyncio
-async def test_fetch_subscriptions_no_cookies(tmp_path, monkeypatch):
-    monkeypatch.setattr(fetcher, "COOKIES_PATH", "/non/existent/path/cookies.txt")
-    count = await fetcher.fetch_subscriptions()
-    assert count == 0
-
-@pytest.mark.asyncio
-async def test_fetch_subscriptions_success(test_db, tmp_path, monkeypatch):
-    cookies_file = os.path.join(tmp_path, "mock_cookies.txt")
-    with open(cookies_file, "w") as f:
-        f.write("# Netscape HTTP Cookie File")
-    monkeypatch.setattr(fetcher, "COOKIES_PATH", cookies_file)
-
-    video1 = {
-        "id": "vid123",
-        "title": "Mock Video 1",
-        "uploader": "Uploader One",
-        "uploader_id": "chan123",
-        "upload_date": "20260601",
-        "duration": 360,
-        "thumbnail": "https://img.youtube.com/vi/vid123/hqdefault.jpg"
-    }
-    video2 = {
-        "id": "vid456",
-        "title": "Mock Video 2",
-        "uploader": "Uploader Two",
-        "uploader_id": "chan456",
-        "upload_date": "20260602",
-        "duration": 720
-    }
-    stdout_bytes = (json.dumps(video1) + "\n" + json.dumps(video2) + "\n").encode("utf-8")
-
-    mock_process = MockProcess(stdout_data=stdout_bytes, returncode=0)
-
-    with patch("asyncio.create_subprocess_exec", return_value=mock_process) as mock_exec:
+async def test_fetch_zero_channels(test_db):
+    """When no subscriptions exist, should return 0."""
+    mock_svc = _mock_youtube_build(sub_channels=[])
+    with patch("fetcher.build", return_value=mock_svc), \
+         patch("fetcher.get_credentials", return_value="mock_creds"):
         count = await fetcher.fetch_subscriptions()
+        assert count == 0
 
-        mock_exec.assert_called_once()
-        args = mock_exec.call_args[0]
-        assert "yt-dlp" in args
-        assert "https://www.youtube.com/feed/subscriptions" in args
-        assert cookies_file in args
+
+@pytest.mark.asyncio
+async def test_fetch_rss_empty(test_db):
+    """When RSS returns nothing, count should be 0."""
+    mock_svc = _mock_youtube_build()
+    with patch("fetcher.build", return_value=mock_svc), \
+         patch("fetcher.get_credentials", return_value="mock_creds"), \
+         patch("httpx.AsyncClient.get", AsyncMock(return_value=MagicMock(status_code=404))):
+        count = await fetcher.fetch_subscriptions()
+        assert count == 0
+
+
+@pytest.mark.asyncio
+async def test_fetch_new_videos(test_db):
+    """New videos from RSS should be inserted into DB."""
+    mock_svc = _mock_youtube_build(video_data={
+        "vid001": {"title": "First Video", "channelTitle": "Chan One",
+                    "channelId": "chan001", "thumbnails": {"high": {"url": ""}},
+                    "publishTime": "2026-06-01T00:00:00Z"},
+        "vid002": {"title": "Second Video", "channelTitle": "Chan Two",
+                    "channelId": "chan002", "thumbnails": {"high": {"url": ""}},
+                    "publishTime": "2026-06-02T00:00:00Z"},
+    })
+    rss_xml = _mock_rss_response([("vid001", "First Video"), ("vid002", "Second Video")])
+    mock_response = MagicMock(status_code=200, text=rss_xml)
+
+    with patch("fetcher.build", return_value=mock_svc), \
+         patch("fetcher.get_credentials", return_value="mock_creds"), \
+         patch("httpx.AsyncClient.get", AsyncMock(return_value=mock_response)):
+        count = await fetcher.fetch_subscriptions()
         assert count == 2
 
-    # Query db to verify values
+    # Verify DB
     cursor = await test_db.execute("SELECT * FROM videos ORDER BY video_id")
-    videos = await cursor.fetchall()
-    assert len(videos) == 2
+    rows = await cursor.fetchall()
+    assert len(rows) == 2
+    assert rows[0]["video_id"] == "vid001"
+    assert rows[0]["title"] == "First Video"
+    assert rows[1]["video_id"] == "vid002"
+    assert rows[1]["title"] == "Second Video"
 
-    assert videos[0]["video_id"] == "vid123"
-    assert videos[0]["title"] == "Mock Video 1"
-    assert videos[0]["channel_name"] == "Uploader One"
-    assert videos[0]["channel_id"] == "chan123"
-    assert videos[0]["url"] == "https://www.youtube.com/watch?v=vid123"
-    assert videos[0]["thumbnail_url"] == "https://img.youtube.com/vi/vid123/hqdefault.jpg"
-    assert videos[0]["publish_date"] == "2026-06-01"
-    assert videos[0]["duration"] == 360
-    assert videos[0]["status"] == "pending"
-
-    assert videos[1]["video_id"] == "vid456"
-    assert videos[1]["title"] == "Mock Video 2"
-    assert videos[1]["publish_date"] == "2026-06-02"
-    assert videos[1]["duration"] == 720
 
 @pytest.mark.asyncio
-async def test_fetch_subscriptions_skip_duplicates(test_db, tmp_path, monkeypatch):
-    cookies_file = os.path.join(tmp_path, "mock_cookies.txt")
-    with open(cookies_file, "w") as f:
-        f.write("# Netscape HTTP Cookie File")
-    monkeypatch.setattr(fetcher, "COOKIES_PATH", cookies_file)
-
-    # Insert an existing video record first
-    await test_db.execute("""
-        INSERT INTO videos (video_id, title, url, status)
-        VALUES ('vid123', 'Mock Video 1', 'https://www.youtube.com/watch?v=vid123', 'pending')
-    """)
+async def test_fetch_skip_duplicates(test_db):
+    """Existing videos should be skipped."""
+    # Pre-insert one video
+    await test_db.execute(
+        "INSERT INTO videos (video_id, title, url, status) VALUES ('vid001', 'Old', 'https://youtube.com/watch?v=vid001', 'pending')"
+    )
     await test_db.commit()
 
-    video1 = {
-        "id": "vid123",
-        "title": "Mock Video 1",
-        "upload_date": "20260601"
-    }
-    video2 = {
-        "id": "vid456",
-        "title": "Mock Video 2",
-        "upload_date": "20260602"
-    }
-    stdout_bytes = (json.dumps(video1) + "\n" + json.dumps(video2) + "\n").encode("utf-8")
+    mock_svc = _mock_youtube_build(video_data={
+        "vid001": {"title": "First Video (updated)", "channelTitle": "Chan One",
+                    "channelId": "chan001"},
+        "vid002": {"title": "Second Video", "channelTitle": "Chan Two",
+                    "channelId": "chan002"},
+    })
+    rss_xml = _mock_rss_response([("vid001", "First Video"), ("vid002", "Second Video")])
+    mock_response = MagicMock(status_code=200, text=rss_xml)
 
-    mock_process = MockProcess(stdout_data=stdout_bytes, returncode=0)
-
-    with patch("asyncio.create_subprocess_exec", return_value=mock_process):
+    with patch("fetcher.build", return_value=mock_svc), \
+         patch("fetcher.get_credentials", return_value="mock_creds"), \
+         patch("httpx.AsyncClient.get", AsyncMock(return_value=mock_response)):
         count = await fetcher.fetch_subscriptions()
-        assert count == 1 # Only 1 new video should be added (vid456)
+        assert count == 1  # Only vid002 is new
+
+    # Verify DB — vid001 still has original title (not updated)
+    cursor = await test_db.execute("SELECT title FROM videos WHERE video_id='vid001'")
+    row = await cursor.fetchone()
+    assert row["title"] == "Old"
+
+
+@pytest.mark.asyncio
+async def test_rotation_advances(test_db):
+    """Rotation slice should advance after each sync."""
+    # Mock 150 channels
+    sub_channels = [{"snippet": {"resourceId": {"channelId": f"chan{i:03d}"}}} for i in range(150)]
+    mock_svc = _mock_youtube_build(sub_channels=sub_channels)
+
+    rss_xml = _mock_rss_response([])  # No videos, just test rotation
+    mock_response = MagicMock(status_code=200, text=rss_xml)
+
+    with patch("fetcher.build", return_value=mock_svc), \
+         patch("fetcher.get_credentials", return_value="mock_creds"), \
+         patch("httpx.AsyncClient.get", AsyncMock(return_value=mock_response)):
+        # First sync — should process chan000-chan049
+        count = await fetcher.fetch_subscriptions()
+        # Second sync — chan050-chan099
+        count2 = await fetcher.fetch_subscriptions()
+        # Third sync — chan100-chan149
+        count3 = await fetcher.fetch_subscriptions()
+        # Fourth sync — wrap around, chan000-chan049 again
+        count4 = await fetcher.fetch_subscriptions()
+
+    # Verify rotation file
+    with open(fetcher._ROTATION_FILE) as f:
+        state = json.load(f)
+    assert state["offset"] == 50  # After 4th sync, offset = 50 (wrapped from 150)
+    assert state["total"] == 150
+
+
+@pytest.mark.asyncio
+async def test_fetch_quietly_handles_missing_credentials(test_db):
+    """When OAuth is missing, should return 0 gracefully."""
+    with patch("fetcher.get_credentials", side_effect=FileNotFoundError("No client_secret")):
+        count = await fetcher.fetch_subscriptions()
+        assert count == 0

backend/tests/test_summarizer.py

@@ -1,3 +1,4 @@
+"""Tests for summarizer.py — mocks transcript API + DeepSeek API."""
 import pytest
 import os
 import httpx
@@ -5,6 +6,7 @@ import aiosqlite
 import summarizer
 from unittest.mock import patch, MagicMock, AsyncMock
 
+
 class MockTranscript:
     def fetch(self):
         return [
@@ -25,6 +27,17 @@ class MockTranscriptList:
     def __iter__(self):
         return iter([self.transcript])
 
+
+def _mock_deepseek_response(content: str) -> MagicMock:
+    """Build a DeepSeek/OpenAI-compatible API response."""
+    r = MagicMock(spec=httpx.Response)
+    r.status_code = 200
+    r.json.return_value = {
+        "choices": [{"message": {"content": content}}]
+    }
+    return r
+
+
 @pytest.mark.asyncio
 async def test_download_transcript_success():
     mock_trans = MockTranscript()
@@ -34,9 +47,9 @@ async def test_download_transcript_success():
         text = summarizer.download_transcript("test_vid")
         assert text == "Welcome to this video tutorial. Today we are learning about Svelte 5 and runes."
 
+
 @pytest.mark.asyncio
 async def test_summarize_video_success(test_db):
-    # Insert a pending video in db first
     await test_db.execute("""
         INSERT INTO videos (video_id, title, url, status)
         VALUES ('summarize_vid', 'Video to Summarize', 'https://www.youtube.com/watch?v=summarize_vid', 'pending')
@@ -45,19 +58,8 @@ async def test_summarize_video_success(test_db):
 
     mock_trans = MockTranscript()
     mock_list = MockTranscriptList(mock_trans)
+    mock_response = _mock_deepseek_response("**Mock Core Hook**\n- Takeaway 1\n- Takeaway 2\nVerdict line.")
 
-    # Mock Claude HTTP response
-    mock_response = MagicMock(spec=httpx.Response)
-    mock_response.status_code = 200
-    mock_response.json.return_value = {
-        "content": [
-            {
-                "text": "**Mock Core Hook**\n- Takeaway 1\n- Takeaway 2\nVerdict line."
-            }
-        ]
-    }
-
-    # Patch both transcript api and httpx AsyncClient post call
     with patch("youtube_transcript_api.YouTubeTranscriptApi.list", return_value=mock_list), \
          patch("httpx.AsyncClient.post", new_callable=AsyncMock, return_value=mock_response) as mock_post:
 
@@ -69,12 +71,12 @@ async def test_summarize_video_success(test_db):
         assert summarizer.BASE_URL in url
 
         headers = mock_post.call_args[1]["headers"]
-        assert "x-api-key" in headers
+        assert "Authorization" in headers
         assert headers["User-Agent"] is not None
 
         payload = mock_post.call_args[1]["json"]
-        assert payload["model"] == "claude-haiku-4-5-20251001"
-        assert len(payload["messages"]) == 1
+        assert payload["model"] == "deepseek-chat"
+        assert len(payload["messages"]) == 2  # system + user
 
         assert summary == "**Mock Core Hook**\n- Takeaway 1\n- Takeaway 2\nVerdict line."
 
@@ -85,9 +87,40 @@ async def test_summarize_video_success(test_db):
     assert video["transcript"] == "Welcome to this video tutorial. Today we are learning about Svelte 5 and runes."
     assert video["summary"] == "**Mock Core Hook**\n- Takeaway 1\n- Takeaway 2\nVerdict line."
 
+
+@pytest.mark.asyncio
+async def test_summarize_video_deepseek_error_leaves_null(test_db):
+    """When DeepSeek fails, summary should stay NULL for retry."""
+    await test_db.execute("""
+        INSERT INTO videos (video_id, title, url, status)
+        VALUES ('err_vid', 'Error Video', 'https://youtube.com/watch?v=err_vid', 'pending')
+    """)
+    await test_db.commit()
+
+    mock_trans = MockTranscript()
+    mock_list = MockTranscriptList(mock_trans)
+    mock_response = MagicMock(spec=httpx.Response)
+    mock_response.status_code = 429
+    # raise_for_status on 429 should raise HTTPStatusError
+    mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
+        "429 Rate Limited", request=MagicMock(), response=mock_response
+    )
+
+    with patch("youtube_transcript_api.YouTubeTranscriptApi.list", return_value=mock_list), \
+         patch("httpx.AsyncClient.post", new_callable=AsyncMock, return_value=mock_response):
+
+        result = await summarizer.summarize_video("err_vid")
+
+        assert result is None  # Returns None instead of an error string
+
+    # Verify DB — summary should remain NULL
+    cursor = await test_db.execute("SELECT summary FROM videos WHERE video_id = 'err_vid'")
+    row = await cursor.fetchone()
+    assert row["summary"] is None
+
+
 @pytest.mark.asyncio
 async def test_summarize_all_pending(test_db):
-    # Insert multiple videos, one pending and one already summarized
     await test_db.execute("""
         INSERT INTO videos (video_id, title, url, summary, status)
         VALUES
@@ -98,28 +131,21 @@ async def test_summarize_all_pending(test_db):
 
     mock_trans = MockTranscript()
     mock_list = MockTranscriptList(mock_trans)
-
-    mock_response = MagicMock(spec=httpx.Response)
-    mock_response.status_code = 200
-    mock_response.json.return_value = {
-        "content": [{"text": "Fresh summary"}]
-    }
+    mock_response = _mock_deepseek_response("Fresh summary")
 
     with patch("youtube_transcript_api.YouTubeTranscriptApi.list", return_value=mock_list), \
          patch("httpx.AsyncClient.post", new_callable=AsyncMock, return_value=mock_response) as mock_post:
 
         await summarizer.summarize_all_pending()
 
-        # Should only call API once for 'pending_vid'
+        # Should only call API once for 'pending_vid' (done_vid already has summary)
         mock_post.assert_called_once()
-        payload = mock_post.call_args[1]["json"]
-        assert "Welcome to this video tutorial." in payload["messages"][0]["content"]
 
     # Verify db states
     cursor = await test_db.execute("SELECT video_id, summary FROM videos ORDER BY video_id")
     videos = await cursor.fetchall()
     assert videos[0]["video_id"] == "done_vid"
-    assert videos[0]["summary"] == "Existing summary" # Untouched
+    assert videos[0]["summary"] == "Existing summary"  # Untouched
 
     assert videos[1]["video_id"] == "pending_vid"
-    assert videos[1]["summary"] == "Fresh summary" # Updated
+    assert videos[1]["summary"] == "Fresh summary"  # Updated

backend/tg_filter.py

@@ -0,0 +1,229 @@
+"""
+Telegram Group Filter — scours 100+ groups for interesting messages.
+Rotates through all groups across cron cycles to avoid rate limits.
+Resets processed tracking per batch so each cycle gets fresh messages.
+"""
+
+import asyncio
+import os
+import re
+import json
+import sqlite3
+import logging
+from datetime import datetime, timezone, timedelta
+from pyrogram import Client
+from pyrogram.types import Message
+from typing import Optional
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    datefmt="%H:%M:%S",
+)
+log = logging.getLogger("tg_filter")
+
+# === CONFIG ===
+PHONE = open("/tmp/tg_phone.txt").read().strip()
+API_ID = 2040
+API_HASH = "b18441a1ff607e10a989891a5462e627"
+WORKDIR = "/Users/jimmyg"
+DB_PATH = os.path.join(WORKDIR, ".hermes", "tg_filter.db")
+
+# Scoring
+SCORE_MENTION = 30
+SCORE_KEYWORD = 15
+SCORE_LINK = 10
+SCORE_MEDIA = 8
+SCORE_CODE = 12
+SCORE_LONG_TEXT = 5
+THRESHOLD = 40
+
+# Scan config
+MSGS_PER_GROUP = 500
+GROUPS_PER_CYCLE = 56
+
+# Keywords
+INTERESTING_KEYWORDS = [
+    "ai", "llm", "gpt", "deepseek", "claude", "gemini", "qwen", "openai",
+    "docker", "kubernetes", "k8s", "tailscale", "wireguard", "vps", "nas",
+    "self-host", "homelab", "server", "deploy", "ci/cd", "gitea", "git",
+    "api", "automation", "script", "python", "rust", "go", "typescript",
+    "svelte", "react", "nextjs", "fastapi", "sveltekit",
+    "tutorial", "guide", "how to", "free", "open source", "github",
+    "security", "vulnerability", "cve", "patch", "update",
+    "opportunity", "合作", "项目", "招聘", "job", "remote",
+    "startup", "saas", "mvp", "产品", "产品发布",
+]
+
+IGNORE_PATTERNS = ["合租社群", "黄油派对"]
+
+
+def score_message(msg: Message) -> int:
+    score = 0
+    text = msg.text or msg.caption or ""
+    if msg.entities:
+        for e in msg.entities:
+            if e.type in ("mention", "text_mention"): score += SCORE_MENTION
+            if e.type == "url": score += SCORE_LINK
+            if e.type == "code" or e.type == "pre": score += SCORE_CODE
+    if msg.photo or msg.video or msg.document or msg.audio: score += SCORE_MEDIA
+    if re.search(r'https?://[^\s]+', text): score += SCORE_LINK
+    text_lower = text.lower()
+    for kw in INTERESTING_KEYWORDS:
+        if kw in text_lower: score += SCORE_KEYWORD
+    if len(text.strip()) >= 200: score += SCORE_LONG_TEXT
+    if msg.forward_from or msg.forward_from_chat: score += 5
+    if msg.reply_to_message_id: score += 3
+    return score
+
+
+def should_ignore(chat_title: str) -> bool:
+    if not chat_title: return False
+    for pat in IGNORE_PATTERNS:
+        if pat in chat_title: return True
+    return False
+
+
+def init_db():
+    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+    db = sqlite3.connect(DB_PATH)
+    db.execute("CREATE TABLE IF NOT EXISTS processed (chat_id INTEGER, message_id INTEGER, PRIMARY KEY (chat_id, message_id))")
+    db.execute("CREATE TABLE IF NOT EXISTS interesting (id INTEGER PRIMARY KEY AUTOINCREMENT, chat_id INTEGER, chat_title TEXT, message_id INTEGER, sender TEXT, text TEXT, score INTEGER, captured_at TEXT, delivered INTEGER DEFAULT 0)")
+    db.execute("CREATE TABLE IF NOT EXISTS group_stats (chat_id INTEGER PRIMARY KEY, chat_title TEXT, total_scanned INTEGER DEFAULT 0, interesting_found INTEGER DEFAULT 0, last_interesting_at TEXT, last_scan_at TEXT)")
+    db.commit()
+    return db
+
+
+def update_group_stats(db, chat_id: int, chat_title: str, found_interesting: int, now: str):
+    cur = db.execute("SELECT total_scanned, interesting_found FROM group_stats WHERE chat_id = ?", (chat_id,))
+    row = cur.fetchone()
+    if row:
+        db.execute(
+            "UPDATE group_stats SET total_scanned = total_scanned + 1, interesting_found = interesting_found + ?, "
+            "last_interesting_at = CASE WHEN ? > 0 THEN ? ELSE last_interesting_at END, last_scan_at = ? WHERE chat_id = ?",
+            (found_interesting, found_interesting, now if found_interesting > 0 else None, now, chat_id)
+        )
+    else:
+        db.execute(
+            "INSERT INTO group_stats (chat_id, chat_title, total_scanned, interesting_found, last_interesting_at, last_scan_at) "
+            "VALUES (?, ?, 1, ?, ?, ?)",
+            (chat_id, chat_title, found_interesting, now if found_interesting > 0 else None, now)
+        )
+
+
+async def scan_and_report(dry_run: bool = False) -> list:
+    db = init_db()
+    c = Client("pyro_session", API_ID, API_HASH, workdir=WORKDIR)
+    await c.start()
+    me = await c.get_me()
+    log.info(f"Scanned as: {me.first_name}")
+
+    interesting = []
+    total_read = 0
+    total_skipped = 0
+    total_groups = 0
+    now = datetime.now(timezone.utc).isoformat()
+
+    # Collect all eligible dialogs
+    candidates = []
+    async for dialog in c.get_dialogs():
+        chat = dialog.chat
+        chat_id = chat.id
+        chat_title = chat.title or chat.first_name or "Unknown"
+        if should_ignore(chat_title):
+            continue
+        candidates.append((chat_id, chat_title))
+
+    log.info(f"Total eligible groups: {len(candidates)}")
+
+    # Sort by last_scan_at (NULLs first) to rotate
+    sorted_candidates = []
+    for cid, title in candidates:
+        cur = db.execute("SELECT last_scan_at FROM group_stats WHERE chat_id = ?", (cid,))
+        row = cur.fetchone()
+        if row and row[0]:
+            sorted_candidates.append((cid, title, row[0]))
+        else:
+            sorted_candidates.append((cid, title, ""))
+    sorted_candidates.sort(key=lambda x: (x[2] == "", x[2]))
+    sorted_candidates = sorted_candidates[:GROUPS_PER_CYCLE]
+
+    log.info(f"Scanning {len(sorted_candidates)} groups this cycle")
+
+    # Clear processed entries for these groups so we get fresh messages
+    group_ids = [cid for cid, _, _ in sorted_candidates]
+    db.execute("DELETE FROM processed WHERE chat_id IN ({})".format(
+        ",".join("?" * len(group_ids))
+    ), group_ids)
+    db.commit()
+
+    for chat_id, chat_title, _ in sorted_candidates:
+        total_groups += 1
+        group_found = 0
+
+        async for msg in c.get_chat_history(chat_id, limit=MSGS_PER_GROUP):
+            total_read += 1
+            score = score_message(msg)
+
+            if score >= THRESHOLD:
+                sender = None
+                if msg.from_user:
+                    sender = msg.from_user.first_name or msg.from_user.username or str(msg.from_user.id)
+                text = (msg.text or msg.caption or "")[:2000]
+                item = {
+                    "chat_id": chat_id, "chat_title": chat_title, "message_id": msg.id,
+                    "sender": sender, "text": text, "score": score,
+                    "has_media": bool(msg.photo or msg.video or msg.document),
+                    "url": f"https://t.me/c/{str(chat_id).replace('-100', '')}/{msg.id}" if chat_id < 0 else None,
+                }
+                interesting.append(item)
+                group_found += 1
+                db.execute(
+                    "INSERT OR IGNORE INTO interesting (chat_id, chat_title, message_id, sender, text, score, captured_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                    (chat_id, chat_title, msg.id, sender, text, score, now),
+                )
+            else:
+                total_skipped += 1
+
+        update_group_stats(db, chat_id, chat_title, group_found, now)
+        db.commit()
+
+    await c.stop()
+    db.close()
+
+    log.info(f"Scanned {total_groups} groups, read {total_read} msgs, found {len(interesting)} interesting")
+
+    if not dry_run and interesting:
+        for item in interesting:
+            _print_item(item)
+
+    # Group quality summary
+    print(f"\n{'='*50}")
+    print(f"📊 GROUP QUALITY SUMMARY")
+    print(f"{'='*50}")
+    db2 = sqlite3.connect(DB_PATH)
+    rows = db2.execute(
+        "SELECT chat_title, total_scanned, interesting_found, last_interesting_at FROM group_stats ORDER BY interesting_found DESC LIMIT 50"
+    ).fetchall()
+    for title, scanned, found, last_interest in rows:
+        status = "🟢" if found >= 1 else "🟡" if scanned >= 3 else "⚪"
+        print(f"{status} {title} — {scanned} scans, {found} interesting, last signal: {last_interest or 'never'}")
+    db2.close()
+
+    return interesting
+
+
+def _print_item(item: dict):
+    print(f"\n{'='*50}")
+    print(f"📌 {item['chat_title']} [{item['score']}pts]")
+    if item['sender']: print(f"👤 {item['sender']}")
+    if item['has_media']: print(f"📎 [has media]")
+    if item['url']: print(f"🔗 {item['url']}")
+    print(f"\n{item['text'][:500]}")
+    print(f"{'='*50}")
+
+
+if __name__ == "__main__":
+    import sys
+    dry_run = "--dry-run" in sys.argv
+    asyncio.run(scan_and_report(dry_run=dry_run))

backend/tg_filter.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -e
+cd ~/repos/t-youtube/backend
+export PYROGRAM_WORKDIR=/Users/jimmyg
+
+~/repos/t-youtube/backend/.venv/bin/python3 tg_filter.py 2>&1

docker-compose.yml

@@ -7,14 +7,15 @@ services:
       dockerfile: Dockerfile
     container_name: t-youtube
     restart: unless-stopped
-    network_mode: host
+    ports:
+      - "8001:8000"
+    env_file:
+      - .env
     environment:
-      - OPENAI_API_KEY=${OPENAI_API_KEY:-sk-Kq5JbgmnEEkdzTqNAQ6bV6nztQ0ngeHTHF9Vg8nUglQvrOlx}
-      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
-      - ANTHROPIC_BASE_URL=https://www.bytecatcode.org
-      - HTTP_PROXY=http://100.70.115.1:8118
-      - HTTPS_PROXY=http://100.70.115.1:8118
-      - NO_PROXY=localhost,127.0.0.1,100.0.0.0/8,192.168.0.0/16
+      - DEEPSEEK_API_KEY=${DEEPSEEK_API_KEY}
+      - DEEPSEEK_BASE_URL=https://api.deepseek.com
+      - DEEPSEEK_MODEL=deepseek-chat
+      - DB_DIR=/app/data
     volumes:
       - ./data:/app/data
       - ./config:/app/config

docs/PDD.md

@@ -0,0 +1,21 @@
+# Product Definition Document — T YouTube
+
+## Vision
+
+A text-first YouTube experience — read transcripts, get AI summaries, never watch a video.
+
+## Goals
+
+1. **No-video YouTube** — read subscriptions, watch content as text, never open the YouTube app
+2. **Daily digest** — AI-summarized subscription feed delivered to Telegram daily
+3. **GFW-proof** — works reliably from China despite YouTube blocks
+
+## Target Users
+
+Self (Jimmy Gan). Primary use: morning skim of YouTube subscriptions via text summaries.
+
+## Success Metrics
+
+- Daily sync completes without errors
+- Telegram digest delivered every morning
+- < 5s page load for dashboard

docs/PLAN.md

@@ -0,0 +1,61 @@
+# Remaining Tasks
+
+## P0 — Immediate Follow-ups
+
+### 1. Deploy Sprint 1 code to NAS (Docker rebuild)
+Sprint 1 fixes (`575fdab`+, agent_worker.py, proxy support, scroll-based mark-read) are committed and pushed to Gitea, but **NAS container is running old code** — `agent_worker.py` missing. 
+- Rebuild Docker image with latest code
+- Restart container
+- Verify `AGENT_ENABLED=true` and `QWEN_BASE_URL=http://localhost:8080` in container env
+
+### 2. Fix daily sync cron
+`t-youtube-daily-sync` errored last run (Jul 9 03:55). Check the sync script at `run_sync.py` for the failure cause. The VPS-based `fetch_and_sync.sh` may have replaced the local sync cron — verify which is the active pipeline.
+
+### 3. Verify tg-group-filter first delivery
+Cron was fixed from `deliver: local` → `deliver: all`. First run at ~22:18 should deliver to Telegram. Check that the filter output reaches the user.
+
+---
+
+## P1 — High Value
+
+### 4. nas-tools main deploy (sidebar refactor)
+Dev CI is green. Sidebar now includes t-youtube, Media Management, Hermes. Just needs:
+```bash
+git checkout main
+git merge dev
+git push origin main
+```
+Then verify production deploy on `nas.jimmygan.com`.
+
+### 5. Connect Google AI Pro to Hermes
+User has Google AI Pro plan accessed via `ccg` → Antigravity proxy (`localhost:8081`). Configure Hermes to use it (Option 1 chosen: custom provider pointing at the proxy). This unlocks Gemini models at no extra cost, improving summarization and agent quality.
+
+---
+
+## P2 — Product & Brand
+
+### 6. t-youtube Sprint 2 (UX Overhaul)
+- Full-text search across video titles
+- Batch select / mark multiple videos read
+- Infinite scroll (cursor-based pagination)
+- Duration + view count in list
+- Transcript accordion in detail view
+
+### 7. t-youtube → public asset (brand play)
+Already built: vim-keyboard YouTube reader with AI summaries. Could be:
+- Twitter/X thread: "I built a better YouTube reader"
+- Open-source README with screenshots
+- Blog post about architecture (FastAPI + Svelte 5 + DeepSeek)
+
+---
+
+## P3 — Infrastructure
+
+### 8. Proxy env support in n8n / other services
+For stable operation from China.
+
+### 9. t-youtube DB backup to MBP
+Single source of truth. Add cron: `ssh nas "cat /volume1/docker/t-youtube/data/t_youtube.db" > ~/backups/t_youtube/$(date +%F).db`
+
+### 10. Cleanup old Gmail labels
+Old labels (Bank, Brokers, Fund, Login Notice, jobs, 购物) still in sidebar — not deleted, just archived.

docs/architecture.md

@@ -0,0 +1,200 @@
+# t-youtube — Text-Based YouTube Digest
+
+## Overview
+
+A self-hosted YouTube reader that syncs your subscriptions, generates AI summaries, and displays them in a Svelte dashboard. Designed to work around GFW restrictions in China and YouTube IP blocks on cloud providers.
+
+## Architecture
+
+```
+                         ┌─────────────────────────┐
+                         │   Oracle Tokyo VPS       │
+                         │  (free-amd-caddy)        │
+                         │                          │
+                         │  ┌──────────────────┐    │
+                         │  │ Caddy (port 443)  │    │
+                         │  │ reverse_proxy to  │────┼─── Cloudflare ─── Internet
+                         │  │ NAS via Tailscale │    │
+                         │  └──────────────────┘    │
+                         │                          │
+                         │  ┌──────────────────┐    │
+                         │  │ Cron (every 6h)   │    │
+                         │  │ fetch_and_sync.sh │────┼─── YouTube Data API
+                         │  └──────────────────┘    │
+                         └──────────┬───────────────┘
+                                    │ Tailscale (DERP relay)
+                         ┌──────────┴───────────────┐
+                         │   NAS ds224plus           │
+                         │  (100.78.131.124)         │
+                         │                           │
+                         │  ┌───────────────────┐   │
+                         │  │ Caddy (port 8443)  │   │
+                         │  │ Let's Encrypt via  │   │
+                         │  │ Cloudflare DNS     │   │
+                         │  └───────────────────┘   │
+                         │                           │
+                         │  ┌───────────────────┐   │
+                         │  │ Authelia (9092)    │   │
+                         │  │ SSO + 2FA          │   │
+                         │  └───────────────────┘   │
+                         │                           │
+                         │  ┌───────────────────┐   │
+                         │  │ t-youtube (8001)  │   │
+                         │  │ FastAPI + Svelte  │   │
+                         │  │ SQLite DB          │   │
+                         │  └───────────────────┘   │
+                         │                           │
+                         │  ┌───────────────────┐   │
+                         │  │ Gitea (3300)       │   │
+                         │  │ git.jimmygan.com   │   │
+                         │  └───────────────────┘   │
+                         └──────────────────────────┘
+```
+
+## Data Flow
+
+1. **Fetch**: VPS cron runs every 6h → YouTube Data API v3 (subscriptions list) + RSS feeds → new video metadata → local SQLite DB
+2. **Summarize**: VPS reads new videos from DB → calls Qwen35B on MacBook (port 8085 via Tailscale) → title-only summaries → saves to DB
+3. **Sync**: VPS `cat` DB → SSH to NAS → `sudo tee` → overwrites NAS DB → restarts Docker container
+4. **Serve**: NAS Docker (FastAPI + Svelte) → serves dashboard to browser → Authelia SSO in front
+
+## Deployment
+
+### VPS (Oracle Tokyo)
+
+Files in `/tmp/yt-fetch/`:
+
+| File | Purpose |
+|------|---------|
+| `fetch_and_sync.sh` | Entry point — fetch → summarize → sync |
+| `fetcher.py` | YouTube Data API + RSS hybrid fetcher |
+| `summarize_new.py` | Title-based summarization via Qwen |
+| `db.py` | SQLite schema |
+| `auth.py` | OAuth credential management |
+| `token.pickle` | YouTube OAuth token |
+| `cookies.txt` | YouTube cookies (for transcript fallback) |
+
+Cron: `0 */6 * * * bash /tmp/yt-fetch/fetch_and_sync.sh`
+
+### NAS
+
+Docker container at `/volume1/docker/t-youtube/`:
+- `docker-compose.yml` — port 8001:8000, env vars for DeepSeek/Qwen
+- `.env` — `DEEPSEEK_API_KEY`, `API_TOKEN`
+- `data/t_youtube.db` — SQLite database (synced from VPS)
+
+### MacBook
+
+Qwen models run via `llama-server`:
+- Port 8080: Qwen3.6-27B-Q8 (27B params, ~30 t/s, 256K ctx)
+- Port 8085: Qwen3.6-35B-A3B-Q8 (35B MoE, 3.5B active, faster)
+- Both with `--spec-type draft-mtp` for speculative decoding
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `DEEPSEEK_API_KEY` | — | DeepSeek API key for summarization |
+| `DEEPSEEK_BASE_URL` | `https://api.deepseek.com` | API endpoint |
+| `DEEPSEEK_MODEL` | `deepseek-chat` | Model name |
+| `API_TOKEN` | — | Bearer token for dashboard write ops |
+| `AGENT_ENABLED` | `false` | Enable agent queue worker |
+| `QWEN_BASE_URL` | `http://localhost:8080` | Local Qwen endpoint |
+| `HTTP_PROXY` | — | Proxy for fetcher/summarizer (China bypass) |
+| `AGENT_POLL_INTERVAL` | `30` | Agent queue poll seconds |
+| `AGENT_MAX_CONCURRENT` | `3` | Agent queue max workers |
+
+### Authelia Bypass
+
+API routes at `/api/*` bypass Authelia via `resources: ['^/api/']` in Authelia `access_control.yaml`. Frontend (`/`) requires SSO login.
+
+## API Endpoints
+
+| Endpoint | Method | Auth | Description |
+|----------|--------|------|-------------|
+| `/api/health` | GET | None | Health check |
+| `/api/config` | GET | None | Auth config (token required?) |
+| `/api/videos` | GET | None | List videos (status, channel, limit params) |
+| `/api/videos/fetch` | POST | Bearer | Trigger subscription sync |
+| `/api/videos/{id}/summarize` | POST | Bearer | Trigger single video summary |
+| `/api/videos/{id}/status` | POST | Bearer | Update status (pending/read/skipped) |
+| `/api/notes` | GET | None | List all notes |
+| `/api/notes/{id}` | GET/POST | Bearer (POST) | Get/save note |
+| `/api/notes/migrate` | POST | Bearer | Migrate localStorage notes to server |
+| `/api/agent-queue` | GET/POST | Bearer (POST) | List/add agent queue items |
+| `/api/channels` | GET | None | List distinct channels |
+| `/api/auto_categories.json` | GET | None | Channel category mapping |
+
+## Sprint Plan
+
+### Sprint 1 ✅ (Current — Deployed)
+- Agent queue worker (disabled by default)
+- Proxy support for fetcher + summarizer
+- Auto-mark-read on navigate away (not timer)
+- VPS fetch + summarize cron
+- run_tests.sh fixes
+- All 2,674 videos summarized (title-based)
+
+### Sprint 2 — UX Overhaul (Next)
+- Full-text search across video titles
+- Batch select → mark read/skip
+- Infinite scroll / pagination
+- Display duration + view count
+- Transcript accordion in detail panel
+
+### Sprint 3 — Polish & Monitoring
+- Stats dashboard (videos/day, channel health, sync lag)
+- Auto-purge old read videos (configurable TTL)
+- Broken channel detection (404 on RSS)
+- Cron failure alerts via Telegram bot
+- Scheduled DB backup to MacBook
+
+### Sprint 4 — Code Quality
+- Split `main.py` into routers
+- Cursor/offset pagination on API
+- Rate limiting middleware
+- aiosqlite connection pooling
+
+## Known Issues
+
+### Transcripts Blocked
+YouTube transcripts inaccessible from all our locations:
+- **Oracle Cloud VPS**: YouTube blocks cloud provider IPs
+- **MacBook (China)**: GFW blocks YouTube API endpoints
+- **YouTube Data API captions.download**: 403 Forbidden for non-owned videos
+
+**Workaround**: Title + description-based summaries via Qwen. Full transcripts need a Japanese residential proxy ($3-5/month).
+
+### auth.jimmygan.com from LAN
+Accessing `auth.jimmygan.com` from LAN shows Immich (photos.jimmygan.com) instead of Authelia. Caused by NAS port 443 routing — DSM nginx still owns port 443 and routes Immich for unmatched domains.
+
+### Gitea SSL
+Uses Let's Encrypt **staging** certificates (acme-staging) — browsers may show untrusted cert warnings.
+
+## Development
+
+### Local Setup
+```bash
+cd ~/repos/t-youtube
+# Backend
+cd backend && python3 -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt
+python3 main.py  # runs on :8000
+
+# Frontend
+cd frontend && npm install && npm run dev  # runs on :5173 with API proxy
+```
+
+### Testing
+```bash
+cd ~/repos/t-youtube && bash run_tests.sh
+# 23 tests across db, fetcher, summarizer, main, agent_worker
+```
+
+### Deploy to NAS
+```bash
+cd ~/repos/t-youtube
+git add -A && git commit -m "..." && git push gitea main:master
+ssh nas 'cd /volume1/docker/t-youtube && git pull origin master && docker compose up -d --build'
+```

docs/configuration.md

@@ -0,0 +1,152 @@
+# t-youtube Configuration Guide
+
+## Environment Variables
+
+### Backend (.env)
+```bash
+# Database path
+DB_DIR=/volume1/docker/t-youtube/backend
+
+# API Token (for write operations)
+API_TOKEN=<your-api-token>
+
+# DeepSeek API (for summarization)
+DEEPSEEK_API_KEY=<your-key>
+
+# YouTube Data API v3
+GOOGLE_APPLICATION_CREDENTIALS=/path/to/credentials.json
+```
+
+### Docker Compose
+```yaml
+version: "3"
+services:
+  t-youtube:
+    build: .
+    ports:
+      - "8001:8001"
+    environment:
+      - DB_DIR=/backend/data
+      - API_TOKEN=<your-token>
+      - DEEPSEEK_API_KEY=<your-key>
+    volumes:
+      - ./backend/data:/backend/data
+```
+
+## API Token Management
+
+### Generation
+```bash
+python3 -c "import secrets; print('api-' + secrets.token_urlsafe(32))"
+```
+
+### Frontend Setup
+- First-time users see a token setup modal
+- Token stored in localStorage
+- Bearer token sent with all API write requests
+
+### Backend Validation
+- Middleware checks `Authorization: Bearer <token>` for POST/PATCH/DELETE on `/api/*`
+- Returns 401 JSON for invalid tokens
+- GET endpoints remain open to authenticated frontend users
+
+## Database Management
+
+### Location
+- **Path**: `/volume1/docker/t-youtube/backend/t_youtube.db`
+- **Type**: SQLite (aiosqlite)
+- **Backup**: Copy the `.db` file before any schema changes
+
+### Schema Migrations
+- Use `sqlite3` CLI or a migration script
+- Always add indexes after schema changes
+- Example:
+  ```bash
+  sqlite3 t_youtube.db "CREATE INDEX IF NOT EXISTS idx_x ON table(column);"
+  ```
+
+### Daily Sync Configuration
+
+#### Cron Job
+```bash
+# Runs every day at 3 AM
+0 3 * * * /path/to/run_sync.py >> /var/log/t-youtube-sync.log 2>&1
+```
+
+#### Fetcher Settings
+- **RSS**: Free, unlimited, ~2000 channels
+- **YouTube Data API v3**: ~50 units per sync
+- **Rotation**: Fetches in slices to avoid timeouts
+- **Retry**: Automatic retry on failure
+
+#### Summarizer Settings
+- **Model**: `deepseek-chat` via DeepSeek API
+- **Timeout**: 30 seconds per video
+- **Fallback**: Video description if transcript unavailable
+- **Language**: Follows content language (Chinese → Chinese summary)
+
+## Authelia Integration
+
+### Authentication Flow
+1. User accesses protected domain
+2. Caddy forwards request to Authelia (`127.0.0.1:9092`)
+3. Authelia checks session/2FA
+4. If no session → redirect to `auth.jimmygan.com`
+5. If session exists → return 200 (allowed)
+
+### 2FA Methods
+- **WebAuthn (Primary)**: Passkey via iCloud Keychain/Bitwarden
+- **TOTP (Fallback)**: Time-based one-time password
+
+### Configuration
+- **Address**: `127.0.0.1:9092`
+- **Database**: SQLite (`/volume1/docker/authelia/config/db.sqlite3`)
+- **LDAP Backend**: LLDAP (`lldap:3890`)
+- **Session**: 1 hour expiration, 5 minute inactivity timeout
+
+### Restart Authelia
+```bash
+cd /volume1/docker/authelia && /usr/local/bin/docker compose restart authelia
+```
+
+## Caddy Configuration
+
+### VPS Caddy (Public)
+- **Port**: 443
+- **TLS**: Let's Encrypt (HTTP-01)
+- **Authelia**: `forward_auth 100.78.131.124:9092`
+- **DNS**: dnsmasq → VPS Tailscale IP `100.109.198.126`
+
+### NAS Caddy (Local/Tailscale)
+- **Port**: 8443 (fallback due to SNI bug)
+- **TLS**: Cloudflare DNS-01
+- **Authelia**: `forward_auth 127.0.0.1:9092`
+- **SNI Bug**: Per-site `tls` blocks cause cert routing issues
+- **Workaround**: Global TLS config + dnsmasq → VPS Tailscale IP
+
+### Reloading Caddy
+```bash
+# VPS
+ssh caddy-vps "sudo systemctl reload caddy"
+
+# NAS
+cd /volume1/docker/caddy && /usr/local/bin/docker compose restart caddy
+```
+
+## Monitoring & Health
+
+### Health Check
+```bash
+curl -s https://yt.jimmygan.com/api/health
+# Expected: {"status": "ok"}
+```
+
+### Sync Status
+- Check `run_sync.py` logs in `/var/log/t-youtube-sync.log`
+- Monitor DB for new videos/summaries
+- Verify cron job is active: `crontab -l`
+
+### Database Size
+```bash
+ls -lh /volume1/docker/t-youtube/backend/t_youtube.db
+```

docs/progress.md

@@ -0,0 +1,102 @@
+# t-youtube Progress Tracking
+
+## Session 2026-07-09: Agent Queue, Notes Migration, Architecture Documentation
+
+### Completed
+- [x] **Agent Queue Feature**:
+  - Added `agent_queue` table to SQLite DB
+  - Implemented `POST/GET/DELETE` endpoints in `main.py`
+  - Created `agent_worker.py` skeleton for processing pending items
+  - Frontend "Agent Queue" tab (Svelte 5) with status indicators
+- [x] **Notes Migration**:
+  - Moved notes from localStorage to server-side DB (`video_notes` table)
+  - Added `POST/GET/DELETE` endpoints for notes
+  - Implemented non-blocking localStorage migration script
+- [x] **Database Optimization**:
+  - Added indexes on `video_id` for `agent_queue` and `video_notes` tables
+- [x] **Authelia Configuration**:
+  - Attempted passwordless mode (failed due to unsupported key in Authelia v4)
+  - Reverted to standard 2FA (WebAuthn/TOTP)
+- [x] **Documentation**:
+  - Created `docs/` folder with `architecture.md` and `progress.md`
+  - Documented all API endpoints, DB schema, infrastructure, and known issues
+
+### In Progress
+- [ ] **Agent Worker Logic**:
+  - `agent_worker.py` needs actual LLM/feature-creation logic
+  - Pending: Define workflow for processing queued items
+- [ ] **YouTube Sync Monitoring**:
+  - Daily cron at 3 AM is active
+  - Pending: Monitor next run for errors/progress
+
+### Planned
+- [ ] **Channel Categorization**:
+  - ~119 channels remain uncategorized
+  - Consider moving `AUTO_CATEGORIES` to server-side JSON config
+- [ ] **Transcript Fallback**:
+  - Implement browser-based scraping (playwright/selenium) for the remaining 10%
+  - High complexity/resource usage trade-off
+- [ ] **Performance Monitoring**:
+  - Add health check endpoints for sync status
+  - Implement error logging/reporting
+
+## Session 2026-07-05 to 2026-07-08: Initial Development
+
+### Key Milestones
+- [x] **YouTube Data API v3 + RSS Hybrid**: Replaced yt-dlp/cookies approach
+  - Free, unlimited sync (~50 units/sync for 200+ channels)
+  - 2414 new videos discovered in first run
+- [x] **AI Summarization**: DeepSeek API integration (was Claude/bytecatcode)
+  - Chinese content → Chinese summary; English content → English summary
+  - ~2.1s per video, ~$0.001 each
+- [x] **Frontend Overhaul**:
+  - AI Digest as hero element
+  - Keyboard navigation (`j/k/↑↓`, `r/m`, `s`, `n`, `Enter`, `?`)
+  - Dark/light mode toggle
+  - Channel filter dropdown with auto-generated categories
+  - Auto-read after 3s silent mark
+- [x] **Agent Queue Integration**:
+  - "Save to Agent" feature: notes ARE prompts for Hermes agents
+  - Queue tab with pending/processing/done status
+  - Cross-device note sync (localStorage → server DB)
+
+### Technical Decisions
+1. **API Token Auth**: Bearer token for API writes, Authelia SSO for frontend
+2. **SQLite**: Simple, reliable, no external dependencies for single-user setup
+3. **DeepSeek API**: Cost-effective for summarization (~$0.001/video)
+4. **Svelte 5**: Reactivity model, keyboard workflow, small bundle size
+5. **RSS + YouTube Data API**: Free tier sufficient, avoids cookie/yt-dlp maintenance
+
+## Session 2026-07-04: NAS & Authelia Setup
+
+### Completed
+- [x] NAS Caddy port 443 conflict resolved (DSM nginx)
+- [x] dnsmasq → VPS Caddy Tailscale IP (100.109.198.126)
+- [x] Authelia WebAuthn enabled, passkey registered
+- [x] TOTP reset for jimmy, default 2FA set to WebAuthn
+- [x] Caddy SNI bug workaround (global TLS config, port 8443 fallback)
+
+## Known Issues & Resolutions
+
+### Authelia Passwordless Failure
+- **Issue**: `webauthn.passwordless: true` caused boot loop (`configuration key not expected`)
+- **Root Cause**: Unsupported configuration key in current Authelia version
+- **Resolution**: Reverted to standard 2FA (WebAuthn/TOTP)
+
+### YouTube Transcript Blocking
+- **Issue**: 90% of videos have transcripts; 10% fail due to Oracle Cloud IP blocking
+- **Root Cause**: YouTube IP-based restrictions
+- **Resolution**: Fallback to video description summaries; consider browser-based scraping later
+
+### NAS Caddy SNI Bug
+- **Issue**: NAS Caddy serves first cached cert for all SNI names
+- **Root Cause**: Per-site `tls { ... }` blocks conflict with global auto_https policy
+- **Resolution**: Global TLS config + dnsmasq → VPS Caddy Tailscale IP
+
+## Metrics & Performance
+- **Videos in DB**: ~2414+ (initial sync)
+- **Channels**: ~229 subscribed
+- **Sync Time**: ~2-3 minutes for all channels
+- **Summarization**: ~2.1s/video, ~$0.001 each via DeepSeek
+- **Frontend Load Time**: 0.14-0.22s (API responses)
+- **Daily API Usage**: ~50 units (well within 10,000/day free tier)

docs/specs/active.md

@@ -0,0 +1 @@
+sprint-001-sync-reliability.md

docs/specs/sprint-001-sync-reliability.md

@@ -0,0 +1,32 @@
+# Sprint 001 — Sync Reliability & Telegram Delivery
+
+**Dates:** Active
+
+## Goals
+
+- Fix daily sync on NAS
+- Verify Telegram delivery pipeline
+- Stabilize subscription fetching behind GFW
+
+## Tasks
+
+### T1: Fix daily sync cron
+
+**Description:**
+`t-youtube-daily-sync` errored last run. Determine if `run_sync.py` is the active pipeline or if VPS-based `fetch_and_sync.sh` replaced it. Fix whichever is active.
+
+**ACs:**
+- [ ] Daily sync completes without errors
+- [ ] New videos appear in dashboard
+
+**Impl Notes:**
+Check NAS cron logs. VPS sync fires every 6h.
+
+### T2: Verify tg-group-filter delivery
+
+**Description:**
+Cron switched from `deliver: local` to `deliver: all`. Confirm Telegram delivery works for filtered results.
+
+**ACs:**
+- [ ] Telegram receives filtered video digest
+- [ ] No duplicate deliveries

docs/troubleshooting.md

@@ -0,0 +1,194 @@
+# t-youtube Troubleshooting Guide
+
+## Common Issues
+
+### 1. Site Down / 502 Bad Gateway
+- **Cause**: t-youtube container not running or Authelia down
+- **Check**:
+  ```bash
+  ssh nas 'docker ps | grep t-youtube'
+  ssh nas 'docker ps | grep authelia'
+  ```
+- **Fix**:
+  ```bash
+  cd /volume1/docker/t-youtube && /usr/local/bin/docker compose up -d
+  cd /volume1/docker/authelia && /usr/local/bin/docker compose restart authelia
+  ```
+
+### 2. Authelia Loop / Login Fails
+- **Cause**: WebAuthn/TOTP misconfiguration or session expired
+- **Check Authelia logs**:
+  ```bash
+  ssh nas 'docker logs authelia --tail 20'
+  ```
+- **Fix**:
+  - Clear browser cache/cookies
+  - Reset WebAuthn via Authelia DB (see below)
+  - Check dnsmasq config (should point to VPS Tailscale IP)
+
+### 3. YouTube Data API Quota Exceeded
+- **Symptom**: Fetcher returns empty results or 403 errors
+- **Cause**: Daily quota limit reached (10,000 units)
+- **Check**:
+  ```bash
+  ssh nas 'docker logs t-youtube 2>&1 | grep -i "quota\|403"'
+  ```
+- **Fix**:
+  - Wait until next day (quota resets at 00:00 UTC)
+  - Reduce number of channels or increase sync interval
+  - Monitor usage in Google Cloud Console
+
+### 4. Summarization Failing
+- **Symptom**: Videos show "No summary" or generic descriptions
+- **Cause**: DeepSeek API key invalid or rate limited
+- **Check**:
+  ```bash
+  ssh nas 'docker logs t-youtube 2>&1 | grep -i "summariz\|deepseek"'
+  ```
+- **Fix**:
+  - Verify `DEEPSEEK_API_KEY` in `.env`
+  - Test API key manually:
+    ```bash
+    curl -s -X POST https://api.deepseek.com/chat/completions \
+      -H "Authorization: Bearer ***
+      -H "Content-Type: application/json" \
+      -d '{"model": "deepseek-chat", "messages": [{"role": "user", "content": "test"}]}'
+    ```
+
+### 5. Database Locked/Corrupted
+- **Symptom**: API returns 500 errors or hangs
+- **Cause**: Concurrent write operations or unexpected shutdown
+- **Fix**:
+  ```bash
+  cd /volume1/docker/t-youtube/backend
+  cp t_youtube.db t_youtube.db.backup
+  sqlite3 t_youtube.db "PRAGMA integrity_check;"
+  # If corrupted, restore from backup or recreate
+  ```
+
+### 6. Caddy Config Issues
+- **Symptom**: 502/503 errors, wrong cert, or domain unreachable
+- **Check**:
+  ```bash
+  ssh caddy-vps "sudo caddy validate --config /etc/caddy/Caddyfile"
+  ssh nas 'docker exec caddy caddy validate --config /etc/caddy/Caddyfile'
+  ```
+- **Fix**:
+  - Validate config
+  - Reload/restart Caddy
+  - Check TLS certs:
+    ```bash
+    echo | openssl s_client -connect 161.33.182.109:443 -servername yt.jimmygan.com 2>&1 | openssl x509 -noout -subject -dates
+    ```
+
+## API Debugging
+
+### Check Video List
+```bash
+curl -s https://yt.jimmygan.com/api/videos | python3 -m json.tool | head -20
+```
+
+### Check Agent Queue
+```bash
+curl -s -H "Authorization: Bearer *** https://yt.jimmygan.com/api/agent-queue
+```
+
+### Check Notes
+```bash
+curl -s -H "Authorization: Bearer *** https://yt.jimmygan.com/api/notes
+```
+
+### Check Channel List
+```bash
+curl -s -H "Authorization: Bearer *** https://yt.jimmygan.com/api/channels
+```
+
+### Test Summarization
+```bash
+curl -s -X POST -H "Authorization: Bearer ***
+  -H "Content-Type: application/json" \
+  -d '{"video_id": "<video_id>"}' \
+  https://yt.jimmygan.com/api/agent-queue/<video_id>/summarize
+```
+
+## Database Queries
+
+### Count Videos by Status
+```sql
+SELECT status, COUNT(*) FROM videos GROUP BY status;
+```
+
+### Count Agent Queue Items by Status
+```sql
+SELECT status, COUNT(*) FROM agent_queue GROUP BY status;
+```
+
+### Find Videos Without Summaries
+```sql
+SELECT video_id, title FROM videos WHERE summary IS NULL OR summary = '';
+```
+
+### Check DB Size
+```bash
+ls -lh /volume1/docker/t-youtube/backend/t_youtube.db
+```
+
+## Logs
+
+### t-youtube Logs
+```bash
+ssh nas 'docker logs t-youtube --tail 50'
+ssh nas 'docker logs t-youtube --tail 50 --since 1h'
+```
+
+### Authelia Logs
+```bash
+ssh nas 'docker logs authelia --tail 50'
+```
+
+### Sync Logs
+```bash
+ssh nas 'cat /var/log/t-youtube-sync.log'
+ssh nas 'tail -100 /var/log/t-youtube-sync.log'
+```
+
+### Caddy Logs (VPS)
+```bash
+ssh caddy-vps "sudo journalctl -u caddy --since '1 hour ago'"
+ssh caddy-vps "sudo journalctl -u caddy --no-pager -n 30"
+```
+
+## Recovery Procedures
+
+### Full System Restart
+```bash
+# 1. Restart services
+cd /volume1/docker/authelia && /usr/local/bin/docker compose restart authelia
+cd /volume1/docker/t-youtube && /usr/local/bin/docker compose up -d
+
+# 2. Verify
+curl -s https://yt.jimmygan.com/api/health
+curl -s https://auth.jimmygan.com/api/health
+```
+
+### Database Backup & Restore
+```bash
+# Backup
+cp /volume1/docker/t-youtube/backend/t_youtube.db /tmp/t-youtube-backup-$(date +%Y%m%d).db
+
+# Restore
+cp /tmp/t-youtube-backup-20260709.db /volume1/docker/t-youtube/backend/t_youtube.db
+cd /volume1/docker/t-youtube && /usr/local/bin/docker compose restart t-youtube
+```
+
+### Authelia User Reset (if locked out)
+```bash
+# Stop Authelia
+ssh nas 'docker stop authelia'
+
+# Reset TOTP for jimmy
+ssh nas 'sqlite3 /volume1/docker/authelia/config/db.sqlite3 "DELETE FROM totp_configurations WHERE username='\'jimmy'\'';"'
+
+# Restart Authelia
+ssh nas 'docker start authelia'
+```

frontend/src/auto_categories.js

@@ -0,0 +1 @@
+export default {"AI Engineer": "AI & Tech", "AI-Fan AI研究室-帆哥": "AI & Tech", "AI大模型": "AI & Tech", "AI探索与发现": "AI & Tech", "Aurora Tech": "AI & Tech", "Claude": "AI & Tech", "ColdFusion": "AI & Tech", "Data Is Beautiful": "AI & Tech", "DeepLearningAI": "AI & Tech", "Google": "AI & Tech", "Google Cloud Tech": "AI & Tech", "Lex Fridman": "AI & Tech", "NiceKate AI": "AI & Tech", "PC Sim": "AI & Tech", "Stanford Online": "AI & Tech", "The Linux Foundation": "AI & Tech", "回到Axton": "AI & Tech", "回形针PaperClip": "AI & Tech", "林亦LYi": "AI & Tech", "硅谷101播客": "AI & Tech", "老石谈芯": "AI & Tech", "鲲鹏Talk": "AI & Tech", "3D Beast": "3D & Design", "Arrimus3D Modeling and Design": "3D & Design", "Blender": "3D & Design", "Blender Guru": "3D & Design", "Creators 3D": "3D & Design", "Designfusion": "3D & Design", "Foundry": "3D & Design", "Grant Abbitt (Gabbitt)": "3D & Design", "Gravity Sketch": "3D & Design", "Hyperganic": "3D & Design", "MSLattice": "3D & Design", "Manolo Remiddi": "3D & Design", "Rhino 3D (Rhinoceros3d official)": "3D & Design", "Shaper3d": "3D & Design", "nTop": "3D & Design", "spherene AG": "3D & Design", "魔界造物": "3D & Design", "Chuck Severance": "Programming", "Coursera": "Programming", "freeCodeCamp.org": "Programming", "Kevin Stratvert": "Programming", "Leila Gharani": "Programming", "LinkedIn Learning": "Programming", "Metabase": "Programming", "n8n": "Programming", "The Coding Gopher": "Programming", "Brian Casel": "Programming", "code秘密花园": "Programming", "cs tech": "Programming", "fequalsf": "Programming", "openscreencast": "Programming", "技术爬爬虾  TechShrimp": "Programming", "林本兔Limbuntu": "Programming", "Best Choice Review": "Hardware & Reviews", "Marques Brownlee": "Hardware & Reviews", "TESTV": "Hardware & Reviews", "先看评测": "Hardware & Reviews", "极客湾Geekerwan": "Hardware & Reviews", "硬核拆解": "Hardware & Reviews", "笔吧评测室": "Hardware & Reviews", "差评硬件部": "Hardware & Reviews", "充电头网": "Hardware & Reviews", "Apple Developer": "Apple Dev", "Made by Google": "Apple Dev", "Allen的分享": "Apple Dev", "Sypnotix": "Apple Dev", "8K World": "Photography", "Can Fiona": "Photography", "小天fotos": "Photography", "影像极客Fotogeeker": "Photography", "摄影师PHiL": "Photography", "虚空光影CosmosFilm": "Photography", "路易斯 LouisDrone": "Photography", "Bruno Mars": "Music", "GraceLeeMusic": "Music", "Katie Melua": "Music", "The Weeknd": "Music", "TheWeekndVEVO": "Music", "杰威爾歌詞MV頻道JVR Lyric MV": "Music", "薛汀哲": "Music", "Salah Trainer": "Sports", "Skills N Talents (swimming)": "Sports", "TotalSports TV": "Sports", "WorldSBK": "Sports", "Everyday Cycling": "Sports", "爱羽客羽毛球网": "Sports", "adidas": "Sports", "Sneaks & Feet极客鞋谈": "Automotive", "TOP的遥控玩具": "Automotive", "悟空的日常": "Automotive"}

frontend/src/auto_categories.json

@@ -0,0 +1 @@
+{"AI Engineer": "AI & Tech", "AI-Fan AI\u7814\u7a76\u5ba4-\u5e06\u54e5": "AI & Tech", "AI\u5927\u6a21\u578b": "AI & Tech", "AI\u63a2\u7d22\u4e0e\u53d1\u73b0": "AI & Tech", "Aurora Tech": "AI & Tech", "Claude": "AI & Tech", "ColdFusion": "AI & Tech", "Data Is Beautiful": "AI & Tech", "DeepLearningAI": "AI & Tech", "Google": "AI & Tech", "Google Cloud Tech": "AI & Tech", "Lex Fridman": "AI & Tech", "NiceKate AI": "AI & Tech", "PC Sim": "AI & Tech", "Stanford Online": "AI & Tech", "The Linux Foundation": "AI & Tech", "\u56de\u5230Axton": "AI & Tech", "\u56de\u5f62\u9488PaperClip": "AI & Tech", "\u6797\u4ea6LYi": "AI & Tech", "\u7845\u8c37101\u64ad\u5ba2": "AI & Tech", "\u8001\u77f3\u8c08\u82af": "AI & Tech", "\u9cb2\u9e4fTalk": "AI & Tech", "3D Beast": "3D & Design", "Arrimus3D Modeling and Design": "3D & Design", "Blender": "3D & Design", "Blender Guru": "3D & Design", "Creators 3D": "3D & Design", "Designfusion": "3D & Design", "Foundry": "3D & Design", "Grant Abbitt (Gabbitt)": "3D & Design", "Gravity Sketch": "3D & Design", "Hyperganic": "3D & Design", "MSLattice": "3D & Design", "Manolo Remiddi": "3D & Design", "Rhino 3D (Rhinoceros3d official)": "3D & Design", "Shaper3d": "3D & Design", "nTop": "3D & Design", "spherene AG": "3D & Design", "\u9b54\u754c\u9020\u7269": "3D & Design", "Chuck Severance": "Programming", "Coursera": "Programming", "freeCodeCamp.org": "Programming", "Kevin Stratvert": "Programming", "Leila Gharani": "Programming", "LinkedIn Learning": "Programming", "Metabase": "Programming", "n8n": "Programming", "The Coding Gopher": "Programming", "Brian Casel": "Programming", "code\u79d8\u5bc6\u82b1\u56ed": "Programming", "cs tech": "Programming", "fequalsf": "Programming", "openscreencast": "Programming", "\u6280\u672f\u722c\u722c\u867e  TechShrimp": "Programming", "\u6797\u672c\u5154Limbuntu": "Programming", "Best Choice Review": "Hardware & Reviews", "Marques Brownlee": "Hardware & Reviews", "TESTV": "Hardware & Reviews", "\u5148\u770b\u8bc4\u6d4b": "Hardware & Reviews", "\u6781\u5ba2\u6e7eGeekerwan": "Hardware & Reviews", "\u786c\u6838\u62c6\u89e3": "Hardware & Reviews", "\u7b14\u5427\u8bc4\u6d4b\u5ba4": "Hardware & Reviews", "\u5dee\u8bc4\u786c\u4ef6\u90e8": "Hardware & Reviews", "\u5145\u7535\u5934\u7f51": "Hardware & Reviews", "Apple Developer": "Apple Dev", "Made by Google": "Apple Dev", "Allen\u7684\u5206\u4eab": "Apple Dev", "Sypnotix": "Apple Dev", "8K World": "Photography", "Can Fiona": "Photography", "\u5c0f\u5929fotos": "Photography", "\u5f71\u50cf\u6781\u5ba2Fotogeeker": "Photography", "\u6444\u5f71\u5e08PHiL": "Photography", "\u865a\u7a7a\u5149\u5f71CosmosFilm": "Photography", "\u8def\u6613\u65af LouisDrone": "Photography", "Bruno Mars": "Music", "GraceLeeMusic": "Music", "Katie Melua": "Music", "The Weeknd": "Music", "TheWeekndVEVO": "Music", "\u6770\u5a01\u723e\u6b4c\u8a5eMV\u983b\u9053JVR Lyric MV": "Music", "\u859b\u6c40\u54f2": "Music", "Salah Trainer": "Sports", "Skills N Talents (swimming)": "Sports", "TotalSports TV": "Sports", "WorldSBK": "Sports", "Everyday Cycling": "Sports", "\u7231\u7fbd\u5ba2\u7fbd\u6bdb\u7403\u7f51": "Sports", "adidas": "Sports", "Sneaks & Feet\u6781\u5ba2\u978b\u8c08": "Automotive", "TOP\u7684\u9065\u63a7\u73a9\u5177": "Automotive", "\u609f\u7a7a\u7684\u65e5\u5e38": "Automotive"}

frontend/src/routes/YoutubeDashboard.svelte

@@ -1,37 +1,183 @@
 <script>
   import { onMount, tick } from 'svelte';
-
+  
   let videos = $state([]);
   let selectedVideo = $state(null);
   let activeTab = $state('pending');
   let isLoading = $state(false);
   let isSyncing = $state(false);
   let syncMessage = $state('');
+  let pendingCount = $state(0);
   let theme = $state(localStorage.getItem('theme') || 'dark');
+  let apiToken = $state(localStorage.getItem('t-yt-token') || '');
+  let apiTokenInput = $state('');
+  let showTokenSetup = $state(false);
   let summaryPanel = $state(null);
-  let notes = $state(JSON.parse(localStorage.getItem('t-yt-notes') || '{}'));
+  let notes = $state({});
   let activeNote = $state(null);
-
+  let queueToAgent = $state(false);
+  let showHelp = $state(false);
+  let channelFilter = $state('');
+  let allChannels = $state([]);
+  let editingCategories = $state(false);
+  let prevSelectedId = $state(null);
+  
+  // Search state
+  let searchQuery = $state('');
+  let searchResults = $state([]);
+  let isSearching = $state(false);
+  let showSearchResults = $state(false);
+  
+  // Batch select state
+  let selectedVideoIds = $state(new Set());
+  let showBatchBar = $state(false);
+  
+  // Stats state
+  let statsData = $state(null);
+  let showStats = $state(false);
+  
+  // Agent queue state
+  let agentItems = $state([]);
+  let agentLoading = $state(false);
+  
+  // Stats fetcher
+  async function loadStats() {
+    try {
+      const res = await fetch('/api/stats');
+      if (res.ok) statsData = await res.json();
+    } catch(e) {}
+  }
+  
+  $effect(() => {
+    if (activeTab === 'stats' && !statsData) loadStats();
+  });
+  
+  $effect(() => {
+    if (activeTab === 'pending' && channelFilter) {
+      loadVideos();
+    } else if (activeTab === 'pending' && !channelFilter) {
+      loadVideos();
+    }
+  });
+  
+  // Auto-generated categories (AI-categorized)
+  const AUTO_CATEGORIES = {"AI Engineer":"AI & Tech","AI-Fan AI研究室-帆哥":"AI & Tech","AI大模型":"AI & Tech","AI探索与发现":"AI & Tech","Aurora Tech":"AI & Tech","Claude":"AI & Tech","ColdFusion":"AI & Tech","Data Is Beautiful":"AI & Tech","DeepLearningAI":"AI & Tech","Google":"AI & Tech","Google Cloud Tech":"AI & Tech","Lex Fridman":"AI & Tech","NiceKate AI":"AI & Tech","PC Sim":"AI & Tech","Stanford Online":"AI & Tech","The Linux Foundation":"AI & Tech","回到Axton":"AI & Tech","回形针PaperClip":"AI & Tech","林亦LYi":"AI & Tech","硅谷101播客":"AI & Tech","老石谈芯":"AI & Tech","鲲鹏Talk":"AI & Tech","3D Beast":"3D & Design","Arrimus3D Modeling and Design":"3D & Design","Blender":"3D & Design","Blender Guru":"3D & Design","Creators 3D":"3D & Design","Designfusion":"3D & Design","Foundry":"3D & Design","Grant Abbitt (Gabbitt)":"3D & Design","Gravity Sketch":"3D & Design","Hyperganic":"3D & Design","MSLattice":"3D & Design","Manolo Remiddi":"3D & Design","Rhino 3D (Rhinoceros3d official)":"3D & Design","Shaper3d":"3D & Design","nTop":"3D & Design","spherene AG":"3D & Design","魔界造物":"3D & Design","Chuck Severance":"Programming","Coursera":"Programming","freeCodeCamp.org":"Programming","Kevin Stratvert":"Programming","Leila Gharani":"Programming","LinkedIn Learning":"Programming","Metabase":"Programming","n8n":"Programming","The Coding Gopher":"Programming","Brian Casel":"Programming","code秘密花园":"Programming","cs tech":"Programming","fequalsf":"Programming","openscreencast":"Programming","技术爬爬虾  TechShrimp":"Programming","林本兔Limbuntu":"Programming","Best Choice Review":"Hardware & Reviews","Marques Brownlee":"Hardware & Reviews","TESTV":"Hardware & Reviews","先看评测":"Hardware & Reviews","极客湾Geekerwan":"Hardware & Reviews","硬核拆解":"Hardware & Reviews","笔吧评测室":"Hardware & Reviews","差评硬件部":"Hardware & Reviews","充电头网":"Hardware & Reviews","Apple Developer":"Apple Dev","Made by Google":"Apple Dev","Allen的分享":"Apple Dev","Sypnotix":"Apple Dev","8K World":"Photography","Can Fiona":"Photography","小天fotos":"Photography","影像极客Fotogeeker":"Photography","摄影师PHiL":"Photography","虚空光影CosmosFilm":"Photography","路易斯 LouisDrone":"Photography","Bruno Mars":"Music","GraceLeeMusic":"Music","Katie Melua":"Music","The Weeknd":"Music","TheWeekndVEVO":"Music","杰威爾歌詞MV頻道JVR Lyric MV":"Music","薛汀哲":"Music","Salah Trainer":"Sports","Skills N Talents (swimming)":"Sports","TotalSports TV":"Sports","WorldSBK":"Sports","Everyday Cycling":"Sports","爱羽客羽毛球网":"Sports","adidas":"Sports","Sneaks & Feet极客鞋谈":"Automotive","TOP的遥控玩具":"Automotive","悟空的日常":"Automotive"};
+  
+  let categories = $state({...AUTO_CATEGORIES});
+  
+  let channels = $derived([...new Set(videos.map(v => v.channel_name))].sort());
+  let filteredVideos = $derived(
+    channelFilter
+      ? channelFilter.startsWith('📁')
+        ? videos.filter(v => (categories[v.channel_name] || '') === channelFilter.replace('📁 ', ''))
+        : videos.filter(v => v.channel_name === channelFilter)
+      : videos
+  );
+  let catList = $derived([...new Set(Object.values(categories).flat())].sort());
+  
+  let noteIds = $derived(new Set(Object.keys(notes).filter(k => notes[k] && notes[k].trim())));
+  
+  // Search debouncer
+  let searchTimeout = null;
+  async function handleSearch(query) {
+    searchQuery = query;
+    if (!query || query.length < 2) {
+      showSearchResults = false;
+      return;
+    }
+    isSearching = true;
+    try {
+      const res = await fetch(`/api/videos/search?q=${encodeURIComponent(query)}&limit=50`);
+      if (res.ok) {
+        searchResults = await res.json();
+        showSearchResults = true;
+      }
+    } catch(e) {
+      console.error('Search failed:', e);
+    } finally {
+      isSearching = false;
+    }
+  }
+  
+  // Batch operations
+  function toggleSelect(videoId) {
+    const newSet = new Set(selectedVideoIds);
+    if (newSet.has(videoId)) {
+      newSet.delete(videoId);
+    } else {
+      newSet.add(videoId);
+    }
+    selectedVideoIds = newSet;
+    showBatchBar = newSet.size > 0;
+  }
+  
+  function selectAll() {
+    selectedVideoIds = new Set(filteredVideos.map(v => v.video_id));
+    showBatchBar = true;
+  }
+  
+  function clearSelection() {
+    selectedVideoIds = new Set();
+    showBatchBar = false;
+  }
+  
+  async function batchUpdate(status) {
+    if (selectedVideoIds.size === 0) return;
+    const ids = Array.from(selectedVideoIds);
+    try {
+      const res = await fetch('/api/videos/batch', {
+        method: 'POST',
+        headers: getAuthHeaders({ 'Content-Type': 'application/json' }),
+        body: JSON.stringify({ video_ids: ids, status })
+      });
+      if (res.ok) {
+        // Remove selected from local list
+        videos = videos.filter(v => !ids.includes(v.video_id));
+        clearSelection();
+        loadPendingCount();
+      }
+    } catch(e) {
+      console.error('Batch update failed:', e);
+    }
+  }
+  
+  function formatDuration(seconds) {
+    if (!seconds || seconds < 60) return '';
+    const m = Math.floor(seconds / 60);
+    const s = seconds % 60;
+    return `${m}:${s.toString().padStart(2, '0')}`;
+  }
+  
+  function formatViews(count) {
+    if (!count || count < 1000) return count || '';
+    if (count < 1000000) return `${(count / 1000).toFixed(1)}K`;
+    return `${(count / 1000000).toFixed(1)}M`;
+  }
+  
   function toggleTheme() {
     theme = theme === 'dark' ? 'light' : 'dark';
     localStorage.setItem('theme', theme);
     document.documentElement.className = theme;
   }
-
+  
   async function loadVideos() {
     isLoading = true;
     try {
       if (activeTab === 'notes') {
-        // Notes tab: show all pending videos, but only those with notes
+        // Notes tab: show only pending videos that have notes
         const res = await fetch(`/api/videos?status=pending&limit=50`);
         if (res.ok) {
           const all = await res.json();
-          videos = all.filter(v => notes[v.video_id]);
+          videos = all.filter(v => noteIds.has(v.video_id));
           if (videos.length > 0) selectedVideo = videos[0];
           else selectedVideo = null;
         }
       } else {
-        const res = await fetch(`/api/videos?status=${activeTab}&limit=50`);
+        const params = new URLSearchParams({status: activeTab, limit: '200'});
+        if (channelFilter && !channelFilter.startsWith('📁')) {
+          params.set('channel', channelFilter);
+        }
+        const res = await fetch(`/api/videos?${params}`);
         if (res.ok) {
           videos = await res.json();
           if (videos.length > 0) {
@@ -49,70 +195,269 @@
       isLoading = false;
     }
   }
-
+  
   async function syncSubscriptions() {
     isSyncing = true;
     syncMessage = 'Syncing...';
     try {
-      const res = await fetch('/api/videos/fetch', { method: 'POST' });
-      if (res.ok) setTimeout(() => { loadVideos(); isSyncing = false; syncMessage = ''; }, 6000);
-    } catch (err) { isSyncing = false; syncMessage = ''; }
+      const res = await fetch('/api/videos/fetch', { method: 'POST', headers: getAuthHeaders() });
+      if (res.ok) {
+        syncMessage = 'Sync started...';
+        setTimeout(() => { loadVideos(); isSyncing = false; syncMessage = ''; }, 6000);
+      } else {
+        isSyncing = false;
+        syncMessage = 'Sync failed';
+      }
+    } catch (err) { isSyncing = false; syncMessage = 'Network error'; }
   }
-
-  async function updateStatus(videoId, newStatus) {
-    await fetch(`/api/videos/${videoId}/status`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ status: newStatus }) });
-    videos = videos.filter(v => v.video_id !== videoId);
-    if (selectedVideo?.video_id === videoId) selectedVideo = videos[0] || null;
+  
+  async function updateStatus(videoId, newStatus, silent = false) {
+    await fetch(`/api/videos/${videoId}/status`, { method: 'POST', headers: getAuthHeaders({ 'Content-Type': 'application/json' }), body: JSON.stringify({ status: newStatus }) });
+    if (!silent) {
+      videos = videos.filter(v => v.video_id !== videoId);
+      if (selectedVideo?.video_id === videoId) selectedVideo = videos[0] || null;
+      if (videos.length < 20) loadVideos();
+    }
   }
-
+  
   async function generateSummary(videoId) {
     if (selectedVideo?.video_id === videoId) selectedVideo.summary = "Generating...";
-    await fetch(`/api/videos/${videoId}/summarize`, { method: 'POST' });
+    await fetch(`/api/videos/${videoId}/summarize`, { method: 'POST', headers: getAuthHeaders() });
     setTimeout(() => loadVideos(), 3000);
   }
-
+  
+  // ---- Server-side notes ----
+  
+  async function loadNotes() {
+    try {
+      const res = await fetch('/api/notes');
+      if (res.ok) {
+        const all = await res.json();
+        const map = {};
+        for (const item of all) map[item.video_id] = item.note_text;
+        notes = map;
+      }
+    } catch(e) { console.error('Failed to load notes:', e); }
+  }
+  
+  async function migrateLocalNotes() {
+    try {
+      const local = JSON.parse(localStorage.getItem('t-yt-notes') || '{}');
+      const keys = Object.keys(local).filter(k => local[k].trim());
+      if (keys.length === 0) return;
+      const missing = keys.filter(k => !notes[k]);
+      if (missing.length === 0) return;
+      const payload = {};
+      for (const k of missing) payload[k] = local[k];
+      await fetch('/api/notes/migrate', {
+        method: 'POST',
+        headers: getAuthHeaders({ 'Content-Type': 'application/json' }),
+        body: JSON.stringify({ notes: payload })
+      });
+      await loadNotes();
+    } catch(e) {}
+  }
+  
+  async function saveNote() {
+    const vid = selectedVideo?.video_id;
+    if (!vid) return;
+    const textarea = document.querySelector('#note-textarea');
+    const current = textarea ? textarea.value : (notes[vid] || '');
+    if (!current.trim()) return;
+    // Save to server
+    await fetch(`/api/notes/${vid}`, {
+      method: 'POST',
+      headers: getAuthHeaders({ 'Content-Type': 'application/json' } ),
+      body: JSON.stringify({ note_text: current, queue_to_agent: queueToAgent })
+    });
+    // Update local state
+    notes = {...notes, [vid]: current};
+    activeNote = null;
+    queueToAgent = false;
+  }
+  
+  // ---- Agent queue ----
+  
+  async function loadAgentQueue() {
+    agentLoading = true;
+    try {
+      const res = await fetch('/api/agent-queue');
+      if (res.ok) agentItems = await res.json();
+    } catch(e) { console.error('Failed to load agent queue:', e); }
+    finally { agentLoading = false; }
+  }
+  
+  async function removeAgentItem(id) {
+    await fetch(`/api/agent-queue/${id}`, { method: 'DELETE', headers: getAuthHeaders() });
+    agentItems = agentItems.filter(i => i.id !== id);
+  }
+  
+  async function initAuth() {
+    // Check if auth is enabled on the backend
+    try {
+      const res = await fetch('/api/config');
+      if (res.ok) {
+        const config = await res.json();
+        if (config.auth_enabled && !apiToken) {
+          showTokenSetup = true;
+          return false;
+        }
+      }
+    } catch(e) {}
+    showTokenSetup = false;
+    return true;
+  }
+  
+  async function setupToken() {
+    if (apiTokenInput.trim()) {
+      apiToken = apiTokenInput.trim();
+      localStorage.setItem('t-yt-token', apiToken);
+      showTokenSetup = false;
+    }
+  }
+  
+  function getAuthHeaders(extraHeaders = {}) {
+    const headers = { ...extraHeaders };
+    if (apiToken) {
+      headers['Authorization'] = 'Bearer ' + apiToken;
+    }
+    return headers;
+  }
+  
+  // ---- Lifecycle ----
+  
   $effect(() => { if (activeTab) loadVideos(); });
   $effect(() => {
+    // Scroll to top when switching videos
     if (selectedVideo && summaryPanel) {
       tick().then(() => summaryPanel.scrollTop = 0);
     }
+    const prevId = prevSelectedId;
+    prevSelectedId = selectedVideo?.video_id || null;
+    // NOTE: auto-mark-read is now handled by scroll-to-bottom detection (see below)
+    // and explicit user actions (r/Enter key or Read button).
   });
-  onMount(() => {
+  
+  // Scroll-based auto-mark-read: mark video as read when user scrolls to bottom of summary
+  let scrollReadTimer = $state(null);
+  function handleSummaryScroll() {
+    if (!summaryPanel || !selectedVideo || activeTab !== 'pending') return;
+    const threshold = 100; // px from bottom
+    const atBottom = (summaryPanel.scrollHeight - summaryPanel.scrollTop - summaryPanel.clientHeight) < threshold;
+    if (atBottom) {
+      // Debounce to avoid rapid-fire updates
+      if (scrollReadTimer) clearTimeout(scrollReadTimer);
+      scrollReadTimer = setTimeout(() => {
+        const sv = selectedVideo;
+        if (sv && sv.summary && !sv.summary.includes('Error') && !sv.summary.includes('📺 Short clip')) {
+          updateStatus(sv.video_id, 'read', true);
+        }
+      }, 500);
+    }
+  }
+  $effect(() => {
+    if (activeTab === 'agent') loadAgentQueue();
+  });
+  
+  onMount(async () => {
     document.documentElement.className = theme;
-    loadVideos();
+    await initAuth();
+    await loadNotes();
+    // Migrate localStorage notes to server (non-blocking)
+    migrateLocalNotes();
+    await loadVideos();
+    loaded = true;
+    loadPendingCount();
+    updateSyncTimer();
+    loadChannels();
     window.addEventListener('keydown', handleKeydown);
     return () => window.removeEventListener('keydown', handleKeydown);
   });
-
+  
+  function updateSyncTimer() {
+    const el = document.getElementById('sync-timer');
+    if (!el) return;
+    const now = new Date();
+    const next = new Date(now);
+    next.setHours(3, 0, 0, 0);
+    if (now > next) next.setDate(next.getDate() + 1);
+    const diff = next - now;
+    const h = Math.floor(diff / 3600000);
+    const m = Math.floor((diff % 3600000) / 60000);
+    el.textContent = `Next sync in ${h}h ${m}m`;
+    setTimeout(updateSyncTimer, 60000);
+  }
+  
+  async function loadPendingCount() {
+    try {
+      const res = await fetch('/api/videos?status=pending&limit=201');
+      if (res.ok) {
+        const all = await res.json();
+        pendingCount = all.length >= 201 ? '200+' : all.length;
+      }
+    } catch(e) {}
+  }
+  
+  async function loadChannels() {
+    try {
+      const res = await fetch('/api/channels');
+      if (res.ok) allChannels = await res.json();
+    } catch(e) {}
+  }
+  
   function handleKeydown(e) {
     if (!videos.length) return;
-    const idx = videos.findIndex(v => v.video_id === selectedVideo?.video_id);
+    if (e.target.tagName === 'TEXTAREA' || e.target.tagName === 'INPUT') return;
+    // If no video selected, let keyboard scroll the page naturally
+    if (!selectedVideo) return;
+    const idx = filteredVideos.findIndex(v => v.video_id === selectedVideo.video_id);
+    let nextIdx = idx;
     if (e.key === 'j' || e.key === 'ArrowDown') {
       e.preventDefault();
-      const next = idx < videos.length - 1 ? idx + 1 : 0;
-      selectedVideo = videos[next];
-      scrollToVideo(next);
+      if (idx < filteredVideos.length - 1) nextIdx = idx + 1; else return;
     } else if (e.key === 'k' || e.key === 'ArrowUp') {
       e.preventDefault();
-      const prev = idx > 0 ? idx - 1 : videos.length - 1;
-      selectedVideo = videos[prev];
-      scrollToVideo(prev);
+      if (idx > 0) nextIdx = idx - 1; else return;
     } else if (e.key === 'r' || e.key === 'm') {
       e.preventDefault();
       if (selectedVideo) updateStatus(selectedVideo.video_id, 'read');
+      return;
     } else if (e.key === 's') {
       e.preventDefault();
       if (selectedVideo) updateStatus(selectedVideo.video_id, 'skipped');
+      return;
+    } else if (e.key === 'n') {
+      e.preventDefault();
+      if (selectedVideo) activeNote = selectedVideo.video_id;
+      return;
+    } else if (e.key === 'Enter') {
+      e.preventDefault();
+      if (activeNote && selectedVideo && activeNote === selectedVideo.video_id) {
+        saveNote();
+      } else if (selectedVideo) {
+        updateStatus(selectedVideo.video_id, 'read');
+      }
+      return;
+    } else if (e.key === '?') {
+      e.preventDefault();
+      showHelp = !showHelp;
+      return;
+    } else {
+      return;
     }
+    selectedVideo = filteredVideos[nextIdx];
+    scrollToVideo(nextIdx);
   }
-
+  
   function scrollToVideo(index) {
-    requestAnimationFrame(() => {
-      const el = document.querySelector(`[data-video-index="${index}"]`);
-      if (el) el.scrollIntoView({ block: 'nearest', behavior: 'smooth' });
-    });
+    const el = document.querySelector(`[data-video-index="${index}"]`);
+    if (el) el.scrollIntoView({ block: 'nearest', behavior: 'instant' });
   }
-
+  
+  function autoFocus(node) {
+    requestAnimationFrame(() => node.focus());
+  }
+  
   function formatMarkdown(text) {
     if (!text) return '<p class="opacity-50 italic">No summary yet.</p>';
     let html = text.replace(/\*\*(.*?)\*\*/g, '<strong class="font-bold" style="color:var(--accent)">$1</strong>');
@@ -124,10 +469,51 @@
     }).join('');
     return html;
   }
+  
+  function noteWordCount(noteText) {
+    if (!noteText) return 0;
+    return noteText.trim().split(/\s+/).length;
+  }
+  
+  function formatDate(d) {
+    if (!d) return '';
+    return d.slice(0, 10);
+  }
+  
+  // Stats display helpers
+  function formatStatsNumber(n) {
+    if (n >= 1000000) return `${(n/1000000).toFixed(1)}M`;
+    if (n >= 1000) return `${(n/1000).toFixed(1)}K`;
+    return n.toString();
+  }
 </script>
 
 <div style="background:var(--bg-primary);color:var(--text-primary);height:100vh;overflow:hidden;display:flex;flex-direction:column">
-  <!-- Top bar -->
+    <!-- Token Setup Modal -->
+    {#if showTokenSetup}
+    <div class="fixed inset-0 z-50 flex items-center justify-center" style="background:rgba(0,0,0,0.5)">
+      <div class="bg-[var(--bg-secondary)] p-6 rounded-lg max-w-md w-full mx-4"
+           style="border:1px solid var(--border)">
+        <h2 class="text-xl font-bold mb-2">API Token Required</h2>
+        <p class="text-sm mb-4" style="color:var(--text-secondary)">
+          This app requires an API token to save notes and manage videos.
+          Please enter the token configured on the server.
+        </p>
+        <input type="text" bind:value={apiTokenInput}
+               placeholder="Enter API token..." class="w-full px-3 py-2 rounded"
+               style="background:var(--bg-primary);border:1px solid var(--border);color:var(--text-primary)"
+               onkeydown={(e) => e.key === 'Enter' && setupToken()} />
+        <div class="flex space-x-2 mt-4">
+          <button onclick={setupToken}
+                  class="px-4 py-2 rounded text-white font-bold"
+                  style="background:var(--accent)">
+            Submit
+          </button>
+        </div>
+      </div>
+    </div>
+    {/if}
+
   <header style="background:var(--bg-secondary);border-bottom:1px solid var(--border);" class="flex items-center justify-between px-5 py-2.5">
     <div class="flex items-center space-x-3">
       <span class="text-lg font-black tracking-wider" style="color:var(--accent)">T YouTube</span>
@@ -144,89 +530,354 @@
         title="Toggle theme">
         {theme === 'dark' ? '☀' : '☾'}
       </button>
+      {#if !isSyncing}
+        <span class="text-[10px]" style="color:var(--text-muted)" id="sync-timer"></span>
+      {/if}
     </div>
   </header>
 
   <div class="flex flex-1 overflow-hidden">
-    <!-- Left: video list -->
+    <!-- Left sidebar -->
     <aside style="width:280px;background:var(--bg-secondary);border-right:1px solid var(--border)" class="flex flex-col flex-shrink-0">
+      <!-- Tabs -->
       <div class="flex p-1.5" style="border-bottom:1px solid var(--border)">
-        {#each ['pending','read','skipped','notes'] as tab}
+        {#each ['pending','read','skipped','notes','stats','🤖 Agent'] as tab}
           <button onclick={() => activeTab = tab}
             class="flex-1 py-1.5 text-center text-[11px] font-bold rounded uppercase transition"
             style="color: {activeTab === tab ? 'var(--accent)' : 'var(--text-muted)'}">
-            {tab}
+            {tab === 'pending' && pendingCount ? `Pending (${pendingCount})` : tab === 'stats' ? '📊 Stats' : tab === '🤖 Agent' ? '🤖 Agent' : tab}
           </button>
         {/each}
       </div>
-      <div class="flex-1 overflow-y-auto divide-y" style="border-color:var(--border)">
-        {#each videos as video (video.video_id)}
-          {@const i = videos.indexOf(video)}
-          <button onclick={() => { selectedVideo = video; }}
-            data-video-index={i}
-            class="w-full text-left p-3 transition flex items-start space-x-3"
-            style="border-left:2px solid {selectedVideo?.video_id === video.video_id ? 'var(--accent)' : 'transparent'};
-                   background:{selectedVideo?.video_id === video.video_id ? 'var(--bg-tertiary)' : 'transparent'}">
-            <img src={video.thumbnail_url} alt="" class="w-20 h-12 rounded object-cover flex-shrink-0" style="background:var(--bg-tertiary)" />
-            <div class="min-w-0">
-              <span class="block text-[10px] font-semibold truncate" style="color:var(--accent)">{video.channel_name}</span>
-              <h3 class="text-xs font-bold line-clamp-2 leading-snug" style="color:var(--text-primary)">{video.title}</h3>
-              <span class="text-[10px] mt-0.5 block" style="color:var(--text-muted)">{video.publish_date || ''} {notes[video.video_id] ? '📝' : ''}</span>
+
+      <!-- Search bar (shown in pending/read/skipped tabs) -->
+      {#if activeTab !== '🤖 Agent' && activeTab !== 'stats' && activeTab !== 'notes'}
+        <div class="px-2 py-1.5" style="border-bottom:1px solid var(--border)">
+          <div class="relative">
+            <input type="text" 
+                   bind:value={searchQuery}
+                   oninput={handleSearch}
+                   placeholder="Search videos..."
+                   class="w-full text-[11px] p-1.5 rounded border"
+                   style="background:var(--bg-primary);color:var(--text-primary);border-color:var(--border)"
+                   onfocus={() => { if (searchResults.length) showSearchResults = true; }}
+                   onblur={() => setTimeout(() => showSearchResults = false, 200)}>
+            {#if isSearching}
+              <div class="absolute right-2 top-1.5 text-[9px] animate-spin" style="color:var(--accent)">↻</div>
+            {/if}
+          </div>
+        </div>
+      {/if}
+
+      <!-- Agent Queue tab content -->
+      {#if activeTab === '🤖 Agent'}
+        <div class="flex-1 overflow-y-auto" style="border-color:var(--border)">
+          {#if agentLoading}
+            <div class="flex items-center justify-center py-8 text-xs" style="color:var(--text-muted)">Loading...</div>
+          {:else if agentItems.length === 0}
+            <div class="flex items-center justify-center py-8 text-xs" style="color:var(--text-muted)">
+              <p>No items queued.<br>Write a note on a video and check "Send to Agent" to add one.</p>
             </div>
-          </button>
-        {/each}
-      </div>
+          {:else}
+            {#each agentItems as item}
+              <div class="p-3 border-b" style="border-color:var(--border)">
+                <div class="flex items-start space-x-2">
+                  <div class="min-w-0 flex-1">
+                    <p class="text-[11px] font-bold leading-tight line-clamp-2" style="color:var(--text-primary)">{item.title || 'Unknown'}</p>
+                    <p class="text-[10px] mt-1" style="color:var(--accent)">{item.channel_name || ''}</p>
+                    <p class="text-[10px] mt-1" style="color:var(--text-muted)">Prompt: {item.user_prompt.slice(0, 120)}{item.user_prompt.length > 120 ? '...' : ''}</p>
+                    <div class="flex items-center space-x-2 mt-1.5">
+                      <span class="text-[9px] px-1.5 py-0.5 rounded font-bold uppercase"
+                        style="background:{item.status === 'done' ? '#10b981' : item.status === 'processing' ? '#f59e0b' : item.status === 'failed' ? '#ef4444' : 'var(--bg-tertiary)'};color:white">
+                        {item.status}
+                      </span>
+                      <span class="text-[9px]" style="color:var(--text-muted)">{formatDate(item.created_at)}</span>
+                    </div>
+                    {#if item.status === 'pending'}
+                      <button onclick={() => removeAgentItem(item.id)}
+                        class="text-[9px] mt-1 px-2 py-0.5 rounded border"
+                        style="color:var(--text-muted);border-color:var(--border)">
+                        Remove
+                      </button>
+                    {/if}
+                  </div>
+                </div>
+              </div>
+            {/each}
+          {/if}
+        </div>
+      {:else if activeTab === 'stats'}
+        <!-- Stats Dashboard -->
+        <div class="flex-1 overflow-y-auto p-3 space-y-3">
+          {#if !statsData}
+            <div class="flex items-center justify-center py-8 text-xs" style="color:var(--text-muted)">Loading stats...</div>
+          {:else}
+            <!-- Summary cards -->
+            <div class="grid grid-cols-2 gap-2">
+              <div class="p-2 rounded border text-center" style="background:var(--bg-tertiary);border-color:var(--border)">
+                <div class="text-lg font-black" style="color:var(--accent)">{formatStatsNumber(statsData.total || 0)}</div>
+                <div class="text-[9px]" style="color:var(--text-muted)">Total Videos</div>
+              </div>
+              <div class="p-2 rounded border text-center" style="background:var(--bg-tertiary);border-color:var(--border)">
+                <div class="text-lg font-black" style="color:var(--accent)">{statsData.summary_rate || 0}%</div>
+                <div class="text-[9px]" style="color:var(--text-muted)">Summary Rate</div>
+              </div>
+              <div class="p-2 rounded border text-center" style="background:var(--bg-tertiary);border-color:var(--border)">
+                <div class="text-lg font-black" style="color:var(--accent)">{statsData.channels || 0}</div>
+                <div class="text-[9px]" style="color:var(--text-muted)">Channels</div>
+              </div>
+              <div class="p-2 rounded border text-center" style="background:var(--bg-tertiary);border-color:var(--border)">
+                <div class="text-lg font-black" style="color:var(--accent)">{statsData.last_7_days || 0}</div>
+                <div class="text-[9px]" style="color:var(--text-muted)">Last 7 Days</div>
+              </div>
+            </div>
+            
+            <!-- Status breakdown -->
+            <div class="p-2 rounded border" style="border-color:var(--border)">
+              <div class="text-[10px] font-bold mb-2" style="color:var(--text-muted)">STATUS BREAKDOWN</div>
+              {#each Object.entries(statsData.status_breakdown || {}) as [status, count]}
+                <div class="flex justify-between items-center py-1">
+                  <span class="text-[11px]" style="color:var(--text-primary)">{status}</span>
+                  <span class="text-[11px] font-bold" style="color:var(--accent)">{count}</span>
+                </div>
+              {/each}
+            </div>
+            
+            <!-- Top channels -->
+            <div class="p-2 rounded border" style="border-color:var(--border)">
+              <div class="text-[10px] font-bold mb-2" style="color:var(--text-muted)">TOP CHANNELS</div>
+              {#each (statsData.top_channels || []).slice(0, 8) as ch}
+                <div class="flex justify-between items-center py-1">
+                  <span class="text-[10px] truncate flex-1 mr-2" style="color:var(--text-primary)">{ch.name}</span>
+                  <span class="text-[10px]" style="color:var(--text-muted)">{ch.count}</span>
+                </div>
+              {/each}
+            </div>
+          {/if}
+        </div>
+      {:else}
+        <!-- Channel filter bar -->
+        {#if (allChannels.length || channels.length) > 1}
+          <div class="px-2 py-1.5 space-y-1" style="border-bottom:1px solid var(--border)">
+            <select bind:value={channelFilter}
+              class="w-full text-[11px] p-1.5 rounded border bg-transparent"
+              style="color:var(--text-primary);border-color:var(--border);background:var(--bg-tertiary)">
+              <option value="">All Channels</option>
+              {#if catList.length}
+                <option disabled>── Categories ──</option>
+                {#each catList as cat}
+                  <option value={'📁 ' + cat}>📁 {cat}</option>
+                {/each}
+                <option disabled>── Channels ──</option>
+              {/if}
+              {#each allChannels.length ? allChannels.map(c => c.channel_name) : channels as ch}
+                <option value={ch}>{ch}</option>
+              {/each}
+            </select>
+            <button onclick={() => editingCategories = !editingCategories}
+              class="w-full text-[10px] py-1 rounded border transition text-center"
+              style="color:var(--text-muted);border-color:var(--border)">
+              {editingCategories ? 'Done' : '✎ Edit Categories'}
+            </button>
+            <button onclick={async () => {
+              const res = await fetch('/auto_categories.json');
+              if (res.ok) {
+                const data = await res.json();
+                for (const [k, v] of Object.entries(data)) categories[k] = v;
+                localStorage.setItem('t-yt-categories', JSON.stringify(categories));
+                loadChannels();
+              }
+            }}
+              class="w-full text-[10px] py-1 rounded border transition text-center"
+              style="color:var(--text-muted);border-color:var(--border)">
+              ↻ Reset to Auto
+            </button>
+          </div>
+        {/if}
+        {#if editingCategories}
+          <div class="overflow-y-auto max-h-48 p-2 space-y-1" style="border-bottom:1px solid var(--border);background:var(--bg-tertiary)">
+            <div class="text-[10px] pb-1" style="color:var(--text-muted)">Type category name next to each channel:</div>
+            <input class="w-full text-[11px] p-1 rounded border mb-1" style="background:var(--bg-primary);color:var(--text-primary);border-color:var(--border)"
+              placeholder="New category name..." id="new-cat-input"
+              onkeydown={e => { if (e.key === 'Enter') { const v = e.target.value.trim(); if (v) { categories[v] = []; localStorage.setItem('t-yt-categories', JSON.stringify(categories)); e.target.value = ''; } } }}>
+            {#each allChannels as ch}
+              <div class="flex items-center space-x-2 text-[11px]">
+                <span class="flex-1 truncate" style="color:var(--text-primary)">{ch.channel_name}</span>
+                <input class="w-20 text-[10px] p-0.5 rounded border text-center"
+                  style="background:var(--bg-primary);color:var(--text-primary);border-color:var(--border)"
+                  placeholder="cat"
+                  value={categories[ch.channel_name] || ''}
+                  oninput={e => {
+                    categories[ch.channel_name] = e.target.value;
+                    localStorage.setItem('t-yt-categories', JSON.stringify(categories));
+                  }}>
+              </div>
+            {/each}
+          </div>
+        {/if}
+        <!-- Video list -->
+        <div class="flex-1 overflow-y-auto divide-y" style="border-color:var(--border)">
+          {#each filteredVideos as video (video.video_id)}
+            {@const i = filteredVideos.indexOf(video)}
+            <button onclick={() => { selectedVideo = video; }}
+              data-video-index={i}
+              class="w-full text-left p-2.5 transition flex items-start space-x-2 outline-none focus:outline-none"
+              style="border-left:2px solid {selectedVideo?.video_id === video.video_id ? 'var(--accent)' : 'transparent'};
+                     background:{selectedVideo?.video_id === video.video_id ? 'var(--bg-tertiary)' : 'transparent'}">
+              <!-- Batch select checkbox -->
+              <input type="checkbox" 
+                     checked={selectedVideoIds.has(video.video_id)}
+                     onclick={(e) => { e.stopPropagation(); toggleSelect(video.video_id); }}
+                     class="w-3 h-3 mt-1 rounded flex-shrink-0"
+                     style="accent-color:var(--accent)">
+              <img src={video.thumbnail_url} alt="" class="w-16 h-10 rounded object-cover flex-shrink-0" style="background:var(--bg-tertiary)" />
+              <div class="min-w-0 flex-1">
+                <span class="block text-[10px] font-semibold truncate" style="color:var(--accent)">{video.channel_name}</span>
+                <h3 class="text-[11px] font-bold line-clamp-2 leading-snug" style="color:var(--text-primary)">{video.title}</h3>
+                <div class="flex items-center gap-2 mt-0.5">
+                  <span class="text-[9px]" style="color:var(--text-muted)">{video.publish_date || ''}</span>
+                  {#if video.duration}
+                    <span class="text-[9px]" style="color:var(--text-muted)">{formatDuration(video.duration)}</span>
+                  {/if}
+                  {#if video.view_count && video.view_count > 0}
+                    <span class="text-[9px]" style="color:var(--text-muted)">{formatViews(video.view_count)}</span>
+                  {/if}
+                  {#if noteIds.has(video.video_id)}
+                    <span class="text-[9px]">📝</span>
+                  {/if}
+                </div>
+              </div>
+            </button>
+          {/each}
+        </div>
+      {/if}
     </aside>
 
-    <!-- Right: summary PRIMARY -->
-    <main bind:this={summaryPanel} id="summary-panel" class="flex-1 overflow-y-auto" style="background:var(--bg-primary);min-height:0">
-      {#if selectedVideo}
+    <!-- Batch action bar -->
+    {#if showBatchBar}
+      <div class="fixed bottom-4 left-1/2 transform -translate-x-1/2 z-40 px-4 py-2 rounded-full shadow-lg flex items-center space-x-3"
+           style="background:var(--bg-secondary);border:1px solid var(--border)">
+        <span class="text-xs font-bold" style="color:var(--accent)">{selectedVideoIds.size} selected</span>
+        <button onclick={() => batchUpdate('read')} class="text-[10px] px-3 py-1 text-white font-bold rounded" style="background:var(--accent)">Read All</button>
+        <button onclick={() => batchUpdate('skipped')} class="text-[10px] px-3 py-1 font-bold rounded border" style="color:var(--text-secondary);border-color:var(--border)">Skip All</button>
+        <button onclick={clearSelection} class="text-[10px] px-3 py-1 font-bold rounded border" style="color:var(--text-muted);border-color:var(--border)">Clear</button>
+      </div>
+    {/if}
+
+    <!-- Right: summary panel -->
+    <main bind:this={summaryPanel} onscroll={handleSummaryScroll} id="summary-panel" class="flex-1 overflow-y-auto" style="background:var(--bg-primary);min-height:0">
+      {#if activeTab === '🤖 Agent'}
+        <div class="p-6 max-w-3xl mx-auto">
+          <h2 class="text-sm font-black tracking-wider mb-4" style="color:var(--accent)">🤖 Agent Queue</h2>
+          {#if agentItems.length === 0}
+            <p class="text-xs opacity-50 italic">Queue empty. Watch a video, press <kbd class="px-1 py-0.5 rounded text-[10px]" style="background:var(--bg-tertiary)">n</kbd> to write a note, check "Send to Agent", and save.</p>
+          {:else}
+            <div class="space-y-3">
+              {#each agentItems as item}
+                <div class="p-4 rounded-xl border" style="background:var(--card-bg);border-color:var(--border)">
+                  <div class="flex items-start space-x-3">
+                    <div class="min-w-0 flex-1">
+                      <h3 class="text-sm font-bold" style="color:var(--text-primary)">{item.title || 'Unknown'}</h3>
+                      <p class="text-[10px] mt-0.5" style="color:var(--accent)">{item.channel_name}</p>
+                      <div class="mt-3 p-2 rounded text-xs leading-relaxed" style="background:var(--bg-tertiary)">
+                        <span class="font-bold text-[10px]" style="color:var(--text-muted)">PROMPT:</span>
+                        <p class="mt-1 whitespace-pre-wrap" style="color:var(--text-primary)">{item.user_prompt}</p>
+                      </div>
+                      <div class="flex items-center space-x-2 mt-2">
+                        <span class="text-[9px] px-1.5 py-0.5 rounded font-bold uppercase"
+                          style="background:{item.status === 'done' ? '#10b981' : item.status === 'processing' ? '#f59e0b' : item.status === 'failed' ? '#ef4444' : 'var(--bg-tertiary)'};color:white">
+                          {item.status}
+                        </span>
+                        <span class="text-[9px]" style="color:var(--text-muted)">{formatDate(item.created_at)}</span>
+                        <a href={item.url} target="_blank" rel="noopener noreferrer"
+                          class="text-[9px] px-2 py-0.5 rounded border" style="color:var(--accent);border-color:var(--accent)">▶ Watch</a>
+                        {#if item.status === 'pending'}
+                          <button onclick={() => removeAgentItem(item.id)}
+                            class="text-[9px] px-2 py-0.5 rounded border" style="color:var(--text-muted);border-color:var(--border)">Remove</button>
+                        {/if}
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              {/each}
+            </div>
+          {/if}
+        </div>
+      {:else if selectedVideo}
         <div class="p-6 max-w-3xl mx-auto space-y-4">
-          <!-- ★ AI Digest -->
+          <!-- Video header -->
+          <div class="flex items-start space-x-4">
+            <img src={selectedVideo.thumbnail_url} alt="" class="w-40 h-24 rounded-lg object-cover flex-shrink-0" style="background:var(--bg-tertiary)" />
+            <div class="min-w-0 space-y-2">
+              <span class="text-[10px] px-2 py-0.5 font-bold rounded-full cursor-pointer hover:opacity-80 transition" 
+                style="color:var(--accent);background:var(--bg-tertiary)"
+                onclick={() => { channelFilter = selectedVideo.channel_name; }}
+                title="Filter by this channel">{selectedVideo.channel_name}</span>
+              <h1 class="text-lg font-bold leading-snug" style="color:var(--text-primary)">{selectedVideo.title}</h1>
+              <div class="text-[10px]" style="color:var(--text-muted)">{selectedVideo.publish_date || ''} 
+                {#if selectedVideo.duration}
+                  • {formatDuration(selectedVideo.duration)}
+                {/if}
+                {#if selectedVideo.view_count}
+                  • {formatViews(selectedVideo.view_count)} views
+                {/if}
+              </div>
+              <div class="flex space-x-2">
+                <button onclick={() => updateStatus(selectedVideo.video_id, 'read')} class="text-[10px] px-2.5 py-1 text-white font-bold rounded transition" style="background:var(--accent)">Read (r)</button>
+                <button onclick={() => updateStatus(selectedVideo.video_id, 'skipped')} class="text-[10px] px-2.5 py-1 font-bold rounded border transition" style="color:var(--text-secondary);border-color:var(--border)">Skip (s)</button>
+                <button onclick={() => activeNote = activeNote === selectedVideo.video_id ? null : selectedVideo.video_id}
+                  class="text-[10px] px-2.5 py-1 font-bold rounded border transition"
+                  style="color:var(--text-muted);border-color:var(--border)">✎ Note (n)</button>
+                <a href={selectedVideo.url} target="_blank" rel="noopener noreferrer" class="text-[10px] px-2.5 py-1 text-white font-bold rounded transition" style="background:var(--accent)">▶ Watch</a>
+              </div>
+            </div>
+          </div>
+
+          <!-- Note editor/viewer -->
+          {#if activeNote === selectedVideo.video_id}
+            <div class="space-y-1.5">
+              <textarea id="note-textarea" rows="3" class="w-full text-xs p-2 rounded border resize-none"
+                style="background:var(--bg-tertiary);color:var(--text-primary);border-color:var(--border)"
+                placeholder="Write instructions for the agent here...
+e.g. 'Add this gyroid lattice workflow as a Hermes skill'"
+                value={notes[selectedVideo.video_id] || ''}
+                oninput={e => notes[selectedVideo.video_id] = e.target.value}
+                use:autoFocus
+                onkeydown={e => { if (e.key === 'Escape') { saveNote(); } else if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); saveNote(); } }}
+              ></textarea>
+              <div class="flex items-center space-x-3">
+                <label class="flex items-center space-x-1.5 text-[11px] cursor-pointer" style="color:var(--text-muted)">
+                  <input type="checkbox" bind:checked={queueToAgent}
+                    class="w-3 h-3 rounded" style="accent-color:var(--accent)">
+                  <span>Send to Agent</span>
+                </label>
+                <div class="flex-1"></div>
+                <button onclick={saveNote}
+                  class="text-[10px] px-3 py-1 text-white font-bold rounded transition" style="background:var(--accent)">
+                  {queueToAgent ? 'Save + 🤖 Queue' : 'Save'}
+                </button>
+              </div>
+            </div>
+          {:else if notes[selectedVideo.video_id]}
+            <div class="p-2 rounded border text-xs leading-relaxed cursor-pointer"
+              style="background:var(--bg-tertiary);color:var(--text-primary);border-color:var(--border)"
+              onclick={() => activeNote = selectedVideo.video_id}
+              title="Click to edit">{notes[selectedVideo.video_id]}</div>
+          {/if}
+
+          <!-- AI Digest -->
           <div class="rounded-xl border p-5 space-y-3 shadow-lg" style="background:var(--card-bg);border-color:var(--accent);border-left-width:3px">
             <div class="flex items-center justify-between pb-2" style="border-bottom:1px solid var(--border)">
               <h2 class="text-xs font-black tracking-widest uppercase" style="color:var(--accent)">AI Digest</h2>
               {#if !selectedVideo.summary || selectedVideo.summary.includes("Error")}
                 <button onclick={() => generateSummary(selectedVideo.video_id)}
-                  class="text-[11px] px-3 py-1 font-semibold rounded border transition" style="color:var(--accent);border-color:var(--accent)">
-                  Generate
-                </button>
+                  class="text-[11px] px-3 py-1 font-semibold rounded border transition" style="color:var(--accent);border-color:var(--accent)">Generate</button>
               {/if}
             </div>
             <div class="prose max-w-none text-sm leading-relaxed" style="color:var(--text-primary)">
               {@html formatMarkdown(selectedVideo.summary)}
             </div>
           </div>
-
-          <!-- Video info -->
-          <div class="flex items-start space-x-3">
-            <img src={selectedVideo.thumbnail_url} alt="" class="w-32 h-18 rounded object-cover flex-shrink-0" style="background:var(--bg-tertiary)" />
-            <div class="min-w-0 space-y-1.5">
-              <span class="text-[10px] px-2 py-0.5 font-bold rounded-full" style="color:var(--accent);background:var(--bg-tertiary)">{selectedVideo.channel_name}</span>
-              <h1 class="text-sm font-bold leading-snug" style="color:var(--text-primary)">{selectedVideo.title}</h1>
-              <div class="flex space-x-2">
-                <button onclick={() => updateStatus(selectedVideo.video_id, 'read')} class="text-[10px] px-2.5 py-1 text-white font-bold rounded transition" style="background:var(--accent)">Read</button>
-                <button onclick={() => updateStatus(selectedVideo.video_id, 'skipped')} class="text-[10px] px-2.5 py-1 font-bold rounded border transition" style="color:var(--text-secondary);border-color:var(--border)">Skip</button>
-                <button onclick={() => activeNote = activeNote === selectedVideo.video_id ? null : selectedVideo.video_id}
-                  class="text-[10px] px-2.5 py-1 font-bold rounded border transition"
-                  style="color:var(--text-muted);border-color:var(--border)">✎ Note</button>
-                <a href={selectedVideo.url} target="_blank" rel="noopener noreferrer" class="text-[10px] px-2.5 py-1 text-white font-bold rounded transition" style="background:var(--accent)">▶ Watch</a>
-              </div>
-              {#if activeNote === selectedVideo.video_id}
-                <div class="space-y-1.5 mt-2">
-                  <textarea rows="2" class="w-full text-xs p-2 rounded border resize-none"
-                    style="background:var(--bg-tertiary);color:var(--text-primary);border-color:var(--border)"
-                    placeholder="Quick note..."
-                    value={notes[selectedVideo.video_id] || ''}
-                    oninput={e => notes[selectedVideo.video_id] = e.target.value}
-                    onkeydown={e => { if (e.key === 'Escape') { localStorage.setItem('t-yt-notes', JSON.stringify(notes)); activeNote = null; } }}
-                  ></textarea>
-                  <button onclick={() => { localStorage.setItem('t-yt-notes', JSON.stringify(notes)); activeNote = null; }}
-                    class="text-[10px] px-3 py-1 text-white font-bold rounded transition" style="background:var(--accent)">Save</button>
-                </div>
-              {/if}
-            </div>
-          </div>
         </div>
       {:else}
         <div class="flex-1 flex items-center justify-center" style="color:var(--text-muted)">
@@ -235,4 +886,21 @@
       {/if}
     </main>
   </div>
+
+  {#if showHelp}
+    <div class="fixed inset-0 z-50 flex items-center justify-center" style="background:rgba(0,0,0,0.6)" onclick={() => showHelp = false}>
+      <div class="rounded-xl p-6 max-w-xs w-full space-y-3 shadow-2xl" style="background:var(--card-bg);border:1px solid var(--border)" onclick={e => e.stopPropagation()}>
+        <h3 class="text-sm font-bold" style="color:var(--accent)">Keyboard Shortcuts</h3>
+        <div class="space-y-1.5 text-xs" style="color:var(--text-secondary)">
+          <div class="flex justify-between"><span>Navigate</span><span><kbd class="px-1.5 py-0.5 rounded text-[10px]" style="background:var(--bg-tertiary)">j</kbd> <kbd class="px-1.5 py-0.5 rounded text-[10px]" style="background:var(--bg-tertiary)">↓</kbd></span></div>
+          <div class="flex justify-between"><span>Navigate up</span><span><kbd class="px-1.5 py-0.5 rounded text-[10px]" style="background:var(--bg-tertiary)">k</kbd> <kbd class="px-1.5 py-0.5 rounded text-[10px]" style="background:var(--bg-tertiary)">↑</kbd></span></div>
+          <div class="flex justify-between"><span>Mark Read</span><span><kbd class="px-1.5 py-0.5 rounded text-[10px]" style="background:var(--bg-tertiary)">r</kbd> / <kbd class="px-1.5 py-0.5 rounded text-[10px]" style="background:var(--bg-tertiary)">Enter</kbd></span></div>
+          <div class="flex justify-between"><span>Skip</span><span><kbd class="px-1.5 py-0.5 rounded text-[10px]" style="background:var(--bg-tertiary)">s</kbd></span></div>
+          <div class="flex justify-between"><span>Note</span><span><kbd class="px-1.5 py-0.5 rounded text-[10px]" style="background:var(--bg-tertiary)">n</kbd></span></div>
+          <div class="flex justify-between"><span>Save note</span><span><kbd class="px-1.5 py-0.5 rounded text-[10px]" style="background:var(--bg-tertiary)">Enter</kbd> / <kbd class="px-1.5 py-0.5 rounded text-[10px]" style="background:var(--bg-tertiary)">Esc</kbd></span></div>
+        </div>
+        <p class="text-[10px] text-center pt-1" style="color:var(--text-muted)">Press <kbd class="px-1 py-0.5 rounded text-[10px]" style="background:var(--bg-tertiary)">?</kbd> to toggle</p>
+      </div>
+    </div>
+  {/if}
 </div>

run_sync.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+import asyncio, os, sys, logging
+
+REPO_ROOT = os.path.dirname(os.path.abspath(__file__))
+BACKEND = os.path.join(REPO_ROOT, "backend")
+ENV_PATH = os.path.join(REPO_ROOT, ".env")
+if os.path.exists(ENV_PATH):
+    with open(ENV_PATH) as f:
+        for line in f:
+            line = line.strip()
+            if line and not line.startswith("#") and "=" in line:
+                key, _, value = line.partition("=")
+                value = value.strip().strip("'\"")
+                os.environ[key] = value
+
+sys.path.insert(0, BACKEND)
+os.chdir(BACKEND)
+
+from db import init_db, DB_PATH
+from fetcher import fetch_subscriptions
+from summarizer import summarize_video
+import aiosqlite
+
+BATCH_SIZE = int(os.environ.get("SUMMARIZE_BATCH", "20"))
+BATCH_DELAY = float(os.environ.get("SUMMARIZE_BATCH_DELAY", "2.0"))
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+
+async def main():
+    await init_db()
+    
+    count = await fetch_subscriptions()
+    print(f"Fetched {count} new videos")
+    
+    async with aiosqlite.connect(DB_PATH) as db:
+        cur = await db.execute("SELECT COUNT(*) FROM videos WHERE summary IS NULL OR summary = ''")
+        total = (await cur.fetchone())[0]
+    
+    if total == 0:
+        print("No pending videos to summarize.")
+        return
+    
+    print(f"Processing batch of {BATCH_SIZE} (of {total} pending)...")
+    
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        cur = await db.execute("SELECT video_id FROM videos WHERE summary IS NULL OR summary = '' LIMIT ?", (BATCH_SIZE,))
+        rows = await cur.fetchall()
+    
+    done = 0
+    for row in rows:
+        await summarize_video(row["video_id"])
+        done += 1
+        if done < len(rows):
+            await asyncio.sleep(BATCH_DELAY)
+    
+    remaining = total - done
+    print(f"Batch done: {done}/{len(rows)}, {remaining} pending")
+
+if __name__ == "__main__":
+    asyncio.run(main())

run_tests.sh

@@ -4,15 +4,20 @@ set -e
 DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 VIDEO_ID="jNQXAC9IVRw"
 
-# 1. Auto-detect and configure SOCKS5 proxy if active on 7890
+# 1. Auto-detect and configure proxy
+PROXY_DETECTED=false
 if nc -z 127.0.0.1 7890 >/dev/null 2>&1; then
-    echo "=== Auto-detected local proxy on port 7890. Enabling proxy... ==="
+    echo "=== Auto-detected local proxy on port 7890. Enabling SOCKS5 proxy... ==="
     export http_proxy=socks5://127.0.0.1:7890
     export https_proxy=socks5://127.0.0.1:7890
     export all_proxy=socks5://127.0.0.1:7890
     export HTTP_PROXY=socks5://127.0.0.1:7890
     export HTTPS_PROXY=socks5://127.0.0.1:7890
     export ALL_PROXY=socks5://127.0.0.1:7890
+    PROXY_DETECTED=true
+elif [ -n "$HTTP_PROXY" ] || [ -n "$http_proxy" ]; then
+    echo "=== Using existing HTTP_PROXY env var: ${HTTP_PROXY:-$http_proxy} ==="
+    PROXY_DETECTED=true
 fi
 
 # 2. Set up virtual environment and install requirements if not set up
@@ -25,9 +30,11 @@ fi
 echo "=== Step 1: Running Mock Unit Tests ==="
 "$DIR/backend/.venv/bin/python3" -m pytest "$DIR/backend/tests/"
 
-echo ""
-echo "=== Step 2: Seeding DB for Live Integration Test ==="
-"$DIR/backend/.venv/bin/python3" -c "import asyncio, aiosqlite, sys; sys.path.insert(0, '$DIR/backend'); import db;
+# Only run live integration tests if a proxy is available (needed from China)
+if [ "$PROXY_DETECTED" = true ]; then
+    echo ""
+    echo "=== Step 2: Seeding DB for Live Integration Test ==="
+    "$DIR/backend/.venv/bin/python3" -c "import asyncio, aiosqlite, sys; sys.path.insert(0, '$DIR/backend'); import db;
 async def run():
     await db.init_db()
     async with aiosqlite.connect(db.DB_PATH) as conn:
@@ -35,14 +42,15 @@ async def run():
         await conn.commit()
 asyncio.run(run())"
 
-echo "=== Step 3: Running Live Ingestion & AI Summarization ==="
-set +e
-"$DIR/backend/.venv/bin/python3" "$DIR/backend/summarizer.py" "$VIDEO_ID"
-set -e
+    echo "=== Step 3: Running Live Ingestion & AI Summarization ==="
+    set +e
+    "$DIR/backend/.venv/bin/python3" "$DIR/backend/summarizer.py" "$VIDEO_ID"
+    SUMMARIZER_EXIT=$?
+    set -e
 
-echo ""
-echo "=== Step 4: Verifying SQLite Database Storage ==="
-"$DIR/backend/.venv/bin/python3" -c "import asyncio, aiosqlite, sys; sys.path.insert(0, '$DIR/backend'); import db;
+    echo ""
+    echo "=== Step 4: Verifying SQLite Database Storage ==="
+    "$DIR/backend/.venv/bin/python3" -c "import asyncio, aiosqlite, sys; sys.path.insert(0, '$DIR/backend'); import db;
 async def run():
     async with aiosqlite.connect(db.DB_PATH) as conn:
         conn.row_factory = aiosqlite.Row
@@ -57,9 +65,17 @@ async def run():
             print()
             print('=============================================')
             print('WARNING: LIVE INTEGRATION TEST COULD NOT COMPLETE')
-            print('YouTube blocked this request or cookies.txt was missing.')
+            print('YouTube blocked this request or DeepSeek is unreachable.')
             print('Please ensure your proxy is active on port 7890 or export')
-            print('your youtube cookies to config/cookies.txt.')
+            print('HTTP_PROXY before running.')
             print('This warning is expected and did not break the build.')
             print('=============================================')
 asyncio.run(run())"
+else
+    echo ""
+    echo "=== Skipping Live Integration Test (no proxy detected) ==="
+    echo "From China, YouTube API and DeepSeek require a proxy."
+    echo "Export HTTP_PROXY or SOCKS5 on port 7890 to enable."
+    echo ""
+    echo "=== Mock tests passed — live test skipped (OK) ==="
+fi