.cliff.toml

@@ -1,44 +0,0 @@
-# git-cliff changelog configuration for Kiwi
-# See: https://git-cliff.org/docs/configuration
-
-[changelog]
-header = """
-# Changelog\n
-"""
-body = """
-{% if version %}\
-## [{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }}
-{% else %}\
-## [Unreleased]
-{% endif %}\
-{% for group, commits in commits | group_by(attribute="group") %}
-### {{ group | upper_first }}
-{% for commit in commits %}
-- {% if commit.scope %}**{{ commit.scope }}:** {% endif %}{{ commit.message | upper_first }}\
-{% endfor %}
-{% endfor %}\n
-"""
-trim = true
-
-[git]
-conventional_commits = true
-filter_unconventional = true
-split_commits = false
-commit_preprocessors = []
-commit_parsers = [
-  { message = "^feat", group = "Features" },
-  { message = "^fix", group = "Bug Fixes" },
-  { message = "^perf", group = "Performance" },
-  { message = "^refactor", group = "Refactoring" },
-  { message = "^docs", group = "Documentation" },
-  { message = "^test", group = "Testing" },
-  { message = "^chore", group = "Chores" },
-  { message = "^ci", group = "CI/CD" },
-  { message = "^revert", group = "Reverts" },
-]
-filter_commits = false
-tag_pattern = "v[0-9].*"
-skip_tags = ""
-ignore_tags = ""
-topo_order = false
-sort_commits = "oldest"

.env.example

@@ -51,12 +51,6 @@ ENABLE_OCR=false
 DEBUG=false
 CLOUD_MODE=false
 DEMO_MODE=false
-# Product identifier reported in cf-orch coordinator analytics for per-app breakdown
-CF_APP_NAME=kiwi
-# USE_ORCH_SCHEDULER: use coordinator-aware multi-GPU scheduler instead of local FIFO.
-# Unset = auto-detect: true if CLOUD_MODE or circuitforge_orch is installed (paid+ local).
-# Set false to force LocalScheduler even when cf-orch is present.
-# USE_ORCH_SCHEDULER=false
 
 # Cloud mode (set in compose.cloud.yml; also set here for reference)
 # CLOUD_DATA_ROOT=/devl/kiwi-cloud-data
@@ -74,14 +68,9 @@ CF_APP_NAME=kiwi
 # HEIMDALL_URL=https://license.circuitforge.tech
 # HEIMDALL_ADMIN_TOKEN=
 
-# Directus JWT (must match cf-directus SECRET env var exactly, including base64 == padding)
+# Directus JWT (must match cf-directus SECRET env var)
 # DIRECTUS_JWT_SECRET=
 
-# E2E test account (Directus — free tier, used by automated tests)
-# E2E_TEST_EMAIL=e2e@circuitforge.tech
-# E2E_TEST_PASSWORD=
-# E2E_TEST_USER_ID=
-
 # In-app feedback → Forgejo issue creation
 # FORGEJO_API_TOKEN=
 # FORGEJO_REPO=Circuit-Forge/kiwi

.forgejo/workflows/ci.yml

@@ -1,62 +0,0 @@
-# Kiwi CI — lint, type-check, test on PR/push
-# Full-stack: FastAPI (Python) + Vue 3 SPA (Node)
-# Adapted from Circuit-Forge/cf-agents workflows/ci.yml (cf-agents#4 tracks the
-# upstream ci-fullstack.yml variant; update this file when that lands).
-#
-# Note: frontend has no test suite yet — CI runs typecheck only.
-# Add `npm run test` when vitest is wired (kiwi#XX).
-#
-# circuitforge-core is not on PyPI — installed from Forgejo git (public repo).
-
-name: CI
-
-on:
-  push:
-    branches: [main, 'feature/**', 'fix/**']
-  pull_request:
-    branches: [main]
-
-jobs:
-  backend:
-    name: Backend (Python)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-          cache: pip
-
-      - name: Install circuitforge-core
-        run: pip install git+https://git.opensourcesolarpunk.com/Circuit-Forge/circuitforge-core.git@main
-
-      - name: Install dependencies
-        run: pip install -e ".[dev]" || pip install -e . pytest pytest-asyncio httpx ruff
-
-      - name: Lint
-        run: ruff check .
-
-      - name: Test
-        run: pytest tests/ -v --tb=short
-
-  frontend:
-    name: Frontend (Vue)
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: frontend
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          cache: npm
-          cache-dependency-path: frontend/package-lock.json
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Type check
-        run: npx vue-tsc --noEmit

.forgejo/workflows/mirror.yml

@@ -1,34 +0,0 @@
-# Mirror push to GitHub and Codeberg on every push to main or tag.
-# Copied from Circuit-Forge/cf-agents workflows/mirror.yml
-# Required secrets: GITHUB_MIRROR_TOKEN, CODEBERG_MIRROR_TOKEN
-
-name: Mirror
-
-on:
-  push:
-    branches: [main]
-    tags: ['v*']
-
-jobs:
-  mirror:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Mirror to GitHub
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_MIRROR_TOKEN }}
-          REPO: ${{ github.event.repository.name }}
-        run: |
-          git remote add github "https://x-access-token:${GITHUB_TOKEN}@github.com/CircuitForgeLLC/${REPO}.git"
-          git push github --mirror
-
-      - name: Mirror to Codeberg
-        env:
-          CODEBERG_TOKEN: ${{ secrets.CODEBERG_MIRROR_TOKEN }}
-          REPO: ${{ github.event.repository.name }}
-        run: |
-          git remote add codeberg "https://CircuitForge:${CODEBERG_TOKEN}@codeberg.org/CircuitForge/${REPO}.git"
-          git push codeberg --mirror

.forgejo/workflows/release.yml

@@ -1,71 +0,0 @@
-# Tag-triggered release workflow.
-# Generates changelog and creates Forgejo release on v* tags.
-# Copied from Circuit-Forge/cf-agents workflows/release.yml
-#
-# Docker push is intentionally disabled — BSL 1.1 registry policy not yet resolved.
-# Tracked in Circuit-Forge/cf-agents#3. Re-enable the Docker steps when that lands.
-#
-# Required secrets: FORGEJO_RELEASE_TOKEN
-# (GHCR_TOKEN not needed until Docker push is enabled)
-
-name: Release
-
-on:
-  push:
-    tags: ['v*']
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      # ── Changelog ────────────────────────────────────────────────────────────
-      - name: Generate changelog
-        uses: orhun/git-cliff-action@v3
-        id: cliff
-        with:
-          config: .cliff.toml
-          args: --latest --strip header
-        env:
-          OUTPUT: CHANGES.md
-
-      # ── Docker (disabled — BSL registry policy pending cf-agents#3) ──────────
-      # - name: Set up QEMU
-      #   uses: docker/setup-qemu-action@v3
-      # - name: Set up Buildx
-      #   uses: docker/setup-buildx-action@v3
-      # - name: Log in to GHCR
-      #   uses: docker/login-action@v3
-      #   with:
-      #     registry: ghcr.io
-      #     username: ${{ github.actor }}
-      #     password: ${{ secrets.GHCR_TOKEN }}
-      # - name: Build and push Docker image
-      #   uses: docker/build-push-action@v6
-      #   with:
-      #     context: .
-      #     push: true
-      #     platforms: linux/amd64,linux/arm64
-      #     tags: |
-      #       ghcr.io/circuitforgellc/kiwi:${{ github.ref_name }}
-      #       ghcr.io/circuitforgellc/kiwi:latest
-      #     cache-from: type=gha
-      #     cache-to: type=gha,mode=max
-
-      # ── Forgejo Release ───────────────────────────────────────────────────────
-      - name: Create Forgejo release
-        env:
-          FORGEJO_TOKEN: ${{ secrets.FORGEJO_RELEASE_TOKEN }}
-          REPO: ${{ github.event.repository.name }}
-          TAG: ${{ github.ref_name }}
-          NOTES: ${{ steps.cliff.outputs.content }}
-        run: |
-          curl -sS -X POST \
-            "https://git.opensourcesolarpunk.com/api/v1/repos/Circuit-Forge/${REPO}/releases" \
-            -H "Authorization: token ${FORGEJO_TOKEN}" \
-            -H "Content-Type: application/json" \
-            -d "$(jq -n --arg tag "$TAG" --arg body "$NOTES" \
-                  '{tag_name: $tag, name: $tag, body: $body}')"

.github/workflows/ci.yml

@@ -1,59 +0,0 @@
-# Kiwi CI — runs on GitHub mirror for public credibility badge.
-# Forgejo (.forgejo/workflows/ci.yml) is the canonical CI — keep these in sync.
-# No Forgejo-specific secrets used here; circuitforge-core is public on Forgejo.
-#
-# Note: frontend has no test suite yet — CI runs typecheck only.
-# Add 'npm run test' when vitest is wired.
-
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-jobs:
-  backend:
-    name: Backend (Python)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-          cache: pip
-
-      - name: Install circuitforge-core
-        run: pip install git+https://git.opensourcesolarpunk.com/Circuit-Forge/circuitforge-core.git@main
-
-      - name: Install dependencies
-        run: pip install -e . pytest pytest-asyncio httpx ruff
-
-      - name: Lint
-        run: ruff check .
-
-      - name: Test
-        run: pytest tests/ -v --tb=short
-
-  frontend:
-    name: Frontend (Vue)
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: frontend
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          cache: npm
-          cache-dependency-path: frontend/package-lock.json
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Type check
-        run: npx vue-tsc --noEmit

.gitleaks.toml

@@ -3,16 +3,6 @@
 [extend]
 path = "/Library/Development/CircuitForge/circuitforge-hooks/gitleaks.toml"
 
-# ── Global allowlist ──────────────────────────────────────────────────────────
-# Amazon grocery department IDs (rh=n:<10-digit>) false-positive as phone
-# numbers. locale_config.py is a static lookup table with no secrets.
-
-[allowlist]
-# Amazon grocery dept IDs (rh=n:<digits>) false-positive as phone numbers.
-regexes = [
-    '''rh=n:\d{8,12}''',
-]
-
 # ── Test fixture allowlists ───────────────────────────────────────────────────
 
 [[rules]]

Dockerfile

@@ -11,9 +11,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 COPY circuitforge-core/ ./circuitforge-core/
 RUN conda run -n base pip install --no-cache-dir -e ./circuitforge-core
 
-# Install circuitforge-orch — needed for the cf-orch-agent sidecar (compose.override.yml)
-COPY circuitforge-orch/ ./circuitforge-orch/
-
 # Create kiwi conda env and install app
 COPY kiwi/environment.yml .
 RUN conda env create -f environment.yml
@@ -25,9 +22,8 @@ COPY kiwi/ ./kiwi/
 # they never end up in the cloud image regardless of .dockerignore placement.
 RUN rm -f /app/kiwi/.env
 
-# Install cf-core and cf-orch into the kiwi env BEFORE installing kiwi
+# Install cf-core into the kiwi env BEFORE installing kiwi (kiwi lists it as a dep)
 RUN conda run -n kiwi pip install --no-cache-dir -e /app/circuitforge-core
-RUN conda run -n kiwi pip install --no-cache-dir -e /app/circuitforge-orch
 WORKDIR /app/kiwi
 RUN conda run -n kiwi pip install --no-cache-dir -e .
 

app/api/endpoints/community.py

@@ -62,13 +62,7 @@ async def list_posts(
 ):
     store = _get_community_store()
     if store is None:
-        return {
+        return {"posts": [], "total": 0, "note": "Community DB not available on this instance."}
-            "posts": [],
-            "total": 0,
-            "page": page,
-            "page_size": page_size,
-            "note": "Community DB not available on this instance.",
-        }
 
     dietary = [t.strip() for t in dietary_tags.split(",")] if dietary_tags else None
     allergen_ex = [t.strip() for t in allergen_exclude.split(",")] if allergen_exclude else None
@@ -82,8 +76,7 @@ async def list_posts(
         dietary_tags=dietary,
         allergen_exclude=allergen_ex,
     )
-    visible = [_post_to_dict(p) for p in posts if _visible(p)]
+    return {"posts": [_post_to_dict(p) for p in posts if _visible(p)], "page": page, "page_size": page_size}
-    return {"posts": visible, "total": len(visible), "page": page, "page_size": page_size}
 
 
 @router.get("/posts/{slug}")

app/api/endpoints/corrections.py

@@ -1,5 +0,0 @@
-# app/api/endpoints/corrections.py — user corrections to LLM output for SFT training
-from circuitforge_core.api import make_corrections_router
-from app.db.session import get_db
-
-router = make_corrections_router(get_db=get_db, product="kiwi")

app/api/endpoints/export.py

@@ -1,11 +1,9 @@
-"""Export endpoints — CSV and JSON export of user data."""
+"""Export endpoints — CSV/Excel of receipt and inventory data."""
 from __future__ import annotations
 
 import asyncio
 import csv
 import io
-import json
-from datetime import datetime, timezone
 
 from fastapi import APIRouter, Depends
 from fastapi.responses import StreamingResponse
@@ -47,33 +45,3 @@ async def export_inventory_csv(store: Store = Depends(get_store)):
         media_type="text/csv",
         headers={"Content-Disposition": "attachment; filename=inventory.csv"},
     )
-
-
-@router.get("/json")
-async def export_full_json(store: Store = Depends(get_store)):
-    """Export full pantry inventory + saved recipes as a single JSON file.
-
-    Intended for data portability — users can import this into another
-    Kiwi instance or keep it as an offline backup.
-    """
-    inventory, saved = await asyncio.gather(
-        asyncio.to_thread(store.list_inventory),
-        asyncio.to_thread(store.get_saved_recipes),
-    )
-
-    export_doc = {
-        "kiwi_export": {
-            "version": "1.0",
-            "exported_at": datetime.now(timezone.utc).isoformat(),
-            "inventory": [dict(row) for row in inventory],
-            "saved_recipes": [dict(row) for row in saved],
-        }
-    }
-
-    body = json.dumps(export_doc, default=str, indent=2)
-    filename = f"kiwi-export-{datetime.now(timezone.utc).strftime('%Y%m%d')}.json"
-    return StreamingResponse(
-        iter([body]),
-        media_type="application/json",
-        headers={"Content-Disposition": f"attachment; filename={filename}"},
-    )

app/api/endpoints/feedback_attach.py

@@ -1,103 +0,0 @@
-"""Screenshot attachment endpoint for in-app feedback.
-
-After the cf-core feedback router creates a Forgejo issue, the frontend
-can call POST /feedback/attach to upload a screenshot and pin it as a
-comment on that issue.
-
-The endpoint is separate from the cf-core router so Kiwi owns it
-without modifying shared infrastructure.
-"""
-from __future__ import annotations
-
-import base64
-import os
-
-import requests
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel, Field
-
-router = APIRouter()
-
-_FORGEJO_BASE = os.environ.get(
-    "FORGEJO_API_URL", "https://git.opensourcesolarpunk.com/api/v1"
-)
-_REPO = "Circuit-Forge/kiwi"
-_MAX_BYTES = 5 * 1024 * 1024  # 5 MB
-
-
-class AttachRequest(BaseModel):
-    issue_number: int
-    filename: str = Field(default="screenshot.png", max_length=80)
-    image_b64: str  # data URI or raw base64
-
-
-class AttachResponse(BaseModel):
-    comment_url: str
-
-
-def _forgejo_headers() -> dict[str, str]:
-    token = os.environ.get("FORGEJO_API_TOKEN", "")
-    return {"Authorization": f"token {token}"}
-
-
-def _decode_image(image_b64: str) -> tuple[bytes, str]:
-    """Return (raw_bytes, mime_type) from a base64 string or data URI."""
-    if image_b64.startswith("data:"):
-        header, _, data = image_b64.partition(",")
-        mime = header.split(";")[0].split(":")[1] if ":" in header else "image/png"
-    else:
-        data = image_b64
-        mime = "image/png"
-    return base64.b64decode(data), mime
-
-
-@router.post("/attach", response_model=AttachResponse)
-def attach_screenshot(payload: AttachRequest) -> AttachResponse:
-    """Upload a screenshot to a Forgejo issue as a comment with embedded image.
-
-    The image is uploaded as an issue asset, then referenced in a comment
-    so it is visible inline when the issue is viewed.
-    """
-    token = os.environ.get("FORGEJO_API_TOKEN", "")
-    if not token:
-        raise HTTPException(status_code=503, detail="Feedback not configured.")
-
-    raw_bytes, mime = _decode_image(payload.image_b64)
-
-    if len(raw_bytes) > _MAX_BYTES:
-        raise HTTPException(
-            status_code=413,
-            detail=f"Screenshot exceeds 5 MB limit ({len(raw_bytes) // 1024} KB received).",
-        )
-
-    # Upload image as issue asset
-    asset_resp = requests.post(
-        f"{_FORGEJO_BASE}/repos/{_REPO}/issues/{payload.issue_number}/assets",
-        headers=_forgejo_headers(),
-        files={"attachment": (payload.filename, raw_bytes, mime)},
-        timeout=20,
-    )
-    if not asset_resp.ok:
-        raise HTTPException(
-            status_code=502,
-            detail=f"Forgejo asset upload failed: {asset_resp.text[:200]}",
-        )
-
-    asset_url = asset_resp.json().get("browser_download_url", "")
-
-    # Pin as a comment so the image is visible inline
-    comment_body = f"**Screenshot attached by reporter:**\n\n![screenshot]({asset_url})"
-    comment_resp = requests.post(
-        f"{_FORGEJO_BASE}/repos/{_REPO}/issues/{payload.issue_number}/comments",
-        headers={**_forgejo_headers(), "Content-Type": "application/json"},
-        json={"body": comment_body},
-        timeout=15,
-    )
-    if not comment_resp.ok:
-        raise HTTPException(
-            status_code=502,
-            detail=f"Forgejo comment failed: {comment_resp.text[:200]}",
-        )
-
-    comment_url = comment_resp.json().get("html_url", "")
-    return AttachResponse(comment_url=comment_url)

app/api/endpoints/household.py

@@ -11,8 +11,7 @@ import sqlite3
 import requests
 from fastapi import APIRouter, Depends, HTTPException
 
-from app.cloud_session import CloudUser, CLOUD_DATA_ROOT, get_session
+from app.cloud_session import CloudUser, CLOUD_DATA_ROOT, HEIMDALL_URL, HEIMDALL_ADMIN_TOKEN, get_session
-from app.services.heimdall_orch import HEIMDALL_URL, HEIMDALL_ADMIN_TOKEN
 from app.db.store import Store
 from app.models.schemas.household import (
     HouseholdAcceptRequest,
@@ -129,18 +128,15 @@ async def household_status(session: CloudUser = Depends(_require_premium)):
 @router.post("/invite", response_model=HouseholdInviteResponse)
 async def create_invite(session: CloudUser = Depends(_require_household_owner)):
     """Generate a one-time invite token valid for 7 days."""
+    store = Store(session.db)
     token = secrets.token_hex(32)
     expires_at = (datetime.now(timezone.utc) + timedelta(days=_INVITE_TTL_DAYS)).isoformat()
-    store = Store(session.db)
-    try:
     store.conn.execute(
         """INSERT INTO household_invites (token, household_id, created_by, expires_at)
            VALUES (?, ?, ?, ?)""",
         (token, session.household_id, session.user_id, expires_at),
     )
     store.conn.commit()
-    finally:
-        store.close()
     invite_url = f"{_KIWI_BASE_URL}/#/join?household_id={session.household_id}&token={token}"
     return HouseholdInviteResponse(token=token, invite_url=invite_url, expires_at=expires_at)
 
@@ -156,7 +152,6 @@ async def accept_invite(
 
     hh_store = _household_store(body.household_id)
     now = datetime.now(timezone.utc).isoformat()
-    try:
     row = hh_store.conn.execute(
         """SELECT token, expires_at, used_at FROM household_invites
            WHERE token = ? AND household_id = ?""",
@@ -175,8 +170,6 @@ async def accept_invite(
         (now, session.user_id, body.token),
     )
     hh_store.conn.commit()
-    finally:
-        hh_store.close()
 
     _heimdall_post("/admin/household/add-member", {
         "household_id": body.household_id,

app/api/endpoints/inventory.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import asyncio
-import logging
 import uuid
 from pathlib import Path
 from typing import Any, Dict, List, Optional
@@ -12,73 +11,28 @@ import aiofiles
 from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile, status
 from pydantic import BaseModel
 
-from app.cloud_session import CloudUser, _auth_label, get_session
+from app.cloud_session import CloudUser, get_session
-
-log = logging.getLogger(__name__)
 from app.db.session import get_store
-from app.services.expiration_predictor import ExpirationPredictor
-
-_predictor = ExpirationPredictor()
 from app.db.store import Store
 from app.models.schemas.inventory import (
     BarcodeScanResponse,
     BulkAddByNameRequest,
     BulkAddByNameResponse,
     BulkAddItemResult,
-    DiscardRequest,
     InventoryItemCreate,
     InventoryItemResponse,
     InventoryItemUpdate,
     InventoryStats,
-    PartialConsumeRequest,
     ProductCreate,
     ProductResponse,
     ProductUpdate,
     TagCreate,
     TagResponse,
 )
-from app.models.schemas.label_capture import LabelConfirmRequest
 
 router = APIRouter()
 
 
-# ── Helpers ───────────────────────────────────────────────────────────────────
-
-def _user_constraints(store) -> list[str]:
-    """Load active dietary constraints from user settings (comma-separated string)."""
-    raw = store.get_setting("dietary_constraints") or ""
-    return [c.strip() for c in raw.split(",") if c.strip()]
-
-
-def _enrich_item(item: dict, user_constraints: list[str] | None = None) -> dict:
-    """Attach computed fields: opened_expiry_date, secondary_state/uses/warning/discard_signs."""
-    from datetime import date, timedelta
-    opened = item.get("opened_date")
-    if opened:
-        days = _predictor.days_after_opening(item.get("category"))
-        if days is not None:
-            try:
-                opened_expiry = date.fromisoformat(opened) + timedelta(days=days)
-                item = {**item, "opened_expiry_date": str(opened_expiry)}
-            except ValueError:
-                pass
-    if "opened_expiry_date" not in item:
-        item = {**item, "opened_expiry_date": None}
-
-    # Secondary use window — check sell-by date (not opened expiry).
-    # Apply dietary constraint filter (e.g. wine suppressed for halal/alcohol-free).
-    sec = _predictor.secondary_state(item.get("category"), item.get("expiration_date"))
-    sec = _predictor.filter_secondary_by_constraints(sec, user_constraints or [])
-    item = {
-        **item,
-        "secondary_state": sec["label"] if sec else None,
-        "secondary_uses": sec["uses"] if sec else None,
-        "secondary_warning": sec["warning"] if sec else None,
-        "secondary_discard_signs": sec["discard_signs"] if sec else None,
-    }
-    return item
-
-
 # ── Products ──────────────────────────────────────────────────────────────────
 
 @router.post("/products", response_model=ProductResponse, status_code=status.HTTP_201_CREATED)
@@ -163,12 +117,7 @@ async def delete_product(product_id: int, store: Store = Depends(get_store)):
 # ── Inventory items ───────────────────────────────────────────────────────────
 
 @router.post("/items", response_model=InventoryItemResponse, status_code=status.HTTP_201_CREATED)
-async def create_inventory_item(
+async def create_inventory_item(body: InventoryItemCreate, store: Store = Depends(get_store)):
-    body: InventoryItemCreate,
-    store: Store = Depends(get_store),
-    session: CloudUser = Depends(get_session),
-):
-    log.info("add_item auth=%s tier=%s product_id=%s", _auth_label(session.user_id), session.tier, body.product_id)
     item = await asyncio.to_thread(
         store.add_inventory_item,
         body.product_id,
@@ -181,10 +130,7 @@ async def create_inventory_item(
         notes=body.notes,
         source=body.source,
     )
-    # RETURNING * omits joined columns (product_name, barcode, category).
+    return InventoryItemResponse.model_validate(item)
-    # Re-fetch with the products JOIN so the response is fully populated (#99).
-    full_item = await asyncio.to_thread(store.get_inventory_item, item["id"])
-    return InventoryItemResponse.model_validate(full_item)
 
 
 @router.post("/items/bulk-add-by-name", response_model=BulkAddByNameResponse)
@@ -197,7 +143,7 @@ async def bulk_add_items_by_name(body: BulkAddByNameRequest, store: Store = Depe
     for entry in body.items:
         try:
             product, _ = await asyncio.to_thread(
-                store.get_or_create_product, entry.name, None, source="manual"
+                store.get_or_create_product, entry.name, None, source="shopping"
             )
             item = await asyncio.to_thread(
                 store.add_inventory_item,
@@ -205,7 +151,7 @@ async def bulk_add_items_by_name(body: BulkAddByNameRequest, store: Store = Depe
                 entry.location,
                 quantity=entry.quantity,
                 unit=entry.unit,
-                source="manual",
+                source="shopping",
             )
             results.append(BulkAddItemResult(name=entry.name, ok=True, item_id=item["id"]))
         except Exception as exc:
@@ -222,15 +168,13 @@ async def list_inventory_items(
     store: Store = Depends(get_store),
 ):
     items = await asyncio.to_thread(store.list_inventory, location, item_status)
-    constraints = await asyncio.to_thread(_user_constraints, store)
+    return [InventoryItemResponse.model_validate(i) for i in items]
-    return [InventoryItemResponse.model_validate(_enrich_item(i, constraints)) for i in items]
 
 
 @router.get("/items/expiring", response_model=List[InventoryItemResponse])
 async def get_expiring_items(days: int = 7, store: Store = Depends(get_store)):
     items = await asyncio.to_thread(store.expiring_soon, days)
-    constraints = await asyncio.to_thread(_user_constraints, store)
+    return [InventoryItemResponse.model_validate(i) for i in items]
-    return [InventoryItemResponse.model_validate(_enrich_item(i, constraints)) for i in items]
 
 
 @router.get("/items/{item_id}", response_model=InventoryItemResponse)
@@ -238,8 +182,7 @@ async def get_inventory_item(item_id: int, store: Store = Depends(get_store)):
     item = await asyncio.to_thread(store.get_inventory_item, item_id)
     if not item:
         raise HTTPException(status_code=404, detail="Inventory item not found")
-    constraints = await asyncio.to_thread(_user_constraints, store)
+    return InventoryItemResponse.model_validate(item)
-    return InventoryItemResponse.model_validate(_enrich_item(item, constraints))
 
 
 @router.patch("/items/{item_id}", response_model=InventoryItemResponse)
@@ -251,83 +194,24 @@ async def update_inventory_item(
         updates["purchase_date"] = str(updates["purchase_date"])
     if "expiration_date" in updates and updates["expiration_date"]:
         updates["expiration_date"] = str(updates["expiration_date"])
-    if "opened_date" in updates and updates["opened_date"]:
-        updates["opened_date"] = str(updates["opened_date"])
     item = await asyncio.to_thread(store.update_inventory_item, item_id, **updates)
     if not item:
         raise HTTPException(status_code=404, detail="Inventory item not found")
-    constraints = await asyncio.to_thread(_user_constraints, store)
+    return InventoryItemResponse.model_validate(item)
-    return InventoryItemResponse.model_validate(_enrich_item(item, constraints))
-
-
-@router.post("/items/{item_id}/open", response_model=InventoryItemResponse)
-async def mark_item_opened(item_id: int, store: Store = Depends(get_store)):
-    """Record that this item was opened today, triggering secondary shelf-life tracking."""
-    from datetime import date
-    item = await asyncio.to_thread(
-        store.update_inventory_item,
-        item_id,
-        opened_date=str(date.today()),
-    )
-    if not item:
-        raise HTTPException(status_code=404, detail="Inventory item not found")
-    constraints = await asyncio.to_thread(_user_constraints, store)
-    return InventoryItemResponse.model_validate(_enrich_item(item, constraints))
 
 
 @router.post("/items/{item_id}/consume", response_model=InventoryItemResponse)
-async def consume_item(
+async def consume_item(item_id: int, store: Store = Depends(get_store)):
-    item_id: int,
-    body: Optional[PartialConsumeRequest] = None,
-    store: Store = Depends(get_store),
-):
-    """Consume an inventory item fully or partially.
-
-    When body.quantity is provided, decrements by that amount and only marks
-    status=consumed when quantity reaches zero. Omit body to consume all.
-    """
     from datetime import datetime, timezone
-    now = datetime.now(timezone.utc).isoformat()
-    if body is not None:
-        item = await asyncio.to_thread(
-            store.partial_consume_item, item_id, body.quantity, now
-        )
-    else:
     item = await asyncio.to_thread(
         store.update_inventory_item,
         item_id,
         status="consumed",
-            consumed_at=now,
-        )
-    if not item:
-        raise HTTPException(status_code=404, detail="Inventory item not found")
-    constraints = await asyncio.to_thread(_user_constraints, store)
-    return InventoryItemResponse.model_validate(_enrich_item(item, constraints))
-
-
-@router.post("/items/{item_id}/discard", response_model=InventoryItemResponse)
-async def discard_item(
-    item_id: int,
-    body: DiscardRequest = DiscardRequest(),
-    store: Store = Depends(get_store),
-):
-    """Mark an item as discarded (not used, spoiled, etc).
-
-    Optional reason field accepts free text or a preset label
-    ('not used', 'spoiled', 'excess', 'other').
-    """
-    from datetime import datetime, timezone
-    item = await asyncio.to_thread(
-        store.update_inventory_item,
-        item_id,
-        status="discarded",
         consumed_at=datetime.now(timezone.utc).isoformat(),
-        disposal_reason=body.reason,
     )
     if not item:
         raise HTTPException(status_code=404, detail="Inventory item not found")
-    constraints = await asyncio.to_thread(_user_constraints, store)
+    return InventoryItemResponse.model_validate(item)
-    return InventoryItemResponse.model_validate(_enrich_item(item, constraints))
 
 
 @router.delete("/items/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
@@ -350,31 +234,6 @@ class BarcodeScanTextRequest(BaseModel):
     auto_add_to_inventory: bool = True
 
 
-def _captured_to_product_info(row: dict) -> dict:
-    """Convert a captured_products row to the product_info dict shape used by
-    the barcode scan flow (mirrors what OpenFoodFactsService returns)."""
-    macros: dict = {}
-    for field in ("calories", "fat_g", "saturated_fat_g", "carbs_g", "sugar_g",
-                  "fiber_g", "protein_g", "sodium_mg", "serving_size_g"):
-        if row.get(field) is not None:
-            macros[field] = row[field]
-    return {
-        "name": row.get("product_name") or row.get("barcode", "Unknown Product"),
-        "brand": row.get("brand"),
-        "category": None,
-        "nutrition_data": macros,
-        "ingredient_names": row.get("ingredient_names") or [],
-        "allergens": row.get("allergens") or [],
-        "source": "visual_capture",
-    }
-
-
-def _gap_message(tier: str, has_visual_capture: bool) -> str:
-    if has_visual_capture:
-        return "We couldn't find this product. Photograph the nutrition label to add it."
-    return "Not found in any product database — add manually"
-
-
 @router.post("/scan/text", response_model=BarcodeScanResponse)
 async def scan_barcode_text(
     body: BarcodeScanTextRequest,
@@ -382,24 +241,12 @@ async def scan_barcode_text(
     session: CloudUser = Depends(get_session),
 ):
     """Scan a barcode from a text string (e.g. from a hardware scanner or manual entry)."""
-    log.info("scan auth=%s tier=%s barcode=%r", _auth_label(session.user_id), session.tier, body.barcode)
     from app.services.openfoodfacts import OpenFoodFactsService
     from app.services.expiration_predictor import ExpirationPredictor
-    from app.tiers import can_use
 
-    predictor = ExpirationPredictor()
-    has_visual_capture = can_use("visual_label_capture", session.tier, session.has_byok)
-
-    # 1. Check local captured-products cache before hitting FDC/OFF
-    cached = await asyncio.to_thread(store.get_captured_product, body.barcode)
-    if cached and cached.get("confirmed_by_user"):
-        product_info: dict | None = _captured_to_product_info(cached)
-        product_source = "visual_capture"
-    else:
     off = OpenFoodFactsService()
+    predictor = ExpirationPredictor()
     product_info = await off.lookup_product(body.barcode)
-        product_source = "openfoodfacts"
-
     inventory_item = None
 
     if product_info and body.auto_add_to_inventory:
@@ -410,7 +257,7 @@ async def scan_barcode_text(
             brand=product_info.get("brand"),
             category=product_info.get("category"),
             nutrition_data=product_info.get("nutrition_data", {}),
-            source=product_source,
+            source="openfoodfacts",
             source_data=product_info,
         )
         exp = predictor.predict_expiration(
@@ -420,14 +267,10 @@ async def scan_barcode_text(
             tier=session.tier,
             has_byok=session.has_byok,
         )
-        # Use OFFs pack size when detected; caller-supplied quantity is a fallback
-        resolved_qty = product_info.get("pack_quantity") or body.quantity
-        resolved_unit = product_info.get("pack_unit") or "count"
         inventory_item = await asyncio.to_thread(
             store.add_inventory_item,
             product["id"], body.location,
-            quantity=resolved_qty,
+            quantity=body.quantity,
-            unit=resolved_unit,
             expiration_date=str(exp) if exp else None,
             source="barcode_scan",
         )
@@ -435,8 +278,6 @@ async def scan_barcode_text(
     else:
         result_product = None
 
-    product_found = product_info is not None
-    needs_capture = not product_found and has_visual_capture
     return BarcodeScanResponse(
         success=True,
         barcodes_found=1,
@@ -446,9 +287,7 @@ async def scan_barcode_text(
             "product": result_product,
             "inventory_item": InventoryItemResponse.model_validate(inventory_item) if inventory_item else None,
             "added_to_inventory": inventory_item is not None,
-            "needs_manual_entry": not product_found and not needs_capture,
+            "message": "Added to inventory" if inventory_item else "Product not found in database",
-            "needs_visual_capture": needs_capture,
-            "message": "Added to inventory" if inventory_item else _gap_message(session.tier, needs_capture),
         }],
         message="Barcode processed",
     )
@@ -464,10 +303,6 @@ async def scan_barcode_image(
     session: CloudUser = Depends(get_session),
 ):
     """Scan a barcode from an uploaded image. Requires Phase 2 scanner integration."""
-    log.info("scan_image auth=%s tier=%s", _auth_label(session.user_id), session.tier)
-    from app.tiers import can_use
-    has_visual_capture = can_use("visual_label_capture", session.tier, session.has_byok)
-
     temp_dir = Path("/tmp/kiwi_barcode_scans")
     temp_dir.mkdir(parents=True, exist_ok=True)
     temp_file = temp_dir / f"{uuid.uuid4()}_{file.filename}"
@@ -490,16 +325,7 @@ async def scan_barcode_image(
         results = []
         for bc in barcodes:
             code = bc["data"]
-
-            # Check local visual-capture cache before hitting FDC/OFF
-            cached = await asyncio.to_thread(store.get_captured_product, code)
-            if cached and cached.get("confirmed_by_user"):
-                product_info: dict | None = _captured_to_product_info(cached)
-                product_source = "visual_capture"
-            else:
             product_info = await off.lookup_product(code)
-                product_source = "openfoodfacts"
-
             inventory_item = None
             if product_info and auto_add_to_inventory:
                 product, _ = await asyncio.to_thread(
@@ -509,7 +335,7 @@ async def scan_barcode_image(
                     brand=product_info.get("brand"),
                     category=product_info.get("category"),
                     nutrition_data=product_info.get("nutrition_data", {}),
-                    source=product_source,
+                    source="openfoodfacts",
                     source_data=product_info,
                 )
                 exp = predictor.predict_expiration(
@@ -519,27 +345,20 @@ async def scan_barcode_image(
                     tier=session.tier,
             has_byok=session.has_byok,
                 )
-                resolved_qty = product_info.get("pack_quantity") or quantity
-                resolved_unit = product_info.get("pack_unit") or "count"
                 inventory_item = await asyncio.to_thread(
                     store.add_inventory_item,
                     product["id"], location,
-                    quantity=resolved_qty,
+                    quantity=quantity,
-                    unit=resolved_unit,
                     expiration_date=str(exp) if exp else None,
                     source="barcode_scan",
                 )
-            product_found = product_info is not None
-            needs_capture = not product_found and has_visual_capture
             results.append({
                 "barcode": code,
                 "barcode_type": bc.get("type", "unknown"),
-                "product": ProductResponse.model_validate(product_info) if product_info else None,
+                "product": ProductResponse.model_validate(product) if product_info else None,
                 "inventory_item": InventoryItemResponse.model_validate(inventory_item) if inventory_item else None,
                 "added_to_inventory": inventory_item is not None,
-                "needs_manual_entry": not product_found and not needs_capture,
+                "message": "Added to inventory" if inventory_item else "Barcode scanned",
-                "needs_visual_capture": needs_capture,
-                "message": "Added to inventory" if inventory_item else _gap_message(session.tier, needs_capture),
             })
         return BarcodeScanResponse(
             success=True, barcodes_found=len(barcodes), results=results,
@@ -550,143 +369,6 @@ async def scan_barcode_image(
             temp_file.unlink()
 
 
-# ── Visual label capture (kiwi#79) ────────────────────────────────────────────
-
-@router.post("/scan/label-capture")
-async def capture_nutrition_label(
-    file: UploadFile = File(...),
-    barcode: str = Form(...),
-    store: Store = Depends(get_store),
-    session: CloudUser = Depends(get_session),
-):
-    """Photograph a nutrition label for an unenriched product (paid tier).
-
-    Sends the image to the vision model and returns structured nutrition data
-    for user review.  Fields extracted with confidence < 0.7 should be
-    highlighted in amber in the UI.
-    """
-    from app.tiers import can_use
-    from app.models.schemas.label_capture import LabelCaptureResponse
-    from app.services.label_capture import extract_label, needs_review as _needs_review
-
-    if not can_use("visual_label_capture", session.tier, session.has_byok):
-        raise HTTPException(status_code=403, detail="Visual label capture requires a Paid tier or higher.")
-    log.info("label_capture tier=%s barcode=%r", session.tier, barcode)
-
-    image_bytes = await file.read()
-    extraction = await asyncio.to_thread(extract_label, image_bytes)
-
-    return LabelCaptureResponse(
-        barcode=barcode,
-        product_name=extraction.get("product_name"),
-        brand=extraction.get("brand"),
-        serving_size_g=extraction.get("serving_size_g"),
-        calories=extraction.get("calories"),
-        fat_g=extraction.get("fat_g"),
-        saturated_fat_g=extraction.get("saturated_fat_g"),
-        carbs_g=extraction.get("carbs_g"),
-        sugar_g=extraction.get("sugar_g"),
-        fiber_g=extraction.get("fiber_g"),
-        protein_g=extraction.get("protein_g"),
-        sodium_mg=extraction.get("sodium_mg"),
-        ingredient_names=extraction.get("ingredient_names") or [],
-        allergens=extraction.get("allergens") or [],
-        confidence=extraction.get("confidence", 0.0),
-        needs_review=_needs_review(extraction),
-    )
-
-
-@router.post("/scan/label-confirm")
-async def confirm_nutrition_label(
-    body: LabelConfirmRequest,
-    store: Store = Depends(get_store),
-    session: CloudUser = Depends(get_session),
-):
-    """Confirm and save a user-reviewed label extraction.
-
-    Saves the product to the local cache so future scans of the same barcode
-    resolve instantly without another capture.  Optionally adds the item to
-    the user's inventory.
-    """
-    from app.tiers import can_use
-    from app.models.schemas.label_capture import LabelConfirmResponse
-    from app.services.expiration_predictor import ExpirationPredictor
-
-    if not can_use("visual_label_capture", session.tier, session.has_byok):
-        raise HTTPException(status_code=403, detail="Visual label capture requires a Paid tier or higher.")
-    log.info("label_confirm tier=%s barcode=%r", session.tier, body.barcode)
-
-    # Persist to local visual-capture cache
-    await asyncio.to_thread(
-        store.save_captured_product,
-        body.barcode,
-        product_name=body.product_name,
-        brand=body.brand,
-        serving_size_g=body.serving_size_g,
-        calories=body.calories,
-        fat_g=body.fat_g,
-        saturated_fat_g=body.saturated_fat_g,
-        carbs_g=body.carbs_g,
-        sugar_g=body.sugar_g,
-        fiber_g=body.fiber_g,
-        protein_g=body.protein_g,
-        sodium_mg=body.sodium_mg,
-        ingredient_names=body.ingredient_names,
-        allergens=body.allergens,
-        confidence=body.confidence,
-        confirmed_by_user=True,
-    )
-
-    product_id: int | None = None
-    inventory_item_id: int | None = None
-
-    if body.auto_add:
-        predictor = ExpirationPredictor()
-        nutrition = {}
-        for field in ("calories", "fat_g", "saturated_fat_g", "carbs_g", "sugar_g",
-                      "fiber_g", "protein_g", "sodium_mg", "serving_size_g"):
-            val = getattr(body, field, None)
-            if val is not None:
-                nutrition[field] = val
-
-        product, _ = await asyncio.to_thread(
-            store.get_or_create_product,
-            body.product_name or body.barcode,
-            body.barcode,
-            brand=body.brand,
-            category=None,
-            nutrition_data=nutrition,
-            source="visual_capture",
-            source_data={},
-        )
-        product_id = product["id"]
-
-        exp = predictor.predict_expiration(
-            "",
-            body.location,
-            product_name=body.product_name or body.barcode,
-            tier=session.tier,
-            has_byok=session.has_byok,
-        )
-        inv_item = await asyncio.to_thread(
-            store.add_inventory_item,
-            product_id, body.location,
-            quantity=body.quantity,
-            unit="count",
-            expiration_date=str(exp) if exp else None,
-            source="visual_capture",
-        )
-        inventory_item_id = inv_item["id"]
-
-    return LabelConfirmResponse(
-        ok=True,
-        barcode=body.barcode,
-        product_id=product_id,
-        inventory_item_id=inventory_item_id,
-        message="Product saved" + (" and added to inventory" if body.auto_add else ""),
-    )
-
-
 # ── Tags ──────────────────────────────────────────────────────────────────────
 
 @router.post("/tags", response_model=TagResponse, status_code=status.HTTP_201_CREATED)

app/api/endpoints/meal_plans.py

@@ -19,7 +19,6 @@ from app.models.schemas.meal_plan import (
     PrepTaskSummary,
     ShoppingListResponse,
     SlotSummary,
-    UpdatePlanRequest,
     UpdatePrepTaskRequest,
     UpsertSlotRequest,
     VALID_MEAL_TYPES,
@@ -82,21 +81,13 @@ async def create_plan(
     session: CloudUser = Depends(get_session),
     store: Store = Depends(get_store),
 ) -> PlanSummary:
-    import sqlite3
-
     # Free tier is locked to dinner-only; paid+ may configure meal types
     if can_use("meal_plan_config", session.tier):
         meal_types = [t for t in req.meal_types if t in VALID_MEAL_TYPES] or ["dinner"]
     else:
         meal_types = ["dinner"]
 
-    try:
     plan = await asyncio.to_thread(store.create_meal_plan, str(req.week_start), meal_types)
-    except sqlite3.IntegrityError:
-        raise HTTPException(
-            status_code=409,
-            detail=f"A meal plan for the week of {req.week_start} already exists.",
-        )
     slots = await asyncio.to_thread(store.get_plan_slots, plan["id"])
     return _plan_summary(plan, slots)
 
@@ -114,28 +105,6 @@ async def list_plans(
     return result
 
 
-@router.patch("/{plan_id}", response_model=PlanSummary)
-async def update_plan(
-    plan_id: int,
-    req: UpdatePlanRequest,
-    session: CloudUser = Depends(get_session),
-    store: Store = Depends(get_store),
-) -> PlanSummary:
-    plan = await asyncio.to_thread(store.get_meal_plan, plan_id)
-    if plan is None:
-        raise HTTPException(status_code=404, detail="Plan not found.")
-    # Free tier stays dinner-only; paid+ may add meal types
-    if can_use("meal_plan_config", session.tier):
-        meal_types = [t for t in req.meal_types if t in VALID_MEAL_TYPES] or ["dinner"]
-    else:
-        meal_types = ["dinner"]
-    updated = await asyncio.to_thread(store.update_meal_plan_types, plan_id, meal_types)
-    if updated is None:
-        raise HTTPException(status_code=404, detail="Plan not found.")
-    slots = await asyncio.to_thread(store.get_plan_slots, plan_id)
-    return _plan_summary(updated, slots)
-
-
 @router.get("/{plan_id}", response_model=PlanSummary)
 async def get_plan(
     plan_id: int,

app/api/endpoints/ocr.py

@@ -219,7 +219,7 @@ def _commit_items(
             receipt_id=receipt_id,
             purchase_date=str(purchase_date) if purchase_date else None,
             expiration_date=str(exp) if exp else None,
-            source="receipt",
+            source="receipt_ocr",
         )
 
         created.append(ApprovedInventoryItem(

app/api/endpoints/receipts.py

@@ -42,11 +42,9 @@ async def upload_receipt(
     )
     # Only queue OCR if the feature is enabled server-side AND the user's tier allows it.
     # Check tier here, not inside the background task — once dispatched it can't be cancelled.
-    # Pass session.db (a Path) rather than store — the store dependency closes before
-    # background tasks run, so the task opens its own store from the DB path.
     ocr_allowed = settings.ENABLE_OCR and can_use("receipt_ocr", session.tier, session.has_byok)
     if ocr_allowed:
-        background_tasks.add_task(_process_receipt_ocr, receipt["id"], saved, session.db)
+        background_tasks.add_task(_process_receipt_ocr, receipt["id"], saved, store)
     return ReceiptResponse.model_validate(receipt)
 
 
@@ -66,7 +64,7 @@ async def upload_receipts_batch(
             store.create_receipt, file.filename, str(saved)
         )
         if ocr_allowed:
-            background_tasks.add_task(_process_receipt_ocr, receipt["id"], saved, session.db)
+            background_tasks.add_task(_process_receipt_ocr, receipt["id"], saved, store)
         results.append(ReceiptResponse.model_validate(receipt))
     return results
 
@@ -99,13 +97,8 @@ async def get_receipt_quality(receipt_id: int, store: Store = Depends(get_store)
     return QualityAssessment.model_validate(qa)
 
 
-async def _process_receipt_ocr(receipt_id: int, image_path: Path, db_path: Path) -> None:
+async def _process_receipt_ocr(receipt_id: int, image_path: Path, store: Store) -> None:
-    """Background task: run OCR pipeline on an uploaded receipt.
+    """Background task: run OCR pipeline on an uploaded receipt."""
-
-    Accepts db_path (not a Store instance) because FastAPI closes the request-scoped
-    store before background tasks execute. This task owns its store lifecycle.
-    """
-    store = Store(db_path)
     try:
         await asyncio.to_thread(store.update_receipt_status, receipt_id, "processing")
         from app.services.receipt_service import ReceiptService
@@ -115,5 +108,3 @@ async def _process_receipt_ocr(receipt_id: int, image_path: Path, db_path: Path)
         await asyncio.to_thread(
             store.update_receipt_status, receipt_id, "error", str(exc)
         )
-    finally:
-        store.close()

app/api/endpoints/recipe_tags.py

@@ -1,166 +0,0 @@
-# app/api/endpoints/recipe_tags.py
-"""Community subcategory tagging for corpus recipes.
-
-Users can tag a recipe they're viewing with a domain/category/subcategory
-from the browse taxonomy. Tags require a community pseudonym and reach
-public visibility once two independent users have tagged the same recipe
-to the same location (upvotes >= 2).
-
-All tiers may submit and upvote tags — community contribution is free.
-"""
-from __future__ import annotations
-
-import logging
-
-from fastapi import APIRouter, Depends, HTTPException
-from pydantic import BaseModel
-
-from app.api.endpoints.community import _get_community_store
-from app.api.endpoints.session import get_session
-from app.cloud_session import CloudUser
-from app.services.recipe.browser_domains import DOMAINS
-
-logger = logging.getLogger(__name__)
-router = APIRouter()
-
-ACCEPT_THRESHOLD = 2
-
-
-# ── Request / response models ──────────────────────────────────────────────────
-
-class TagSubmitBody(BaseModel):
-    recipe_id: int
-    domain: str
-    category: str
-    subcategory: str | None = None
-    pseudonym: str
-
-
-class TagResponse(BaseModel):
-    id: int
-    recipe_id: int
-    domain: str
-    category: str
-    subcategory: str | None
-    pseudonym: str
-    upvotes: int
-    accepted: bool
-
-
-def _to_response(row: dict) -> TagResponse:
-    return TagResponse(
-        id=row["id"],
-        recipe_id=int(row["recipe_ref"]),
-        domain=row["domain"],
-        category=row["category"],
-        subcategory=row.get("subcategory"),
-        pseudonym=row["pseudonym"],
-        upvotes=row["upvotes"],
-        accepted=row["upvotes"] >= ACCEPT_THRESHOLD,
-    )
-
-
-def _validate_location(domain: str, category: str, subcategory: str | None) -> None:
-    """Raise 422 if (domain, category, subcategory) isn't in the known taxonomy."""
-    if domain not in DOMAINS:
-        raise HTTPException(status_code=422, detail=f"Unknown domain '{domain}'.")
-    cats = DOMAINS[domain].get("categories", {})
-    if category not in cats:
-        raise HTTPException(
-            status_code=422,
-            detail=f"Unknown category '{category}' in domain '{domain}'.",
-        )
-    if subcategory is not None:
-        subcats = cats[category].get("subcategories", {})
-        if subcategory not in subcats:
-            raise HTTPException(
-                status_code=422,
-                detail=f"Unknown subcategory '{subcategory}' in '{domain}/{category}'.",
-            )
-
-
-# ── Endpoints ──────────────────────────────────────────────────────────────────
-
-@router.get("/recipes/community-tags/{recipe_id}", response_model=list[TagResponse])
-async def list_recipe_tags(
-    recipe_id: int,
-    session: CloudUser = Depends(get_session),
-) -> list[TagResponse]:
-    """Return all community tags for a corpus recipe, accepted ones first."""
-    store = _get_community_store()
-    if store is None:
-        return []
-    tags = store.list_tags_for_recipe(recipe_id)
-    return [_to_response(r) for r in tags]
-
-
-@router.post("/recipes/community-tags", response_model=TagResponse, status_code=201)
-async def submit_recipe_tag(
-    body: TagSubmitBody,
-    session: CloudUser = Depends(get_session),
-) -> TagResponse:
-    """Tag a corpus recipe with a browse taxonomy location.
-
-    Requires the user to have a community pseudonym set. Returns 409 if this
-    user has already tagged this recipe to this exact location.
-    """
-    store = _get_community_store()
-    if store is None:
-        raise HTTPException(
-            status_code=503,
-            detail="Community features are not available on this instance.",
-        )
-
-    _validate_location(body.domain, body.category, body.subcategory)
-
-    try:
-        import psycopg2.errors  # type: ignore[import]
-        row = store.submit_recipe_tag(
-            recipe_id=body.recipe_id,
-            domain=body.domain,
-            category=body.category,
-            subcategory=body.subcategory,
-            pseudonym=body.pseudonym,
-        )
-        return _to_response(row)
-    except Exception as exc:
-        if "unique" in str(exc).lower() or "UniqueViolation" in type(exc).__name__:
-            raise HTTPException(
-                status_code=409,
-                detail="You have already tagged this recipe to this location.",
-            )
-        logger.error("submit_recipe_tag failed: %s", exc)
-        raise HTTPException(status_code=500, detail="Failed to submit tag.")
-
-
-@router.post("/recipes/community-tags/{tag_id}/upvote", response_model=TagResponse)
-async def upvote_recipe_tag(
-    tag_id: int,
-    pseudonym: str,
-    session: CloudUser = Depends(get_session),
-) -> TagResponse:
-    """Upvote an existing community tag.
-
-    Returns 409 if this pseudonym has already voted on this tag.
-    Returns 404 if the tag doesn't exist.
-    """
-    store = _get_community_store()
-    if store is None:
-        raise HTTPException(status_code=503, detail="Community features unavailable.")
-
-    tag_row = store.get_recipe_tag_by_id(tag_id)
-    if tag_row is None:
-        raise HTTPException(status_code=404, detail=f"Tag {tag_id} not found.")
-
-    try:
-        new_upvotes = store.upvote_recipe_tag(tag_id, pseudonym)
-    except ValueError:
-        raise HTTPException(status_code=404, detail=f"Tag {tag_id} not found.")
-    except Exception as exc:
-        if "unique" in str(exc).lower() or "UniqueViolation" in type(exc).__name__:
-            raise HTTPException(status_code=409, detail="You have already voted on this tag.")
-        logger.error("upvote_recipe_tag failed: %s", exc)
-        raise HTTPException(status_code=500, detail="Failed to upvote tag.")
-
-    tag_row["upvotes"] = new_upvotes
-    return _to_response(tag_row)

app/api/endpoints/recipes.py

@@ -2,31 +2,21 @@
 from __future__ import annotations
 
 import asyncio
-import logging
 from pathlib import Path
 from typing import Annotated
 
 from fastapi import APIRouter, Depends, HTTPException, Query
 
-from app.cloud_session import CloudUser, _auth_label, get_session
+from app.cloud_session import CloudUser, get_session
-
-log = logging.getLogger(__name__)
-from app.db.session import get_store
 from app.db.store import Store
 from app.models.schemas.recipe import (
     AssemblyTemplateOut,
     BuildRequest,
-    LeftoversResponse,
-    RecipeJobStatus,
     RecipeRequest,
     RecipeResult,
     RecipeSuggestion,
     RoleCandidatesResponse,
-    StreamTokenRequest,
-    StreamTokenResponse,
 )
-from app.services.coordinator_proxy import CoordinatorError, coordinator_authorize
-from app.api.endpoints.imitate import _build_recipe_prompt
 from app.services.recipe.assembly_recipes import (
     build_from_selection,
     get_role_candidates,
@@ -34,16 +24,11 @@ from app.services.recipe.assembly_recipes import (
 )
 from app.services.recipe.browser_domains import (
     DOMAINS,
-    category_has_subcategories,
     get_category_names,
     get_domain_labels,
     get_keywords_for_category,
-    get_keywords_for_subcategory,
-    get_subcategory_names,
 )
 from app.services.recipe.recipe_engine import RecipeEngine
-from app.services.recipe.time_effort import parse_time_effort
-from app.services.recipe.sensory import build_sensory_exclude
 from app.services.heimdall_orch import check_orch_budget
 from app.tiers import can_use
 
@@ -65,93 +50,13 @@ def _suggest_in_thread(db_path: Path, req: RecipeRequest) -> RecipeResult:
         store.close()
 
 
-def _build_stream_prompt(db_path: Path, level: int) -> str:
+@router.post("/suggest", response_model=RecipeResult)
-    """Fetch pantry + user settings from DB and build the recipe prompt.
-
-    Runs in a thread (called via asyncio.to_thread) so it can use sync Store.
-    """
-    import datetime
-
-    store = Store(db_path)
-    try:
-        items = store.list_inventory(status="available")
-        pantry_names = [i["product_name"] for i in items if i.get("product_name")]
-
-        today = datetime.date.today()
-        expiring_names = [
-            i["product_name"]
-            for i in items
-            if i.get("product_name")
-            and i.get("expiry_date")
-            and (datetime.date.fromisoformat(i["expiry_date"]) - today).days <= 3
-        ]
-
-        settings: dict = {}
-        try:
-            rows = store.conn.execute("SELECT key, value FROM user_settings").fetchall()
-            settings = {r["key"]: r["value"] for r in rows}
-        except Exception:
-            pass
-
-        constraints_raw = settings.get("dietary_constraints", "")
-        constraints = [c.strip() for c in constraints_raw.split(",") if c.strip()] if constraints_raw else []
-        allergies_raw = settings.get("allergies", "")
-        allergies = [a.strip() for a in allergies_raw.split(",") if a.strip()] if allergies_raw else []
-
-        return _build_recipe_prompt(pantry_names, expiring_names, constraints, allergies, level)
-    finally:
-        store.close()
-
-
-async def _enqueue_recipe_job(session: CloudUser, req: RecipeRequest):
-    """Queue an async recipe_llm job and return 202 with job_id.
-
-    Falls back to synchronous generation in CLOUD_MODE (scheduler polls only
-    the shared settings DB, not per-user DBs — see snipe#45 / kiwi backlog).
-    """
-    import json
-    import uuid
-    from fastapi.responses import JSONResponse
-    from app.cloud_session import CLOUD_MODE
-    from app.tasks.runner import insert_task
-
-    if CLOUD_MODE:
-        log.warning("recipe_llm async jobs not supported in CLOUD_MODE — falling back to sync")
-        result = await asyncio.to_thread(_suggest_in_thread, session.db, req)
-        return result
-
-    job_id = f"rec_{uuid.uuid4().hex}"
-
-    def _create(db_path: Path) -> int:
-        store = Store(db_path)
-        try:
-            row = store.create_recipe_job(job_id, session.user_id, req.model_dump_json())
-            return row["id"]
-        finally:
-            store.close()
-
-    int_id = await asyncio.to_thread(_create, session.db)
-    params_json = json.dumps({"job_id": job_id})
-    task_id, is_new = insert_task(session.db, "recipe_llm", int_id, params=params_json)
-    if is_new:
-        from app.tasks.scheduler import get_scheduler
-        get_scheduler(session.db).enqueue(task_id, "recipe_llm", int_id, params_json)
-
-    return JSONResponse(content={"job_id": job_id, "status": "queued"}, status_code=202)
-
-
-@router.post("/suggest")
 async def suggest_recipes(
     req: RecipeRequest,
-    async_mode: bool = Query(default=False, alias="async"),
     session: CloudUser = Depends(get_session),
-    store: Store = Depends(get_store),
+) -> RecipeResult:
-):
-    log.info("recipes auth=%s tier=%s level=%s", _auth_label(session.user_id), session.tier, req.level)
     # Inject session-authoritative tier/byok immediately — client-supplied values are ignored.
-    # Also read stored unit_system preference; default to metric if not set.
+    req = req.model_copy(update={"tier": session.tier, "has_byok": session.has_byok})
-    unit_system = store.get_setting("unit_system") or "metric"
-    req = req.model_copy(update={"tier": session.tier, "has_byok": session.has_byok, "unit_system": unit_system})
     if req.level == 4 and not req.wildcard_confirmed:
         raise HTTPException(
             status_code=400,
@@ -179,85 +84,12 @@ async def suggest_recipes(
             req = req.model_copy(update={"level": 2})
             orch_fallback = True
 
-    if req.level in (3, 4) and async_mode:
-        return await _enqueue_recipe_job(session, req)
-
     result = await asyncio.to_thread(_suggest_in_thread, session.db, req)
     if orch_fallback:
         result = result.model_copy(update={"orch_fallback": True})
     return result
 
 
-@router.post("/stream-token", response_model=StreamTokenResponse)
-async def get_stream_token(
-    req: StreamTokenRequest,
-    session: CloudUser = Depends(get_session),
-) -> StreamTokenResponse:
-    """Issue a one-time stream token for LLM recipe generation.
-
-    Tier-gated (Paid or BYOK). Builds the prompt from pantry + user settings,
-    then calls the cf-orch coordinator to obtain a stream URL. Returns
-    immediately — the frontend opens EventSource to the stream URL directly.
-    """
-    if not can_use("recipe_suggestions", session.tier, session.has_byok):
-        raise HTTPException(
-            status_code=403,
-            detail="Streaming recipe generation requires Paid tier or a configured LLM backend.",
-        )
-    if req.level == 4 and not req.wildcard_confirmed:
-        raise HTTPException(
-            status_code=400,
-            detail="Level 4 (Wildcard) streaming requires wildcard_confirmed=true.",
-        )
-
-    prompt = await asyncio.to_thread(_build_stream_prompt, session.db, req.level)
-
-    try:
-        result = await coordinator_authorize(prompt=prompt, caller="kiwi-recipe", ttl_s=300)
-    except CoordinatorError as exc:
-        raise HTTPException(status_code=exc.status_code, detail=str(exc))
-
-    return StreamTokenResponse(
-        stream_url=result.stream_url,
-        token=result.token,
-        expires_in_s=result.expires_in_s,
-    )
-
-
-@router.get("/jobs/{job_id}", response_model=RecipeJobStatus)
-async def get_recipe_job_status(
-    job_id: str,
-    session: CloudUser = Depends(get_session),
-) -> RecipeJobStatus:
-    """Poll the status of an async recipe generation job.
-
-    Returns 404 when job_id is unknown or belongs to a different user.
-    On status='done' with suggestions=[], the LLM returned empty — client
-    should show a 'no recipe generated, try again' message.
-    """
-    def _get(db_path: Path) -> dict | None:
-        store = Store(db_path)
-        try:
-            return store.get_recipe_job(job_id, session.user_id)
-        finally:
-            store.close()
-
-    row = await asyncio.to_thread(_get, session.db)
-    if row is None:
-        raise HTTPException(status_code=404, detail="Job not found.")
-
-    result = None
-    if row["status"] == "done" and row["result"]:
-        result = RecipeResult.model_validate_json(row["result"])
-
-    return RecipeJobStatus(
-        job_id=row["job_id"],
-        status=row["status"],
-        result=result,
-        error=row["error"],
-    )
-
-
 @router.get("/browse/domains")
 async def list_browse_domains(
     session: CloudUser = Depends(get_session),
@@ -275,42 +107,15 @@ async def list_browse_categories(
     if domain not in DOMAINS:
         raise HTTPException(status_code=404, detail=f"Unknown domain '{domain}'.")
 
-    cat_names = get_category_names(domain)
+    keywords_by_category = {
-    keywords_by_category = {cat: get_keywords_for_category(domain, cat) for cat in cat_names}
+        cat: get_keywords_for_category(domain, cat)
-    has_subs = {cat: category_has_subcategories(domain, cat) for cat in cat_names}
+        for cat in get_category_names(domain)
-
-    def _get(db_path: Path) -> list[dict]:
-        store = Store(db_path)
-        try:
-            return store.get_browser_categories(domain, keywords_by_category, has_subs)
-        finally:
-            store.close()
-
-    return await asyncio.to_thread(_get, session.db)
-
-
-@router.get("/browse/{domain}/{category}/subcategories")
-async def list_browse_subcategories(
-    domain: str,
-    category: str,
-    session: CloudUser = Depends(get_session),
-) -> list[dict]:
-    """Return [{subcategory, recipe_count}] for a category that supports subcategories."""
-    if domain not in DOMAINS:
-        raise HTTPException(status_code=404, detail=f"Unknown domain '{domain}'.")
-    if not category_has_subcategories(domain, category):
-        return []
-
-    subcat_names = get_subcategory_names(domain, category)
-    keywords_by_subcat = {
-        sub: get_keywords_for_subcategory(domain, category, sub)
-        for sub in subcat_names
     }
 
     def _get(db_path: Path) -> list[dict]:
         store = Store(db_path)
         try:
-            return store.get_browser_subcategories(domain, keywords_by_subcat)
+            return store.get_browser_categories(domain, keywords_by_category)
         finally:
             store.close()
 
@@ -324,31 +129,16 @@ async def browse_recipes(
     page: Annotated[int, Query(ge=1)] = 1,
     page_size: Annotated[int, Query(ge=1, le=100)] = 20,
     pantry_items: Annotated[str | None, Query()] = None,
-    subcategory: Annotated[str | None, Query()] = None,
-    q: Annotated[str | None, Query(max_length=200)] = None,
-    sort: Annotated[str, Query(pattern="^(default|alpha|alpha_desc|match)$")] = "default",
     session: CloudUser = Depends(get_session),
 ) -> dict:
     """Return a paginated list of recipes for a domain/category.
 
-    Pass pantry_items as a comma-separated string to receive match_pct badges.
+    Pass pantry_items as a comma-separated string to receive match_pct
-    Pass subcategory to narrow within a category that has subcategories.
+    badges on each result.
-    Pass q to filter by title substring. Pass sort for ordering (default/alpha/alpha_desc/match).
-    sort=match orders by pantry coverage DESC; falls back to default when no pantry_items.
     """
     if domain not in DOMAINS:
         raise HTTPException(status_code=404, detail=f"Unknown domain '{domain}'.")
 
-    if category == "_all":
-        keywords = None  # unfiltered browse
-    elif subcategory:
-        keywords = get_keywords_for_subcategory(domain, category, subcategory)
-        if not keywords:
-            raise HTTPException(
-                status_code=404,
-                detail=f"Unknown subcategory '{subcategory}' in '{category}'.",
-            )
-    else:
     keywords = get_keywords_for_category(domain, category)
     if not keywords:
         raise HTTPException(
@@ -365,81 +155,12 @@ async def browse_recipes(
     def _browse(db_path: Path) -> dict:
         store = Store(db_path)
         try:
-            # Load sensory preferences
-            sensory_prefs_json = store.get_setting("sensory_preferences")
-            sensory_exclude = build_sensory_exclude(sensory_prefs_json)
-
             result = store.browse_recipes(
                 keywords=keywords,
                 page=page,
                 page_size=page_size,
                 pantry_items=pantry_list,
-                q=q or None,
-                sort=sort,
-                sensory_exclude=sensory_exclude,
             )
-
-            # ── Attach time/effort signals to each browse result ────────────────
-            import json as _json
-            for recipe_row in result.get("recipes", []):
-                directions_raw = recipe_row.get("directions") or []
-                if isinstance(directions_raw, str):
-                    try:
-                        directions_raw = _json.loads(directions_raw)
-                    except Exception:
-                        directions_raw = []
-                if directions_raw:
-                    _profile = parse_time_effort(directions_raw)
-                    recipe_row["active_min"] = _profile.active_min
-                    recipe_row["passive_min"] = _profile.passive_min
-                else:
-                    recipe_row["active_min"] = None
-                    recipe_row["passive_min"] = None
-                # Remove directions from browse payload — not needed by the card UI
-                recipe_row.pop("directions", None)
-
-            # Community tag fallback: if FTS returned nothing for a subcategory,
-            # check whether accepted community tags exist for this location and
-            # fetch those corpus recipes directly by ID.
-            if result["total"] == 0 and subcategory and keywords:
-                try:
-                    from app.api.endpoints.community import _get_community_store
-                    cs = _get_community_store()
-                    if cs is not None:
-                        community_ids = cs.get_accepted_recipe_ids_for_subcategory(
-                            domain=domain,
-                            category=category,
-                            subcategory=subcategory,
-                        )
-                        if community_ids:
-                            offset = (page - 1) * page_size
-                            paged_ids = community_ids[offset: offset + page_size]
-                            recipes = store.fetch_recipes_by_ids(paged_ids, pantry_list)
-                            import json as _json_c
-                            for recipe_row in recipes:
-                                directions_raw = recipe_row.get("directions") or []
-                                if isinstance(directions_raw, str):
-                                    try:
-                                        directions_raw = _json_c.loads(directions_raw)
-                                    except Exception:
-                                        directions_raw = []
-                                if directions_raw:
-                                    _profile = parse_time_effort(directions_raw)
-                                    recipe_row["active_min"] = _profile.active_min
-                                    recipe_row["passive_min"] = _profile.passive_min
-                                else:
-                                    recipe_row["active_min"] = None
-                                    recipe_row["passive_min"] = None
-                                recipe_row.pop("directions", None)
-                            result = {
-                                "recipes": recipes,
-                                "total": len(community_ids),
-                                "page": page,
-                                "community_tagged": True,
-                            }
-                except Exception as exc:
-                    logger.warning("community tag fallback failed: %s", exc)
-
             store.log_browser_telemetry(
                 domain=domain,
                 category=category,
@@ -555,87 +276,4 @@ async def get_recipe(recipe_id: int, session: CloudUser = Depends(get_session))
     recipe = await asyncio.to_thread(_get, session.db, recipe_id)
     if not recipe:
         raise HTTPException(status_code=404, detail="Recipe not found.")
-
+    return recipe
-    # Normalize corpus record into RecipeSuggestion shape so RecipeDetailPanel
-    # can render it without knowing it came from a direct DB lookup.
-    ingredient_names = recipe.get("ingredient_names") or []
-    if isinstance(ingredient_names, str):
-        import json as _json
-        try:
-            ingredient_names = _json.loads(ingredient_names)
-        except Exception:
-            ingredient_names = []
-
-    _directions_for_te = recipe.get("directions") or []
-    if isinstance(_directions_for_te, str):
-        import json as _json2
-        try:
-            _directions_for_te = _json2.loads(_directions_for_te)
-        except Exception:
-            _directions_for_te = []
-
-    if _directions_for_te:
-        _te = parse_time_effort(_directions_for_te)
-        _time_effort_out: dict | None = {
-            "active_min": _te.active_min,
-            "passive_min": _te.passive_min,
-            "total_min": _te.total_min,
-            "effort_label": _te.effort_label,
-            "equipment": _te.equipment,
-            "step_analyses": [
-                {"is_passive": sa.is_passive, "detected_minutes": sa.detected_minutes}
-                for sa in _te.step_analyses
-            ],
-        }
-    else:
-        _time_effort_out = None
-
-    return {
-        "id": recipe.get("id"),
-        "title": recipe.get("title", ""),
-        "match_count": 0,
-        "matched_ingredients": ingredient_names,
-        "missing_ingredients": [],
-        "directions": recipe.get("directions") or [],
-        "prep_notes": [],
-        "swap_candidates": [],
-        "element_coverage": {},
-        "notes": recipe.get("notes") or "",
-        "level": 1,
-        "is_wildcard": False,
-        "nutrition": None,
-        "source_url": recipe.get("source_url") or None,
-        "complexity": None,
-        "estimated_time_min": None,
-        "time_effort": _time_effort_out,
-    }
-
-
-@router.post("/{recipe_id}/leftovers", response_model=LeftoversResponse)
-async def get_leftovers_shelf_life(
-    recipe_id: int,
-    session: CloudUser = Depends(get_session),
-) -> LeftoversResponse:
-    """Return cooked-leftover shelf-life estimate for a recipe.
-
-    Free tier: deterministic lookup (FDA/USDA table).
-    Deterministic path always runs; no tier gate needed.
-    """
-    def _get(db_path: Path, rid: int) -> LeftoversResponse:
-        from app.services.leftovers_predictor import predict_leftovers_from_row
-        store = Store(db_path)
-        try:
-            recipe = store.get_recipe(rid)
-        finally:
-            store.close()
-        if recipe is None:
-            raise HTTPException(status_code=404, detail="Recipe not found.")
-        result = predict_leftovers_from_row(recipe)
-        return LeftoversResponse(
-            fridge_days=result.fridge_days,
-            freeze_days=result.freeze_days,
-            freeze_by_day=result.freeze_by_day,
-            storage_advice=result.storage_advice,
-        )
-
-    return await asyncio.to_thread(_get, session.db, recipe_id)

app/api/endpoints/saved_recipes.py

@@ -5,7 +5,6 @@ import asyncio
 from pathlib import Path
 
 from fastapi import APIRouter, Depends, HTTPException
-from pydantic import BaseModel
 
 from app.cloud_session import CloudUser, get_session
 from app.db.store import Store
@@ -17,13 +16,8 @@ from app.models.schemas.saved_recipe import (
     SaveRecipeRequest,
     UpdateSavedRecipeRequest,
 )
-from app.services.magpie_hook import fire_recipe_signal
 from app.tiers import can_use
 
-
-class StyleClassifyResponse(BaseModel):
-    suggested_tags: list[str]
-
 router = APIRouter()
 
 
@@ -41,7 +35,7 @@ def _to_summary(row: dict, store: Store) -> SavedRecipeSummary:
     return SavedRecipeSummary(
         id=row["id"],
         recipe_id=row["recipe_id"],
-        title=row.get("title") or "",
+        title=row.get("title", ""),
         saved_at=row["saved_at"],
         notes=row.get("notes"),
         rating=row.get("rating"),
@@ -61,9 +55,7 @@ async def save_recipe(
         row = store.save_recipe(req.recipe_id, req.notes, req.rating)
         return _to_summary(row, store)
 
-    result = await asyncio.to_thread(_in_thread, session.db, _run)
+    return await asyncio.to_thread(_in_thread, session.db, _run)
-    asyncio.create_task(fire_recipe_signal(session.db, req.recipe_id, req.rating, []))
-    return result
 
 
 @router.delete("/{recipe_id}", status_code=204)
@@ -90,11 +82,7 @@ async def update_saved_recipe(
         )
         return _to_summary(row, store)
 
-    result = await asyncio.to_thread(_in_thread, session.db, _run)
+    return await asyncio.to_thread(_in_thread, session.db, _run)
-    asyncio.create_task(
-        fire_recipe_signal(session.db, recipe_id, req.rating, req.style_tags or [])
-    )
-    return result
 
 
 @router.get("", response_model=list[SavedRecipeSummary])
@@ -110,37 +98,12 @@ async def list_saved_recipes(
     return await asyncio.to_thread(_in_thread, session.db, _run)
 
 
-# ── style classifier (Paid / BYOK) ───────────────────────────────────────────
-
-@router.post("/{recipe_id}/classify-style", response_model=StyleClassifyResponse)
-async def classify_style(
-    recipe_id: int,
-    session: CloudUser = Depends(get_session),
-) -> StyleClassifyResponse:
-    if not can_use("style_classifier", session.tier, getattr(session, "has_byok", False)):
-        raise HTTPException(status_code=403, detail="Style classifier requires Paid tier or BYOK.")
-
-    def _run(store: Store) -> StyleClassifyResponse:
-        recipe = store.get_recipe(recipe_id)
-        if recipe is None:
-            raise HTTPException(status_code=404, detail="Recipe not found.")
-        from app.services.recipe.style_classifier import classify_style as _classify
-        tags = _classify(recipe)
-        return StyleClassifyResponse(suggested_tags=tags)
-
-    return await asyncio.to_thread(_in_thread, session.db, _run)
-
-
 # ── collections (Paid) ────────────────────────────────────────────────────────
 
 @router.get("/collections", response_model=list[CollectionSummary])
 async def list_collections(
     session: CloudUser = Depends(get_session),
 ) -> list[CollectionSummary]:
-    # Free users can list (they'll always have zero — creating requires Paid).
-    # Returning 403 here breaks savedStore.load() via Promise.all for non-Paid users.
-    if not can_use("recipe_collections", session.tier):
-        return []
     rows = await asyncio.to_thread(
         _in_thread, session.db, lambda s: s.get_collections()
     )

app/api/endpoints/session.py

@@ -1,37 +0,0 @@
-"""Session bootstrap endpoint — called once per app load by the frontend.
-
-Logs auth= + tier= for log-based analytics without client-side tracking.
-See Circuit-Forge/kiwi#86.
-"""
-from __future__ import annotations
-
-import logging
-
-from fastapi import APIRouter, Depends
-
-from app.cloud_session import CloudUser, _auth_label, get_session
-from app.core.config import settings
-
-router = APIRouter()
-log = logging.getLogger(__name__)
-
-
-@router.get("/bootstrap")
-def session_bootstrap(session: CloudUser = Depends(get_session)) -> dict:
-    """Record auth type and tier for log-based analytics.
-
-    Expected log output:
-        INFO:app.api.endpoints.session: session auth=authed tier=paid
-        INFO:app.api.endpoints.session: session auth=anon tier=free
-
-    E2E test sessions (E2E_TEST_USER_ID) are logged at DEBUG so they don't
-    pollute analytics counts while still being visible when DEBUG=true.
-    """
-    is_test = bool(settings.E2E_TEST_USER_ID and session.user_id == settings.E2E_TEST_USER_ID)
-    logger = log.debug if is_test else log.info
-    logger("session auth=%s tier=%s%s", _auth_label(session.user_id), session.tier, " e2e=true" if is_test else "")
-    return {
-        "auth": _auth_label(session.user_id),
-        "tier": session.tier,
-        "has_byok": session.has_byok,
-    }

app/api/endpoints/settings.py

@@ -10,7 +10,7 @@ from app.db.store import Store
 
 router = APIRouter()
 
-_ALLOWED_KEYS = frozenset({"cooking_equipment", "unit_system", "shopping_locale", "sensory_preferences", "time_first_layout"})
+_ALLOWED_KEYS = frozenset({"cooking_equipment"})
 
 
 class SettingBody(BaseModel):

app/api/endpoints/shopping.py

@@ -1,233 +0,0 @@
-"""Shopping list endpoints.
-
-Free tier for all users (anonymous guests included — shopping list is the
-primary affiliate revenue surface). Confirm-purchase action is also Free:
-it moves a checked item into pantry inventory without a tier gate so the
-flow works for anyone who signs up or browses without an account.
-
-Routes:
-  GET    /shopping              — list items (with affiliate links)
-  POST   /shopping              — add item manually
-  PATCH  /shopping/{id}         — update (check/uncheck, rename, qty)
-  DELETE /shopping/{id}         — remove single item
-  DELETE /shopping/checked       — clear all checked items
-  DELETE /shopping/all           — clear entire list
-  POST   /shopping/from-recipe   — bulk add gaps from a recipe
-  POST   /shopping/{id}/confirm  — confirm purchase → add to pantry inventory
-"""
-from __future__ import annotations
-
-import asyncio
-import logging
-
-from fastapi import APIRouter, Depends, HTTPException, status
-
-from app.cloud_session import CloudUser, get_session
-from app.db.session import get_store
-from app.db.store import Store
-from app.models.schemas.shopping import (
-    BulkAddFromRecipeRequest,
-    ConfirmPurchaseRequest,
-    ShoppingItemCreate,
-    ShoppingItemResponse,
-    ShoppingItemUpdate,
-)
-from app.services.recipe.grocery_links import GroceryLinkBuilder
-
-log = logging.getLogger(__name__)
-router = APIRouter()
-
-
-def _enrich(item: dict, builder: GroceryLinkBuilder) -> ShoppingItemResponse:
-    """Attach live affiliate links to a raw store row."""
-    links = builder.build_links(item["name"])
-    return ShoppingItemResponse(
-        **{**item, "checked": bool(item.get("checked", 0))},
-        grocery_links=[{"ingredient": l.ingredient, "retailer": l.retailer, "url": l.url} for l in links],
-    )
-
-
-def _in_thread(db_path, fn):
-    store = Store(db_path)
-    try:
-        return fn(store)
-    finally:
-        store.close()
-
-
-# ── List ──────────────────────────────────────────────────────────────────────
-
-def _locale_from_store(store: Store) -> str:
-    return store.get_setting("shopping_locale") or "us"
-
-
-@router.get("", response_model=list[ShoppingItemResponse])
-async def list_shopping_items(
-    include_checked: bool = True,
-    session: CloudUser = Depends(get_session),
-    store: Store = Depends(get_store),
-):
-    locale = await asyncio.to_thread(_in_thread, session.db, _locale_from_store)
-    builder = GroceryLinkBuilder(tier=session.tier, has_byok=session.has_byok, locale=locale)
-    items = await asyncio.to_thread(
-        _in_thread, session.db, lambda s: s.list_shopping_items(include_checked)
-    )
-    return [_enrich(i, builder) for i in items]
-
-
-# ── Add manually ──────────────────────────────────────────────────────────────
-
-@router.post("", response_model=ShoppingItemResponse, status_code=status.HTTP_201_CREATED)
-async def add_shopping_item(
-    body: ShoppingItemCreate,
-    session: CloudUser = Depends(get_session),
-    store: Store = Depends(get_store),
-):
-    builder = GroceryLinkBuilder(tier=session.tier, has_byok=session.has_byok, locale=_locale_from_store(store))
-    item = await asyncio.to_thread(
-        _in_thread,
-        session.db,
-        lambda s: s.add_shopping_item(
-            name=body.name,
-            quantity=body.quantity,
-            unit=body.unit,
-            category=body.category,
-            notes=body.notes,
-            source=body.source,
-            recipe_id=body.recipe_id,
-            sort_order=body.sort_order,
-        ),
-    )
-    return _enrich(item, builder)
-
-
-# ── Bulk add from recipe ───────────────────────────────────────────────────────
-
-@router.post("/from-recipe", response_model=list[ShoppingItemResponse], status_code=status.HTTP_201_CREATED)
-async def add_from_recipe(
-    body: BulkAddFromRecipeRequest,
-    session: CloudUser = Depends(get_session),
-    store: Store = Depends(get_store),
-):
-    """Add missing ingredients from a recipe to the shopping list.
-
-    Runs pantry gap analysis and adds only the items the user doesn't have
-    (unless include_covered=True). Skips duplicates already on the list.
-    """
-    from app.services.meal_plan.shopping_list import compute_shopping_list
-
-    def _run(store: Store):
-        recipe = store.get_recipe(body.recipe_id)
-        if not recipe:
-            raise HTTPException(status_code=404, detail="Recipe not found")
-        inventory = store.list_inventory()
-        gaps, covered = compute_shopping_list([recipe], inventory)
-        targets = (gaps + covered) if body.include_covered else gaps
-
-        # Avoid duplicates already on the list
-        existing = {i["name"].lower() for i in store.list_shopping_items()}
-        added = []
-        for gap in targets:
-            if gap.ingredient_name.lower() in existing:
-                continue
-            item = store.add_shopping_item(
-                name=gap.ingredient_name,
-                quantity=None,
-                unit=gap.have_unit,
-                source="recipe",
-                recipe_id=body.recipe_id,
-            )
-            added.append(item)
-        return added
-
-    builder = GroceryLinkBuilder(tier=session.tier, has_byok=session.has_byok, locale=_locale_from_store(store))
-    items = await asyncio.to_thread(_in_thread, session.db, _run)
-    return [_enrich(i, builder) for i in items]
-
-
-# ── Update ────────────────────────────────────────────────────────────────────
-
-@router.patch("/{item_id}", response_model=ShoppingItemResponse)
-async def update_shopping_item(
-    item_id: int,
-    body: ShoppingItemUpdate,
-    session: CloudUser = Depends(get_session),
-    store: Store = Depends(get_store),
-):
-    builder = GroceryLinkBuilder(tier=session.tier, has_byok=session.has_byok, locale=_locale_from_store(store))
-    item = await asyncio.to_thread(
-        _in_thread,
-        session.db,
-        lambda s: s.update_shopping_item(item_id, **body.model_dump(exclude_none=True)),
-    )
-    if not item:
-        raise HTTPException(status_code=404, detail="Shopping item not found")
-    return _enrich(item, builder)
-
-
-# ── Confirm purchase → pantry ─────────────────────────────────────────────────
-
-@router.post("/{item_id}/confirm", status_code=status.HTTP_201_CREATED)
-async def confirm_purchase(
-    item_id: int,
-    body: ConfirmPurchaseRequest,
-    session: CloudUser = Depends(get_session),
-):
-    """Confirm a checked item was purchased and add it to pantry inventory.
-
-    Human approval step: the user explicitly confirms what they actually bought
-    before it lands in their pantry. Returns the new inventory item.
-    """
-    def _run(store: Store):
-        shopping_item = store.get_shopping_item(item_id)
-        if not shopping_item:
-            raise HTTPException(status_code=404, detail="Shopping item not found")
-
-        qty = body.quantity if body.quantity is not None else (shopping_item.get("quantity") or 1.0)
-        unit = body.unit or shopping_item.get("unit") or "count"
-        category = shopping_item.get("category")
-
-        product = store.get_or_create_product(
-            name=shopping_item["name"],
-            category=category,
-        )
-        inv_item = store.add_inventory_item(
-            product_id=product["id"],
-            location=body.location,
-            quantity=qty,
-            unit=unit,
-            source="manual",
-        )
-        # Mark the shopping item checked and leave it for the user to clear
-        store.update_shopping_item(item_id, checked=True)
-        return inv_item
-
-    return await asyncio.to_thread(_in_thread, session.db, _run)
-
-
-# ── Delete ────────────────────────────────────────────────────────────────────
-
-@router.delete("/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
-async def delete_shopping_item(
-    item_id: int,
-    session: CloudUser = Depends(get_session),
-):
-    deleted = await asyncio.to_thread(
-        _in_thread, session.db, lambda s: s.delete_shopping_item(item_id)
-    )
-    if not deleted:
-        raise HTTPException(status_code=404, detail="Shopping item not found")
-
-
-@router.delete("/checked", status_code=status.HTTP_204_NO_CONTENT)
-async def clear_checked(session: CloudUser = Depends(get_session)):
-    await asyncio.to_thread(
-        _in_thread, session.db, lambda s: s.clear_checked_shopping_items()
-    )
-
-
-@router.delete("/all", status_code=status.HTTP_204_NO_CONTENT)
-async def clear_all(session: CloudUser = Depends(get_session)):
-    await asyncio.to_thread(
-        _in_thread, session.db, lambda s: s.clear_all_shopping_items()
-    )

app/api/routes.py

@@ -1,12 +1,9 @@
 from fastapi import APIRouter
-from app.api.endpoints import health, receipts, export, inventory, ocr, recipes, settings, staples, feedback, feedback_attach, household, saved_recipes, imitate, meal_plans, orch_usage, session, shopping
+from app.api.endpoints import health, receipts, export, inventory, ocr, recipes, settings, staples, feedback, household, saved_recipes, imitate, meal_plans, orch_usage
 from app.api.endpoints.community import router as community_router
-from app.api.endpoints.corrections import router as corrections_router
-from app.api.endpoints.recipe_tags import router as recipe_tags_router
 
 api_router = APIRouter()
 
-api_router.include_router(session.router,        prefix="/session",        tags=["session"])
 api_router.include_router(health.router,         prefix="/health",         tags=["health"])
 api_router.include_router(receipts.router,       prefix="/receipts",       tags=["receipts"])
 api_router.include_router(ocr.router,            prefix="/receipts",       tags=["ocr"])
@@ -17,12 +14,8 @@ api_router.include_router(recipes.router,        prefix="/recipes",        tags=
 api_router.include_router(settings.router,       prefix="/settings",       tags=["settings"])
 api_router.include_router(staples.router,        prefix="/staples",        tags=["staples"])
 api_router.include_router(feedback.router,       prefix="/feedback",       tags=["feedback"])
-api_router.include_router(feedback_attach.router, prefix="/feedback",       tags=["feedback"])
 api_router.include_router(household.router,      prefix="/household",      tags=["household"])
 api_router.include_router(imitate.router,        prefix="/imitate",        tags=["imitate"])
 api_router.include_router(meal_plans.router,     prefix="/meal-plans",     tags=["meal-plans"])
 api_router.include_router(orch_usage.router,     prefix="/orch-usage",     tags=["orch-usage"])
-api_router.include_router(shopping.router,       prefix="/shopping",       tags=["shopping"])
 api_router.include_router(community_router)
-api_router.include_router(recipe_tags_router)
-api_router.include_router(corrections_router,    prefix="/corrections",    tags=["corrections"])

app/cloud_session.py

@@ -1,9 +1,11 @@
 """Cloud session resolution for Kiwi FastAPI.
 
-Delegates JWT validation, Heimdall provisioning, tier resolution, and guest
+Local mode (CLOUD_MODE unset/false): returns a local CloudUser with no auth
-session management to circuitforge_core.CloudSessionFactory. Kiwi-specific
+checks, full tier access, and DB path pointing to settings.DB_PATH.
-CloudUser (per-user DB path, household data, BYOK flag) and DB helpers are
+
-kept here.
+Cloud mode (CLOUD_MODE=true): validates the cf_session JWT injected by Caddy
+as X-CF-Session, resolves user_id, auto-provisions a free Heimdall license on
+first visit, fetches the tier, and returns a per-user DB path.
 
 FastAPI usage:
     @app.get("/api/v1/inventory/items")
@@ -15,11 +17,15 @@ from __future__ import annotations
 
 import logging
 import os
+import re
+import time
 from dataclasses import dataclass
 from pathlib import Path
 
-from circuitforge_core.cloud_session import CloudSessionFactory as _CoreFactory, detect_byok
+import jwt as pyjwt
-from fastapi import Depends, HTTPException, Request, Response
+import requests
+import yaml
+from fastapi import Depends, HTTPException, Request
 
 log = logging.getLogger(__name__)
 
@@ -27,22 +33,54 @@ log = logging.getLogger(__name__)
 
 CLOUD_MODE: bool = os.environ.get("CLOUD_MODE", "").lower() in ("1", "true", "yes")
 CLOUD_DATA_ROOT: Path = Path(os.environ.get("CLOUD_DATA_ROOT", "/devl/kiwi-cloud-data"))
+DIRECTUS_JWT_SECRET: str = os.environ.get("DIRECTUS_JWT_SECRET", "")
+HEIMDALL_URL: str = os.environ.get("HEIMDALL_URL", "https://license.circuitforge.tech")
+HEIMDALL_ADMIN_TOKEN: str = os.environ.get("HEIMDALL_ADMIN_TOKEN", "")
+
+# Dev bypass: comma-separated IPs or CIDR ranges that skip JWT auth.
+# NEVER set this in production. Intended only for LAN developer testing when
+# the request doesn't pass through Caddy (which normally injects X-CF-Session).
+# Example: CLOUD_AUTH_BYPASS_IPS=10.1.10.0/24,127.0.0.1
+import ipaddress as _ipaddress
+
+_BYPASS_RAW: list[str] = [
+    e.strip()
+    for e in os.environ.get("CLOUD_AUTH_BYPASS_IPS", "").split(",")
+    if e.strip()
+]
+
+_BYPASS_NETS: list[_ipaddress.IPv4Network | _ipaddress.IPv6Network] = []
+_BYPASS_IPS: frozenset[str] = frozenset()
+
+if _BYPASS_RAW:
+    _nets, _ips = [], set()
+    for entry in _BYPASS_RAW:
+        try:
+            _nets.append(_ipaddress.ip_network(entry, strict=False))
+        except ValueError:
+            _ips.add(entry)  # treat non-parseable entries as bare IPs
+    _BYPASS_NETS = _nets
+    _BYPASS_IPS = frozenset(_ips)
+
+
+def _is_bypass_ip(ip: str) -> bool:
+    if not ip:
+        return False
+    if ip in _BYPASS_IPS:
+        return True
+    try:
+        addr = _ipaddress.ip_address(ip)
+        return any(addr in net for net in _BYPASS_NETS)
+    except ValueError:
+        return False
 
 _LOCAL_KIWI_DB: Path = Path(os.environ.get("KIWI_DB", "data/kiwi.db"))
 
+_TIER_CACHE: dict[str, tuple[dict, float]] = {}
+_TIER_CACHE_TTL = 300  # 5 minutes
+
 TIERS = ["free", "paid", "premium", "ultra"]
 
-_core = _CoreFactory(product="kiwi", byok_detector=detect_byok)
-
-
-def _auth_label(user_id: str) -> str:
-    """Classify a user_id into a short tag for structured log lines. No PII emitted."""
-    if user_id in ("local", "local-dev"):
-        return "local"
-    if user_id.startswith("anon-"):
-        return "anon"
-    return "authed"
-
 
 # ── Domain ────────────────────────────────────────────────────────────────────
 
@@ -57,7 +95,73 @@ class CloudUser:
     license_key: str | None = None  # key_display for lifetime/founders keys; None for subscription/free
 
 
-# ── DB path helpers ───────────────────────────────────────────────────────────
+# ── JWT validation ─────────────────────────────────────────────────────────────
+
+def _extract_session_token(header_value: str) -> str:
+    m = re.search(r'(?:^|;)\s*cf_session=([^;]+)', header_value)
+    return m.group(1).strip() if m else header_value.strip()
+
+
+def validate_session_jwt(token: str) -> str:
+    """Validate cf_session JWT and return the Directus user_id."""
+    try:
+        payload = pyjwt.decode(
+            token,
+            DIRECTUS_JWT_SECRET,
+            algorithms=["HS256"],
+            options={"require": ["id", "exp"]},
+        )
+        return payload["id"]
+    except Exception as exc:
+        log.debug("JWT validation failed: %s", exc)
+        raise HTTPException(status_code=401, detail="Session invalid or expired")
+
+
+# ── Heimdall integration ──────────────────────────────────────────────────────
+
+def _ensure_provisioned(user_id: str) -> None:
+    if not HEIMDALL_ADMIN_TOKEN:
+        return
+    try:
+        requests.post(
+            f"{HEIMDALL_URL}/admin/provision",
+            json={"directus_user_id": user_id, "product": "kiwi", "tier": "free"},
+            headers={"Authorization": f"Bearer {HEIMDALL_ADMIN_TOKEN}"},
+            timeout=5,
+        )
+    except Exception as exc:
+        log.warning("Heimdall provision failed for user %s: %s", user_id, exc)
+
+
+def _fetch_cloud_tier(user_id: str) -> tuple[str, str | None, bool, str | None]:
+    """Returns (tier, household_id | None, is_household_owner, license_key | None)."""
+    now = time.monotonic()
+    cached = _TIER_CACHE.get(user_id)
+    if cached and (now - cached[1]) < _TIER_CACHE_TTL:
+        entry = cached[0]
+        return entry["tier"], entry.get("household_id"), entry.get("is_household_owner", False), entry.get("license_key")
+
+    if not HEIMDALL_ADMIN_TOKEN:
+        return "free", None, False, None
+    try:
+        resp = requests.post(
+            f"{HEIMDALL_URL}/admin/cloud/resolve",
+            json={"directus_user_id": user_id, "product": "kiwi"},
+            headers={"Authorization": f"Bearer {HEIMDALL_ADMIN_TOKEN}"},
+            timeout=5,
+        )
+        data = resp.json() if resp.ok else {}
+        tier = data.get("tier", "free")
+        household_id = data.get("household_id")
+        is_owner = data.get("is_household_owner", False)
+        license_key = data.get("key_display")
+    except Exception as exc:
+        log.warning("Heimdall tier resolve failed for user %s: %s", user_id, exc)
+        tier, household_id, is_owner, license_key = "free", None, False, None
+
+    _TIER_CACHE[user_id] = ({"tier": tier, "household_id": household_id, "is_household_owner": is_owner, "license_key": license_key}, now)
+    return tier, household_id, is_owner, license_key
+
 
 def _user_db_path(user_id: str, household_id: str | None = None) -> Path:
     if household_id:
@@ -68,56 +172,94 @@ def _user_db_path(user_id: str, household_id: str | None = None) -> Path:
     return path
 
 
-def _anon_guest_db_path(guest_id: str) -> Path:
+def _anon_db_path() -> Path:
-    """Per-session DB for unauthenticated guest visitors.
+    """Ephemeral DB for unauthenticated guest visitors (Free tier, no persistence)."""
-
+    path = CLOUD_DATA_ROOT / "anonymous" / "kiwi.db"
-    Each anonymous visitor gets an isolated SQLite DB keyed by their guest UUID
-    cookie, so shopping lists and affiliate interactions never bleed across sessions.
-    """
-    path = CLOUD_DATA_ROOT / f"anon-{guest_id}" / "kiwi.db"
     path.parent.mkdir(parents=True, exist_ok=True)
     return path
 
 
+# ── BYOK detection ────────────────────────────────────────────────────────────
+
+_LLM_CONFIG_PATH = Path.home() / ".config" / "circuitforge" / "llm.yaml"
+
+
+def _detect_byok(config_path: Path = _LLM_CONFIG_PATH) -> bool:
+    """Return True if at least one enabled non-vision LLM backend is configured.
+
+    Reads the same llm.yaml that LLMRouter uses. Local (Ollama, vLLM) and
+    API-key backends both count — the policy is "user is supplying compute",
+    regardless of where that compute lives.
+    """
+    try:
+        with open(config_path) as f:
+            cfg = yaml.safe_load(f) or {}
+        return any(
+            b.get("enabled", True) and b.get("type") != "vision_service"
+            for b in cfg.get("backends", {}).values()
+        )
+    except Exception:
+        return False
+
+
 # ── FastAPI dependency ────────────────────────────────────────────────────────
 
-def get_session(request: Request, response: Response) -> CloudUser:
+def get_session(request: Request) -> CloudUser:
     """FastAPI dependency — resolves the current user from the request.
 
-    Delegates auth/tier resolution to cf-core CloudSessionFactory, then maps
-    the result to Kiwi's CloudUser with per-user DB path and household data.
-
     Local mode: fully-privileged "local" user pointing at local DB.
     Cloud mode: validates X-CF-Session JWT, provisions license, resolves tier.
-    Dev bypass: CLOUD_AUTH_BYPASS_IPS match returns a "local-dev" session.
+    Dev bypass: if CLOUD_AUTH_BYPASS_IPS is set and the client IP matches,
-    Anonymous: per-session UUID cookie (cf_guest_id) isolates each guest's data.
+      returns a "local" session without JWT validation (dev/LAN use only).
     """
-    core_user = _core.resolve(request, response)
+    has_byok = _detect_byok()
-    uid, tier, has_byok = core_user.user_id, core_user.tier, core_user.has_byok
 
-    if not CLOUD_MODE or uid in ("local", "local-dev"):
+    if not CLOUD_MODE:
-        # local-dev gets a writable path under CLOUD_DATA_ROOT; local uses KIWI_DB
+        return CloudUser(user_id="local", tier="local", db=_LOCAL_KIWI_DB, has_byok=has_byok)
-        db = _user_db_path(uid) if uid == "local-dev" else _LOCAL_KIWI_DB
-        return CloudUser(user_id=uid, tier=tier, db=db, has_byok=has_byok)
 
-    if uid.startswith("anon-"):
+    # Prefer X-Real-IP (set by nginx from the actual client address) over the
-        guest_id = uid[len("anon-"):]
+    # TCP peer address (which is nginx's container IP when behind the proxy).
+    client_ip = (
+        request.headers.get("x-real-ip", "")
+        or (request.client.host if request.client else "")
+    )
+    if (_BYPASS_IPS or _BYPASS_NETS) and _is_bypass_ip(client_ip):
+        log.debug("CLOUD_AUTH_BYPASS_IPS match for %s — returning local session", client_ip)
+        # Use a dev DB under CLOUD_DATA_ROOT so the container has a writable path.
+        dev_db = _user_db_path("local-dev")
+        return CloudUser(user_id="local-dev", tier="local", db=dev_db, has_byok=has_byok)
+
+    raw_header = (
+        request.headers.get("x-cf-session", "")
+        or request.headers.get("cookie", "")
+    )
+    if not raw_header:
         return CloudUser(
-            user_id=uid, tier=tier,
+            user_id="anonymous",
-            db=_anon_guest_db_path(guest_id),
+            tier="free",
+            db=_anon_db_path(),
             has_byok=has_byok,
         )
 
-    household_id = core_user.meta.get("household_id")
+    token = _extract_session_token(raw_header)  # gitleaks:allow — function name, not a secret
-    is_owner = core_user.meta.get("is_household_owner", False)
+    if not token:
-    license_key = core_user.meta.get("license_key")
-    log.debug("Resolved %s session uid=%s tier=%s household=%s", _auth_label(uid), uid[:8], tier, household_id)
         return CloudUser(
-        user_id=uid, tier=tier,
+            user_id="anonymous",
-        db=_user_db_path(uid, household_id=household_id),
+            tier="free",
+            db=_anon_db_path(),
+            has_byok=has_byok,
+        )
+
+    user_id = validate_session_jwt(token)
+    _ensure_provisioned(user_id)
+    tier, household_id, is_household_owner, license_key = _fetch_cloud_tier(user_id)
+    return CloudUser(
+        user_id=user_id,
+        tier=tier,
+        db=_user_db_path(user_id, household_id=household_id),
         has_byok=has_byok,
         household_id=household_id,
-        is_household_owner=is_owner,
+        is_household_owner=is_household_owner,
         license_key=license_key,
     )
 

app/core/config.py

@@ -35,18 +35,6 @@ class Settings:
     # Database
     DB_PATH: Path = Path(os.environ.get("DB_PATH", str(DATA_DIR / "kiwi.db")))
 
-    # Pre-computed browse counts cache (small SQLite, separate from corpus).
-    # Written by the nightly refresh task and by infer_recipe_tags.py.
-    # Set BROWSE_COUNTS_PATH to a bind-mounted path if you want the host
-    # pipeline to share counts with the container without re-running FTS.
-    BROWSE_COUNTS_PATH: Path = Path(
-        os.environ.get("BROWSE_COUNTS_PATH", str(DATA_DIR / "browse_counts.db"))
-    )
-
-    # Magpie data flywheel — ingest endpoint for anonymized recipe signals
-    # Set MAGPIE_INGEST_URL to enable; leave unset (or None) to disable silently.
-    MAGPIE_INGEST_URL: str | None = os.environ.get("MAGPIE_INGEST_URL") or None
-
     # Community feature settings
     COMMUNITY_DB_URL: str | None = os.environ.get("COMMUNITY_DB_URL") or None
     COMMUNITY_PSEUDONYM_SALT: str = os.environ.get(
@@ -72,19 +60,8 @@ class Settings:
     # CFOrchClient reads CF_LICENSE_KEY automatically; exposed here for startup validation.
     CF_LICENSE_KEY: str | None = os.environ.get("CF_LICENSE_KEY")
 
-    # E2E test account — analytics logging is suppressed for this user_id so test
-    # runs don't pollute session counts.  Set to the Directus UUID of the test user.
-    E2E_TEST_USER_ID: str | None = os.environ.get("E2E_TEST_USER_ID") or None
-
     # Feature flags
     ENABLE_OCR: bool = os.environ.get("ENABLE_OCR", "false").lower() in ("1", "true", "yes")
-    # Use OrchestratedScheduler (coordinator-aware, multi-GPU fan-out) instead of
-    # LocalScheduler. Defaults to true in CLOUD_MODE; can be set independently
-    # for multi-GPU local rigs that don't need full cloud auth.
-    USE_ORCH_SCHEDULER: bool | None = (
-        None if os.environ.get("USE_ORCH_SCHEDULER") is None
-        else os.environ.get("USE_ORCH_SCHEDULER", "").lower() in ("1", "true", "yes")
-    )
 
     # Runtime
     DEBUG: bool = os.environ.get("DEBUG", "false").lower() in ("1", "true", "yes")

app/db/migrations/030_opened_date.sql

@@ -1,5 +0,0 @@
--- Migration 030: open-package tracking
--- Adds opened_date to track when a multi-use item was first opened,
--- enabling secondary shelf-life windows (e.g. salsa: 1 year sealed → 2 weeks opened).
-
-ALTER TABLE inventory_items ADD COLUMN opened_date TEXT;

app/db/migrations/031_disposal_reason.sql

@@ -1,4 +0,0 @@
--- Migration 031: add disposal_reason for waste logging (#60)
--- status='discarded' already exists in the CHECK constraint from migration 002.
--- This column stores free-text reason (optional) and calm-framing presets.
-ALTER TABLE inventory_items ADD COLUMN disposal_reason TEXT;

app/db/migrations/032_meal_plan_unique_week.sql

@@ -1,4 +0,0 @@
--- 032_meal_plan_unique_week.sql
--- Prevent duplicate plans for the same week.
--- Existing duplicates must be resolved before applying (keep MIN(id) per week_start).
-CREATE UNIQUE INDEX IF NOT EXISTS idx_meal_plans_week_start ON meal_plans (week_start);

app/db/migrations/033_shopping_list.sql

@@ -1,21 +0,0 @@
--- Migration 033: standalone shopping list
--- Items can be added manually, from recipe gap analysis, or from the recipe browser.
--- Affiliate links are computed at query time by the API layer (never stored).
-
-CREATE TABLE IF NOT EXISTS shopping_list_items (
-    id           INTEGER PRIMARY KEY AUTOINCREMENT,
-    name         TEXT    NOT NULL,
-    quantity     REAL,
-    unit         TEXT,
-    category     TEXT,
-    checked      INTEGER NOT NULL DEFAULT 0,   -- 0=want, 1=in-cart/checked off
-    notes        TEXT,
-    source       TEXT    NOT NULL DEFAULT 'manual',  -- manual | recipe | meal_plan
-    recipe_id    INTEGER REFERENCES recipes(id) ON DELETE SET NULL,
-    sort_order   INTEGER NOT NULL DEFAULT 0,
-    created_at   TEXT    NOT NULL DEFAULT (datetime('now')),
-    updated_at   TEXT    NOT NULL DEFAULT (datetime('now'))
-);
-
-CREATE INDEX IF NOT EXISTS idx_shopping_list_checked
-    ON shopping_list_items (checked, sort_order);

app/db/migrations/034_recipe_jobs.sql

@@ -1,14 +0,0 @@
--- Migration 034: async recipe generation job queue
-CREATE TABLE IF NOT EXISTS recipe_jobs (
-    id          INTEGER PRIMARY KEY AUTOINCREMENT,
-    job_id      TEXT    NOT NULL UNIQUE,
-    user_id     TEXT    NOT NULL,
-    status      TEXT    NOT NULL DEFAULT 'queued',
-    request     TEXT    NOT NULL,
-    result      TEXT,
-    error       TEXT,
-    created_at  TEXT    NOT NULL DEFAULT (datetime('now')),
-    updated_at  TEXT    NOT NULL DEFAULT (datetime('now'))
-);
-CREATE INDEX IF NOT EXISTS idx_recipe_jobs_job_id  ON recipe_jobs (job_id);
-CREATE INDEX IF NOT EXISTS idx_recipe_jobs_user_id ON recipe_jobs (user_id, created_at DESC);

app/db/migrations/035_sensory_tags.sql

@@ -1,12 +0,0 @@
--- Migration 035: add sensory_tags column for sensory profile filtering
---
--- sensory_tags holds a JSON object with texture, smell, and noise signals:
---   {"textures": ["mushy", "creamy"], "smell": "pungent", "noise": "moderate"}
---
--- Empty object '{}' means untagged — these recipes pass ALL sensory filters
--- (graceful degradation when tag_sensory_profiles.py has not yet been run).
---
--- Populated offline by: python scripts/tag_sensory_profiles.py [path/to/kiwi.db]
--- No FTS rebuild needed — sensory_tags is filtered in Python after candidate fetch.
-
-ALTER TABLE recipes ADD COLUMN sensory_tags TEXT NOT NULL DEFAULT '{}';

app/db/migrations/036_captured_products.sql

@@ -1,26 +0,0 @@
--- Migration 036: captured_products local cache
--- Products captured via visual label scanning (kiwi#79).
--- Keyed by barcode; checked before FDC/OFF on future scans so each product
--- is only captured once per device.
-
-CREATE TABLE IF NOT EXISTS captured_products (
-    id                INTEGER PRIMARY KEY AUTOINCREMENT,
-    barcode           TEXT UNIQUE NOT NULL,
-    product_name      TEXT,
-    brand             TEXT,
-    serving_size_g    REAL,
-    calories          REAL,
-    fat_g             REAL,
-    saturated_fat_g   REAL,
-    carbs_g           REAL,
-    sugar_g           REAL,
-    fiber_g           REAL,
-    protein_g         REAL,
-    sodium_mg         REAL,
-    ingredient_names  TEXT NOT NULL DEFAULT '[]',   -- JSON array
-    allergens         TEXT NOT NULL DEFAULT '[]',   -- JSON array
-    confidence        REAL,
-    source            TEXT NOT NULL DEFAULT 'visual_capture',
-    captured_at       TEXT NOT NULL DEFAULT (datetime('now')),
-    confirmed_by_user INTEGER NOT NULL DEFAULT 0
-);

app/db/migrations/037_products_source_visual_capture.sql

@@ -1,34 +0,0 @@
--- Migration 037: add 'visual_capture' to products.source CHECK constraint
--- SQLite cannot ALTER a CHECK constraint, so we rebuild the table.
-
-PRAGMA foreign_keys = OFF;
-
-BEGIN;
-
-CREATE TABLE products_new (
-    id              INTEGER PRIMARY KEY AUTOINCREMENT,
-    barcode         TEXT UNIQUE,
-    name            TEXT NOT NULL,
-    brand           TEXT,
-    category        TEXT,
-    description     TEXT,
-    image_url       TEXT,
-    nutrition_data  TEXT NOT NULL DEFAULT '{}',
-    source          TEXT NOT NULL DEFAULT 'openfoodfacts'
-                         CHECK (source IN ('openfoodfacts', 'manual', 'receipt_ocr', 'visual_capture')),
-    source_data     TEXT,
-    created_at      TEXT NOT NULL DEFAULT (datetime('now')),
-    updated_at      TEXT NOT NULL DEFAULT (datetime('now'))
-);
-
-INSERT INTO products_new
-    SELECT id, barcode, name, brand, category, description, image_url,
-           nutrition_data, source, source_data, created_at, updated_at
-    FROM products;
-
-DROP TABLE products;
-ALTER TABLE products_new RENAME TO products;
-
-COMMIT;
-
-PRAGMA foreign_keys = ON;

app/db/migrations/038_inventory_items_source_visual_capture.sql

@@ -1,43 +0,0 @@
--- Migration 038: add 'visual_capture' to inventory_items.source CHECK constraint
--- SQLite cannot ALTER a CHECK constraint, so we rebuild the table.
-
-PRAGMA foreign_keys = OFF;
-
-BEGIN;
-
-CREATE TABLE inventory_items_new (
-    id              INTEGER PRIMARY KEY AUTOINCREMENT,
-    product_id      INTEGER NOT NULL
-                        REFERENCES products (id) ON DELETE RESTRICT,
-    receipt_id      INTEGER
-                        REFERENCES receipts (id) ON DELETE SET NULL,
-    quantity        REAL NOT NULL DEFAULT 1 CHECK (quantity > 0),
-    unit            TEXT NOT NULL DEFAULT 'count',
-    location        TEXT NOT NULL,
-    sublocation     TEXT,
-    purchase_date   TEXT,
-    expiration_date TEXT,
-    status          TEXT NOT NULL DEFAULT 'available'
-                        CHECK (status IN ('available', 'consumed', 'expired', 'discarded')),
-    consumed_at     TEXT,
-    notes           TEXT,
-    source          TEXT NOT NULL DEFAULT 'manual'
-                        CHECK (source IN ('barcode_scan', 'manual', 'receipt', 'visual_capture')),
-    created_at      TEXT NOT NULL DEFAULT (datetime('now')),
-    updated_at      TEXT NOT NULL DEFAULT (datetime('now')),
-    opened_date     TEXT,
-    disposal_reason TEXT
-);
-
-INSERT INTO inventory_items_new
-    SELECT id, product_id, receipt_id, quantity, unit, location, sublocation,
-           purchase_date, expiration_date, status, consumed_at, notes, source,
-           created_at, updated_at, opened_date, disposal_reason
-    FROM inventory_items;
-
-DROP TABLE inventory_items;
-ALTER TABLE inventory_items_new RENAME TO inventory_items;
-
-COMMIT;
-
-PRAGMA foreign_keys = ON;

app/db/migrations/039_saved_recipes_drop_fk.sql

@@ -1,31 +0,0 @@
--- Migration 039: Drop FK constraint on saved_recipes.recipe_id.
---
--- In cloud mode the recipe corpus is ATTACHed as a separate database.
--- SQLite FK constraints only resolve against the `main` schema, so
--- `REFERENCES recipes(id)` was always failing for cloud saves (the
--- main.recipes table is empty; all data lives in corpus.recipes).
--- The corpus is read-only and never modified by the app, so cascade-on-delete
--- is meaningless anyway. Remove the constraint without changing any data.
-
-PRAGMA foreign_keys = OFF;
-
-CREATE TABLE saved_recipes_new (
-    id          INTEGER PRIMARY KEY AUTOINCREMENT,
-    recipe_id   INTEGER NOT NULL,
-    saved_at    TEXT    NOT NULL DEFAULT (datetime('now')),
-    notes       TEXT,
-    rating      INTEGER CHECK (rating IS NULL OR (rating >= 0 AND rating <= 5)),
-    style_tags  TEXT    NOT NULL DEFAULT '[]',
-    UNIQUE (recipe_id)
-);
-
-INSERT INTO saved_recipes_new SELECT * FROM saved_recipes;
-
-DROP TABLE saved_recipes;
-
-ALTER TABLE saved_recipes_new RENAME TO saved_recipes;
-
-CREATE INDEX IF NOT EXISTS idx_saved_recipes_saved_at ON saved_recipes (saved_at DESC);
-CREATE INDEX IF NOT EXISTS idx_saved_recipes_rating   ON saved_recipes (rating);
-
-PRAGMA foreign_keys = ON;

app/db/migrations/040_corrections.sql

@@ -1,21 +0,0 @@
--- 040_corrections.sql — corrections table for SFT training data
--- Schema from circuitforge_core.api.corrections.CORRECTIONS_MIGRATION_SQL
-CREATE TABLE IF NOT EXISTS corrections (
-    id               INTEGER PRIMARY KEY AUTOINCREMENT,
-    item_id          TEXT    NOT NULL DEFAULT '',
-    product          TEXT    NOT NULL,
-    correction_type  TEXT    NOT NULL,
-    input_text       TEXT    NOT NULL,
-    original_output  TEXT    NOT NULL,
-    corrected_output TEXT    NOT NULL DEFAULT '',
-    rating           TEXT    NOT NULL DEFAULT 'down',
-    context          TEXT    NOT NULL DEFAULT '{}',
-    opted_in         INTEGER NOT NULL DEFAULT 0,
-    created_at       TEXT    NOT NULL DEFAULT (datetime('now'))
-);
-
-CREATE INDEX IF NOT EXISTS idx_corrections_product
-    ON corrections (product);
-
-CREATE INDEX IF NOT EXISTS idx_corrections_opted_in
-    ON corrections (opted_in);

app/db/session.py

@@ -6,8 +6,6 @@ Cloud mode: opens a Store at the per-user DB path from the CloudUser session.
 """
 from __future__ import annotations
 
-import sqlite3
-from collections.abc import Iterator
 from typing import Generator
 
 from fastapi import Depends
@@ -23,16 +21,3 @@ def get_store(session: CloudUser = Depends(get_session)) -> Generator[Store, Non
         yield store
     finally:
         store.close()
-
-
-def get_db(session: CloudUser = Depends(get_session)) -> Iterator[sqlite3.Connection]:
-    """FastAPI dependency — yields the raw sqlite3.Connection for the current user.
-
-    Used by make_corrections_router() from circuitforge-core, which expects a
-    dependency that yields a sqlite3.Connection directly.
-    """
-    store = Store(session.db)
-    try:
-        yield store.conn
-    finally:
-        store.close()

app/db/store.py

@@ -11,7 +11,6 @@ from typing import Any
 
 from circuitforge_core.db.base import get_connection
 from circuitforge_core.db.migrations import run_migrations
-from app.services.recipe.sensory import SensoryExclude, passes_sensory_filter
 
 MIGRATIONS_DIR = Path(__file__).parent / "migrations"
 
@@ -24,25 +23,12 @@ _COUNT_CACHE: dict[tuple[str, ...], int] = {}
 
 class Store:
     def __init__(self, db_path: Path, key: str = "") -> None:
-        import os
         self._db_path = str(db_path)
         self.conn: sqlite3.Connection = get_connection(db_path, key)
         self.conn.execute("PRAGMA journal_mode=WAL")
         self.conn.execute("PRAGMA foreign_keys=ON")
         run_migrations(self.conn, MIGRATIONS_DIR)
 
-        # When RECIPE_DB_PATH is set (cloud mode), attach the shared read-only
-        # corpus DB as the "corpus" schema so per-user DBs can access recipe data.
-        # _cp (corpus prefix) is "corpus." in cloud mode, "" in local mode.
-        corpus_path = os.environ.get("RECIPE_DB_PATH", "")
-        if corpus_path:
-            self.conn.execute("ATTACH DATABASE ? AS corpus", (corpus_path,))
-            self._cp = "corpus."
-            self._corpus_path = corpus_path
-        else:
-            self._cp = ""
-            self._corpus_path = self._db_path
-
     def close(self) -> None:
         self.conn.close()
 
@@ -60,9 +46,7 @@ class Store:
                     # saved recipe columns
                     "style_tags",
                     # meal plan columns
-                    "meal_types",
+                    "meal_types"):
-                    # captured_products columns
-                    "allergens"):
             if key in d and isinstance(d[key], str):
                 try:
                     d[key] = json.loads(d[key])
@@ -234,8 +218,7 @@ class Store:
 
     def update_inventory_item(self, item_id: int, **kwargs) -> dict[str, Any] | None:
         allowed = {"quantity", "unit", "location", "sublocation",
-                   "purchase_date", "expiration_date", "opened_date",
+                   "expiration_date", "status", "notes", "consumed_at"}
-                   "status", "notes", "consumed_at", "disposal_reason"}
         updates = {k: v for k, v in kwargs.items() if k in allowed}
         if not updates:
             return self.get_inventory_item(item_id)
@@ -248,32 +231,6 @@ class Store:
         self.conn.commit()
         return self.get_inventory_item(item_id)
 
-    def partial_consume_item(
-        self,
-        item_id: int,
-        consume_qty: float,
-        consumed_at: str,
-    ) -> dict[str, Any] | None:
-        """Decrement quantity by consume_qty. Mark consumed when quantity reaches 0."""
-        row = self.get_inventory_item(item_id)
-        if row is None:
-            return None
-        remaining = max(0.0, round(row["quantity"] - consume_qty, 6))
-        if remaining <= 0:
-            self.conn.execute(
-                "UPDATE inventory_items SET quantity = 0, status = 'consumed',"
-                " consumed_at = ?, updated_at = datetime('now') WHERE id = ?",
-                (consumed_at, item_id),
-            )
-        else:
-            self.conn.execute(
-                "UPDATE inventory_items SET quantity = ?, updated_at = datetime('now')"
-                " WHERE id = ?",
-                (remaining, item_id),
-            )
-        self.conn.commit()
-        return self.get_inventory_item(item_id)
-
     def expiring_soon(self, days: int = 7) -> list[dict[str, Any]]:
         return self._fetch_all(
             """SELECT i.*, p.name as product_name, p.category
@@ -388,9 +345,8 @@ class Store:
 
     def _fts_ready(self) -> bool:
         """Return True if the recipes_fts virtual table exists."""
-        schema = "corpus" if self._cp else "main"
         row = self._fetch_one(
-            f"SELECT 1 FROM {schema}.sqlite_master WHERE type='table' AND name='recipes_fts'"
+            "SELECT 1 FROM sqlite_master WHERE type='table' AND name='recipes_fts'"
         )
         return row is not None
 
@@ -681,12 +637,10 @@ class Store:
             return []
 
         # Pull up to 10× limit candidates so ranking has enough headroom.
-        # FTS5 pseudo-column in WHERE uses bare table name, not schema-qualified.
-        c = self._cp
         sql = f"""
             SELECT r.*
-            FROM {c}recipes_fts
+            FROM recipes_fts
-            JOIN {c}recipes r ON r.id = {c}recipes_fts.rowid
+            JOIN recipes r ON r.id = recipes_fts.rowid
             WHERE recipes_fts MATCH ?
             {where_extra}
             LIMIT ?
@@ -720,10 +674,9 @@ class Store:
             "CASE WHEN r.ingredient_names LIKE ? THEN 1 ELSE 0 END"
             for _ in ingredient_names
         )
-        c = self._cp
         sql = f"""
             SELECT r.*, ({match_score}) AS match_count
-            FROM {c}recipes r
+            FROM recipes r
             WHERE ({like_clauses})
             {where_extra}
             ORDER BY match_count DESC, r.id ASC
@@ -733,46 +686,7 @@ class Store:
         return self._fetch_all(sql, tuple(all_params))
 
     def get_recipe(self, recipe_id: int) -> dict | None:
-        row = self._fetch_one(f"SELECT * FROM {self._cp}recipes WHERE id = ?", (recipe_id,))
+        return self._fetch_one("SELECT * FROM recipes WHERE id = ?", (recipe_id,))
-        if row is None and self._cp:
-            # Fall back to user's own assembled recipes in main schema
-            row = self._fetch_one("SELECT * FROM recipes WHERE id = ?", (recipe_id,))
-        return row
-
-    # --- Async recipe jobs ---
-
-    def create_recipe_job(self, job_id: str, user_id: str, request_json: str) -> sqlite3.Row:
-        return self._insert_returning(
-            "INSERT INTO recipe_jobs (job_id, user_id, status, request) VALUES (?,?,?,?) RETURNING *",
-            (job_id, user_id, "queued", request_json),
-        )
-
-    def get_recipe_job(self, job_id: str, user_id: str) -> sqlite3.Row | None:
-        return self._fetch_one(
-            "SELECT * FROM recipe_jobs WHERE job_id=? AND user_id=?",
-            (job_id, user_id),
-        )
-
-    def update_recipe_job_running(self, job_id: str) -> None:
-        self.conn.execute(
-            "UPDATE recipe_jobs SET status='running', updated_at=datetime('now') WHERE job_id=?",
-            (job_id,),
-        )
-        self.conn.commit()
-
-    def complete_recipe_job(self, job_id: str, result_json: str) -> None:
-        self.conn.execute(
-            "UPDATE recipe_jobs SET status='done', result=?, updated_at=datetime('now') WHERE job_id=?",
-            (result_json, job_id),
-        )
-        self.conn.commit()
-
-    def fail_recipe_job(self, job_id: str, error: str) -> None:
-        self.conn.execute(
-            "UPDATE recipe_jobs SET status='failed', error=?, updated_at=datetime('now') WHERE job_id=?",
-            (error, job_id),
-        )
-        self.conn.commit()
 
     def upsert_built_recipe(
         self,
@@ -823,7 +737,7 @@ class Store:
             return {}
         placeholders = ",".join("?" * len(names))
         rows = self._fetch_all(
-            f"SELECT name, elements FROM {self._cp}ingredient_profiles WHERE name IN ({placeholders})",
+            f"SELECT name, elements FROM ingredient_profiles WHERE name IN ({placeholders})",
             tuple(names),
         )
         result: dict[str, list[str]] = {}
@@ -964,25 +878,12 @@ class Store:
             "title":    "r.title ASC",
         }.get(sort_by, "sr.saved_at DESC")
 
-        c = self._cp
-        # In corpus-attached (cloud) mode: try corpus recipes first, fall back
-        # to user's own assembled recipes. In local mode: single join suffices.
-        if c:
-            recipe_join = (
-                f"LEFT JOIN {c}recipes rc ON rc.id = sr.recipe_id "
-                "LEFT JOIN recipes rm ON rm.id = sr.recipe_id"
-            )
-            title_col = "COALESCE(rc.title, rm.title) AS title"
-        else:
-            recipe_join = "JOIN recipes rc ON rc.id = sr.recipe_id"
-            title_col = "rc.title"
-
         if collection_id is not None:
             return self._fetch_all(
                 f"""
-                SELECT sr.*, {title_col}
+                SELECT sr.*, r.title
                 FROM saved_recipes sr
-                {recipe_join}
+                JOIN recipes r ON r.id = sr.recipe_id
                 JOIN recipe_collection_members rcm ON rcm.saved_recipe_id = sr.id
                 WHERE rcm.collection_id = ?
                 ORDER BY {order}
@@ -991,9 +892,9 @@ class Store:
             )
         return self._fetch_all(
             f"""
-            SELECT sr.*, {title_col}
+            SELECT sr.*, r.title
             FROM saved_recipes sr
-            {recipe_join}
+            JOIN recipes r ON r.id = sr.recipe_id
             ORDER BY {order}
             """,
         )
@@ -1008,26 +909,10 @@ class Store:
     # ── recipe collections ────────────────────────────────────────────────
 
     def create_collection(self, name: str, description: str | None) -> dict:
-        # INSERT RETURNING * omits aggregate columns (e.g. member_count); re-query
+        return self._insert_returning(
-        # with the same SELECT used by get_collections() so the response shape is consistent.
+            "INSERT INTO recipe_collections (name, description) VALUES (?, ?) RETURNING *",
-        cur = self.conn.execute(
-            "INSERT INTO recipe_collections (name, description) VALUES (?, ?)",
             (name, description),
         )
-        self.conn.commit()
-        new_id = cur.lastrowid
-        row = self._fetch_one(
-            """
-            SELECT rc.*,
-                   COUNT(rcm.saved_recipe_id) AS member_count
-            FROM recipe_collections rc
-            LEFT JOIN recipe_collection_members rcm ON rcm.collection_id = rc.id
-            WHERE rc.id = ?
-            GROUP BY rc.id
-            """,
-            (new_id,),
-        )
-        return row  # type: ignore[return-value]
 
     def delete_collection(self, collection_id: int) -> None:
         self.conn.execute(
@@ -1089,38 +974,17 @@ class Store:
     # ── recipe browser ────────────────────────────────────────────────────
 
     def get_browser_categories(
-        self,
+        self, domain: str, keywords_by_category: dict[str, list[str]]
-        domain: str,
-        keywords_by_category: dict[str, list[str]],
-        has_subcategories_by_category: dict[str, bool] | None = None,
     ) -> list[dict]:
-        """Return [{category, recipe_count, has_subcategories}] for each category.
+        """Return [{category, recipe_count}] for each category in the domain.
 
-        keywords_by_category maps category name → keyword list for counting.
+        keywords_by_category maps category name to the keyword list used to
-        has_subcategories_by_category maps category name → bool (optional;
+        match against recipes.category and recipes.keywords.
-        defaults to False for all categories when omitted).
         """
         results = []
         for category, keywords in keywords_by_category.items():
             count = self._count_recipes_for_keywords(keywords)
-            results.append({
+            results.append({"category": category, "recipe_count": count})
-                "category": category,
-                "recipe_count": count,
-                "has_subcategories": (has_subcategories_by_category or {}).get(category, False),
-            })
-        return results
-
-    def get_browser_subcategories(
-        self, domain: str, keywords_by_subcategory: dict[str, list[str]]
-    ) -> list[dict]:
-        """Return [{subcategory, recipe_count}] for each subcategory.
-
-        Mirrors get_browser_categories but for the second level.
-        """
-        results = []
-        for subcat, keywords in keywords_by_subcategory.items():
-            count = self._count_recipes_for_keywords(keywords)
-            results.append({"subcategory": subcat, "recipe_count": count})
         return results
 
     @staticmethod
@@ -1132,16 +996,12 @@ class Store:
     def _count_recipes_for_keywords(self, keywords: list[str]) -> int:
         if not keywords:
             return 0
-        # Use corpus path as cache key so all cloud users share the same counts.
+        cache_key = (self._db_path, *sorted(keywords))
-        cache_key = (self._corpus_path, *sorted(keywords))
         if cache_key in _COUNT_CACHE:
             return _COUNT_CACHE[cache_key]
         match_expr = self._browser_fts_query(keywords)
-        c = self._cp
-        # FTS5 pseudo-column in WHERE is always the bare (unqualified) table name,
-        # even when the table is accessed through an ATTACHed schema.
         row = self.conn.execute(
-            f"SELECT count(*) FROM {c}recipe_browser_fts WHERE recipe_browser_fts MATCH ?",
+            "SELECT count(*) FROM recipe_browser_fts WHERE recipe_browser_fts MATCH ?",
             (match_expr,),
         ).fetchone()
         count = row[0] if row else 0
@@ -1150,101 +1010,44 @@ class Store:
 
     def browse_recipes(
         self,
-        keywords: list[str] | None,
+        keywords: list[str],
         page: int,
         page_size: int,
         pantry_items: list[str] | None = None,
-        q: str | None = None,
-        sort: str = "default",
-        sensory_exclude: SensoryExclude | None = None,
     ) -> dict:
         """Return a page of recipes matching the keyword set.
 
-        Pass keywords=None to browse all recipes without category filtering.
         Each recipe row includes match_pct (float | None) when pantry_items
         is provided. match_pct is the fraction of ingredient_names covered by
         the pantry set — computed deterministically, no LLM needed.
-
-        q:    optional title substring filter (case-insensitive LIKE).
-        sort: "default" (corpus order) | "alpha" (A→Z) | "alpha_desc" (Z→A)
-              | "match" (pantry coverage DESC — falls back to default when no pantry).
         """
-        if keywords is not None and not keywords:
+        if not keywords:
             return {"recipes": [], "total": 0, "page": page}
 
-        offset = (page - 1) * page_size
-        c = self._cp
-        pantry_set = {p.lower() for p in pantry_items} if pantry_items else None
-
-        # "match" sort requires pantry items; fall back gracefully when absent.
-        effective_sort = sort if (sort != "match" or pantry_set) else "default"
-
-        order_clause = {
-            "alpha":      "ORDER BY title ASC",
-            "alpha_desc": "ORDER BY title DESC",
-        }.get(effective_sort, "ORDER BY id ASC")
-
-        q_param = f"%{q.strip()}%" if q and q.strip() else None
-
-        # ── match sort: push match_pct computation into SQL so ORDER BY works ──
-        if effective_sort == "match" and pantry_set:
-            return self._browse_by_match(
-                keywords, page, page_size, offset, pantry_set, q_param, c,
-                sensory_exclude=sensory_exclude,
-            )
-
-        cols = (
-            f"SELECT id, title, category, keywords, ingredient_names,"
-            f"       calories, fat_g, protein_g, sodium_mg, directions, sensory_tags FROM {c}recipes"
-        )
-
-        if keywords is None:
-            if q_param:
-                total = self.conn.execute(
-                    f"SELECT COUNT(*) FROM {c}recipes WHERE LOWER(title) LIKE LOWER(?)",
-                    (q_param,),
-                ).fetchone()[0]
-                rows = self._fetch_all(
-                    f"{cols} WHERE LOWER(title) LIKE LOWER(?) {order_clause} LIMIT ? OFFSET ?",
-                    (q_param, page_size, offset),
-                )
-            else:
-                total = self.conn.execute(f"SELECT COUNT(*) FROM {c}recipes").fetchone()[0]
-                rows = self._fetch_all(
-                    f"{cols} {order_clause} LIMIT ? OFFSET ?",
-                    (page_size, offset),
-                )
-        else:
         match_expr = self._browser_fts_query(keywords)
-            fts_sub = f"id IN (SELECT rowid FROM {c}recipe_browser_fts WHERE recipe_browser_fts MATCH ?)"
+        offset = (page - 1) * page_size
-            if q_param:
+
-                total = self.conn.execute(
-                    f"SELECT COUNT(*) FROM {c}recipes WHERE {fts_sub} AND LOWER(title) LIKE LOWER(?)",
-                    (match_expr, q_param),
-                ).fetchone()[0]
-                rows = self._fetch_all(
-                    f"{cols} WHERE {fts_sub} AND LOWER(title) LIKE LOWER(?) {order_clause} LIMIT ? OFFSET ?",
-                    (match_expr, q_param, page_size, offset),
-                )
-            else:
         # Reuse cached count — avoids a second index scan on every page turn.
         total = self._count_recipes_for_keywords(keywords)
+
         rows = self._fetch_all(
-                    f"{cols} WHERE {fts_sub} {order_clause} LIMIT ? OFFSET ?",
+            """
+            SELECT id, title, category, keywords, ingredient_names,
+                   calories, fat_g, protein_g, sodium_mg
+            FROM recipes
+            WHERE id IN (
+                SELECT rowid FROM recipe_browser_fts
+                WHERE recipe_browser_fts MATCH ?
+            )
+            ORDER BY id ASC
+            LIMIT ? OFFSET ?
+            """,
             (match_expr, page_size, offset),
         )
-                # Community tag fallback: if FTS found nothing, check whether
-                # community-tagged recipe IDs exist for this keyword context.
-                # browse_recipes doesn't know domain/category directly, so the
-                # fallback is triggered by the caller via community_ids= when needed.
-                # (See browse_recipes_with_community_fallback in the endpoint layer.)
 
+        pantry_set = {p.lower() for p in pantry_items} if pantry_items else None
         recipes = []
         for r in rows:
-            # Apply sensory filter -- untagged recipes (empty {}) always pass
-            if sensory_exclude and not sensory_exclude.is_empty():
-                if not passes_sensory_filter(r.get("sensory_tags"), sensory_exclude):
-                    continue
             entry = {
                 "id":         r["id"],
                 "title":      r["title"],
@@ -1254,159 +1057,14 @@ class Store:
             if pantry_set:
                 names = r.get("ingredient_names") or []
                 if names:
-                    matched = sum(1 for n in names if n.lower() in pantry_set)
+                    matched = sum(
+                        1 for n in names if n.lower() in pantry_set
+                    )
                     entry["match_pct"] = round(matched / len(names), 3)
             recipes.append(entry)
 
         return {"recipes": recipes, "total": total, "page": page}
 
-    def fetch_recipes_by_ids(
-        self,
-        recipe_ids: list[int],
-        pantry_items: list[str] | None = None,
-    ) -> list[dict]:
-        """Fetch a specific set of corpus recipes by ID for community tag fallback.
-
-        Returns recipes in the same shape as browse_recipes rows, with match_pct
-        populated when pantry_items are provided.
-        """
-        if not recipe_ids:
-            return []
-        c = self._cp
-        pantry_set = {p.lower() for p in pantry_items} if pantry_items else None
-        ph = ",".join("?" * len(recipe_ids))
-        rows = self._fetch_all(
-            f"SELECT id, title, category, keywords, ingredient_names,"
-            f"       calories, fat_g, protein_g, sodium_mg, directions"
-            f" FROM {c}recipes WHERE id IN ({ph}) ORDER BY id ASC",
-            tuple(recipe_ids),
-        )
-        result = []
-        for r in rows:
-            entry: dict = {
-                "id":        r["id"],
-                "title":     r["title"],
-                "category":  r["category"],
-                "match_pct": None,
-            }
-            entry["directions"] = r.get("directions")
-            if pantry_set:
-                names = r.get("ingredient_names") or []
-                if names:
-                    matched = sum(1 for n in names if n.lower() in pantry_set)
-                    entry["match_pct"] = round(matched / len(names), 3)
-            result.append(entry)
-        return result
-
-    # How many FTS candidates to fetch before Python-scoring for match sort.
-    # Large enough to cover several pages with good diversity; small enough
-    # that json-parsing + dict-lookup stays sub-second even for big categories.
-    _MATCH_POOL_SIZE = 800
-
-    def _browse_by_match(
-        self,
-        keywords: list[str] | None,
-        page: int,
-        page_size: int,
-        offset: int,
-        pantry_set: set[str],
-        q_param: str | None,
-        c: str,
-        sensory_exclude: SensoryExclude | None = None,
-    ) -> dict:
-        """Browse recipes sorted by pantry match percentage.
-
-        Fetches up to _MATCH_POOL_SIZE FTS candidates, scores each against the
-        pantry set in Python (fast dict lookup on a bounded list), then sorts
-        and paginates in-memory. This avoids correlated json_each() subqueries
-        that are prohibitively slow over 50k+ row result sets.
-
-        The reported total is the full FTS count (from cache), not pool size.
-        """
-        import json as _json
-
-        pantry_lower = {p.lower() for p in pantry_set}
-
-        # ── Fetch candidate pool from FTS ────────────────────────────────────
-        base_cols = (
-            f"SELECT r.id, r.title, r.category, r.ingredient_names, r.directions, r.sensory_tags"
-            f" FROM {c}recipes r"
-        )
-
-        self.conn.row_factory = sqlite3.Row
-
-        if keywords is None:
-            if q_param:
-                total = self.conn.execute(
-                    f"SELECT COUNT(*) FROM {c}recipes WHERE LOWER(title) LIKE LOWER(?)",
-                    (q_param,),
-                ).fetchone()[0]
-                rows = self.conn.execute(
-                    f"{base_cols} WHERE LOWER(r.title) LIKE LOWER(?)"
-                    f" ORDER BY r.id ASC LIMIT ?",
-                    (q_param, self._MATCH_POOL_SIZE),
-                ).fetchall()
-            else:
-                total = self.conn.execute(
-                    f"SELECT COUNT(*) FROM {c}recipes"
-                ).fetchone()[0]
-                rows = self.conn.execute(
-                    f"{base_cols} ORDER BY r.id ASC LIMIT ?",
-                    (self._MATCH_POOL_SIZE,),
-                ).fetchall()
-        else:
-            match_expr = self._browser_fts_query(keywords)
-            fts_sub = (
-                f"r.id IN (SELECT rowid FROM {c}recipe_browser_fts"
-                f" WHERE recipe_browser_fts MATCH ?)"
-            )
-            if q_param:
-                total = self.conn.execute(
-                    f"SELECT COUNT(*) FROM {c}recipes r"
-                    f" WHERE {fts_sub} AND LOWER(r.title) LIKE LOWER(?)",
-                    (match_expr, q_param),
-                ).fetchone()[0]
-                rows = self.conn.execute(
-                    f"{base_cols} WHERE {fts_sub} AND LOWER(r.title) LIKE LOWER(?)"
-                    f" ORDER BY r.id ASC LIMIT ?",
-                    (match_expr, q_param, self._MATCH_POOL_SIZE),
-                ).fetchall()
-            else:
-                total = self._count_recipes_for_keywords(keywords)
-                rows = self.conn.execute(
-                    f"{base_cols} WHERE {fts_sub} ORDER BY r.id ASC LIMIT ?",
-                    (match_expr, self._MATCH_POOL_SIZE),
-                ).fetchall()
-
-        # ── Score in Python, sort, paginate ──────────────────────────────────
-        scored = []
-        for r in rows:
-            row = dict(r)
-            # Sensory filter applied before scoring to keep hot path clean
-            if sensory_exclude and not sensory_exclude.is_empty():
-                if not passes_sensory_filter(row.get("sensory_tags"), sensory_exclude):
-                    continue
-            try:
-                names = _json.loads(row["ingredient_names"] or "[]")
-            except Exception:
-                names = []
-            if names:
-                matched = sum(1 for n in names if n.lower() in pantry_lower)
-                match_pct = round(matched / len(names), 3)
-            else:
-                match_pct = None
-            scored.append({
-                "id":        row["id"],
-                "title":     row["title"],
-                "category":  row["category"],
-                "match_pct": match_pct,
-                "directions": row.get("directions"),
-            })
-
-        scored.sort(key=lambda r: (-(r["match_pct"] or 0), r["id"]))
-        page_slice = scored[offset: offset + page_size]
-        return {"recipes": page_slice, "total": total, "page": page}
-
     def log_browser_telemetry(
         self,
         domain: str,
@@ -1434,12 +1092,6 @@ class Store:
     def get_meal_plan(self, plan_id: int) -> dict | None:
         return self._fetch_one("SELECT * FROM meal_plans WHERE id = ?", (plan_id,))
 
-    def update_meal_plan_types(self, plan_id: int, meal_types: list[str]) -> dict | None:
-        return self._fetch_one(
-            "UPDATE meal_plans SET meal_types = ? WHERE id = ? RETURNING *",
-            (json.dumps(meal_types), plan_id),
-        )
-
     def list_meal_plans(self) -> list[dict]:
         return self._fetch_all("SELECT * FROM meal_plans ORDER BY week_start DESC")
 
@@ -1469,11 +1121,10 @@ class Store:
         self.conn.commit()
 
     def get_plan_slots(self, plan_id: int) -> list[dict]:
-        c = self._cp
         return self._fetch_all(
-            f"""SELECT s.*, r.title AS recipe_title
+            """SELECT s.*, r.name AS recipe_title
                FROM meal_plan_slots s
-               LEFT JOIN {c}recipes r ON r.id = s.recipe_id
+               LEFT JOIN recipes r ON r.id = s.recipe_id
                WHERE s.plan_id = ?
                ORDER BY s.day_of_week, s.meal_type""",
             (plan_id,),
@@ -1481,11 +1132,10 @@ class Store:
 
     def get_plan_recipes(self, plan_id: int) -> list[dict]:
         """Return full recipe rows for all recipes assigned to a plan."""
-        c = self._cp
         return self._fetch_all(
-            f"""SELECT DISTINCT r.*
+            """SELECT DISTINCT r.*
                FROM meal_plan_slots s
-               JOIN {c}recipes r ON r.id = s.recipe_id
+               JOIN recipes r ON r.id = s.recipe_id
                WHERE s.plan_id = ? AND s.recipe_id IS NOT NULL""",
             (plan_id,),
         )
@@ -1573,141 +1223,3 @@ class Store:
             (pseudonym, directus_user_id),
         )
         self.conn.commit()
-
-    # ── Shopping list ─────────────────────────────────────────────────────────
-
-    def add_shopping_item(
-        self,
-        name: str,
-        quantity: float | None = None,
-        unit: str | None = None,
-        category: str | None = None,
-        notes: str | None = None,
-        source: str = "manual",
-        recipe_id: int | None = None,
-        sort_order: int = 0,
-    ) -> dict:
-        return self._insert_returning(
-            """INSERT INTO shopping_list_items
-               (name, quantity, unit, category, notes, source, recipe_id, sort_order)
-               VALUES (?, ?, ?, ?, ?, ?, ?, ?) RETURNING *""",
-            (name, quantity, unit, category, notes, source, recipe_id, sort_order),
-        )
-
-    def list_shopping_items(self, include_checked: bool = True) -> list[dict]:
-        where = "" if include_checked else "WHERE checked = 0"
-        self.conn.row_factory = sqlite3.Row
-        rows = self.conn.execute(
-            f"SELECT * FROM shopping_list_items {where} ORDER BY checked, sort_order, id",
-        ).fetchall()
-        return [self._row_to_dict(r) for r in rows]
-
-    def get_shopping_item(self, item_id: int) -> dict | None:
-        self.conn.row_factory = sqlite3.Row
-        row = self.conn.execute(
-            "SELECT * FROM shopping_list_items WHERE id = ?", (item_id,)
-        ).fetchone()
-        return self._row_to_dict(row) if row else None
-
-    def update_shopping_item(self, item_id: int, **kwargs) -> dict | None:
-        allowed = {"name", "quantity", "unit", "category", "checked", "notes", "sort_order"}
-        fields = {k: v for k, v in kwargs.items() if k in allowed and v is not None}
-        if not fields:
-            return self.get_shopping_item(item_id)
-        if "checked" in fields:
-            fields["checked"] = 1 if fields["checked"] else 0
-        set_clause = ", ".join(f"{k} = ?" for k in fields)
-        values = list(fields.values()) + [item_id]
-        self.conn.execute(
-            f"UPDATE shopping_list_items SET {set_clause}, updated_at = datetime('now') WHERE id = ?",
-            values,
-        )
-        self.conn.commit()
-        return self.get_shopping_item(item_id)
-
-    def delete_shopping_item(self, item_id: int) -> bool:
-        cur = self.conn.execute(
-            "DELETE FROM shopping_list_items WHERE id = ?", (item_id,)
-        )
-        self.conn.commit()
-        return cur.rowcount > 0
-
-    def clear_checked_shopping_items(self) -> int:
-        cur = self.conn.execute("DELETE FROM shopping_list_items WHERE checked = 1")
-        self.conn.commit()
-        return cur.rowcount
-
-    def clear_all_shopping_items(self) -> int:
-        cur = self.conn.execute("DELETE FROM shopping_list_items")
-        self.conn.commit()
-        return cur.rowcount
-
-    # ── Captured products (visual label cache) ────────────────────────────────
-
-    def get_captured_product(self, barcode: str) -> dict | None:
-        """Look up a locally-captured product by barcode.
-
-        Returns the row dict (ingredient_names and allergens already decoded as
-        lists) or None if the barcode has not been captured yet.
-        """
-        return self._fetch_one(
-            "SELECT * FROM captured_products WHERE barcode = ?", (barcode,)
-        )
-
-    def save_captured_product(
-        self,
-        barcode: str,
-        *,
-        product_name: str | None = None,
-        brand: str | None = None,
-        serving_size_g: float | None = None,
-        calories: float | None = None,
-        fat_g: float | None = None,
-        saturated_fat_g: float | None = None,
-        carbs_g: float | None = None,
-        sugar_g: float | None = None,
-        fiber_g: float | None = None,
-        protein_g: float | None = None,
-        sodium_mg: float | None = None,
-        ingredient_names: list[str] | None = None,
-        allergens: list[str] | None = None,
-        confidence: float | None = None,
-        confirmed_by_user: bool = True,
-        source: str = "visual_capture",
-    ) -> dict:
-        """Insert or replace a captured product row, returning the saved dict."""
-        return self._insert_returning(
-            """INSERT INTO captured_products
-               (barcode, product_name, brand, serving_size_g, calories,
-                fat_g, saturated_fat_g, carbs_g, sugar_g, fiber_g,
-                protein_g, sodium_mg, ingredient_names, allergens,
-                confidence, confirmed_by_user, source)
-               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-               ON CONFLICT(barcode) DO UPDATE SET
-                 product_name      = excluded.product_name,
-                 brand             = excluded.brand,
-                 serving_size_g    = excluded.serving_size_g,
-                 calories          = excluded.calories,
-                 fat_g             = excluded.fat_g,
-                 saturated_fat_g   = excluded.saturated_fat_g,
-                 carbs_g           = excluded.carbs_g,
-                 sugar_g           = excluded.sugar_g,
-                 fiber_g           = excluded.fiber_g,
-                 protein_g         = excluded.protein_g,
-                 sodium_mg         = excluded.sodium_mg,
-                 ingredient_names  = excluded.ingredient_names,
-                 allergens         = excluded.allergens,
-                 confidence        = excluded.confidence,
-                 confirmed_by_user = excluded.confirmed_by_user,
-                 source            = excluded.source,
-                 captured_at       = datetime('now')
-               RETURNING *""",
-            (
-                barcode, product_name, brand, serving_size_g, calories,
-                fat_g, saturated_fat_g, carbs_g, sugar_g, fiber_g,
-                protein_g, sodium_mg,
-                self._dump(ingredient_names or []),
-                self._dump(allergens or []),
-                confidence, 1 if confirmed_by_user else 0, source,
-            ),
-        )

app/main.py

@@ -1,9 +1,7 @@
 #!/usr/bin/env python
 # app/main.py
 
-import asyncio
 import logging
-import os
 from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
@@ -13,31 +11,8 @@ from app.api.routes import api_router
 from app.core.config import settings
 from app.services.meal_plan.affiliates import register_kiwi_programs
 
-# Structured key=value log lines — grep/awk-friendly for log-based analytics.
-# Without basicConfig, app-level INFO logs are silently dropped.
-logging.basicConfig(level=logging.INFO, format="%(levelname)s:%(name)s: %(message)s")
 logger = logging.getLogger(__name__)
 
-_BROWSE_REFRESH_INTERVAL_H = 24
-
-
-async def _browse_counts_refresh_loop(corpus_path: str) -> None:
-    """Refresh browse counts every 24 h while the container is running."""
-    from app.db.store import _COUNT_CACHE
-    from app.services.recipe.browse_counts_cache import load_into_memory, refresh
-
-    while True:
-        await asyncio.sleep(_BROWSE_REFRESH_INTERVAL_H * 3600)
-        try:
-            logger.info("browse_counts: starting scheduled refresh...")
-            computed = await asyncio.to_thread(
-                refresh, corpus_path, settings.BROWSE_COUNTS_PATH
-            )
-            load_into_memory(settings.BROWSE_COUNTS_PATH, _COUNT_CACHE, corpus_path)
-            logger.info("browse_counts: scheduled refresh complete (%d sets)", computed)
-        except Exception as exc:
-            logger.warning("browse_counts: scheduled refresh failed: %s", exc)
-
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -54,27 +29,6 @@ async def lifespan(app: FastAPI):
     from app.api.endpoints.community import init_community_store
     init_community_store(settings.COMMUNITY_DB_URL)
 
-    # Browse counts cache — warm in-memory cache from disk, refresh if stale.
-    # Uses the corpus path the store will attach to at request time.
-    corpus_path = os.environ.get("RECIPE_DB_PATH", str(settings.DB_PATH))
-    try:
-        from app.db.store import _COUNT_CACHE
-        from app.services.recipe.browse_counts_cache import (
-            is_stale, load_into_memory, refresh,
-        )
-        if is_stale(settings.BROWSE_COUNTS_PATH):
-            logger.info("browse_counts: cache stale — refreshing in background...")
-            asyncio.create_task(
-                asyncio.to_thread(refresh, corpus_path, settings.BROWSE_COUNTS_PATH)
-            )
-        else:
-            load_into_memory(settings.BROWSE_COUNTS_PATH, _COUNT_CACHE, corpus_path)
-    except Exception as exc:
-        logger.warning("browse_counts: startup init failed (live FTS fallback active): %s", exc)
-
-    # Nightly background refresh loop
-    asyncio.create_task(_browse_counts_refresh_loop(corpus_path))
-
     yield
 
     # Graceful scheduler shutdown

app/models/schemas/inventory.py

@@ -89,20 +89,9 @@ class InventoryItemUpdate(BaseModel):
     unit: Optional[str] = None
     location: Optional[str] = None
     sublocation: Optional[str] = None
-    purchase_date: Optional[date] = None
     expiration_date: Optional[date] = None
-    opened_date: Optional[date] = None
     status: Optional[str] = None
     notes: Optional[str] = None
-    disposal_reason: Optional[str] = None
-
-
-class PartialConsumeRequest(BaseModel):
-    quantity: float = Field(..., gt=0, description="Amount to consume from this item")
-
-
-class DiscardRequest(BaseModel):
-    reason: Optional[str] = Field(None, max_length=200)
 
 
 class InventoryItemResponse(BaseModel):
@@ -117,15 +106,8 @@ class InventoryItemResponse(BaseModel):
     sublocation: Optional[str]
     purchase_date: Optional[str]
     expiration_date: Optional[str]
-    opened_date: Optional[str] = None
-    opened_expiry_date: Optional[str] = None
-    secondary_state: Optional[str] = None
-    secondary_uses: Optional[List[str]] = None
-    secondary_warning: Optional[str] = None
-    secondary_discard_signs: Optional[str] = None
     status: str
     notes: Optional[str]
-    disposal_reason: Optional[str] = None
     source: str
     created_at: str
     updated_at: str
@@ -141,8 +123,6 @@ class BarcodeScanResult(BaseModel):
     product: Optional[ProductResponse]
     inventory_item: Optional[InventoryItemResponse]
     added_to_inventory: bool
-    needs_manual_entry: bool = False
-    needs_visual_capture: bool = False  # Paid tier offer when no product data found
     message: str
 
 

app/models/schemas/label_capture.py

@@ -1,59 +0,0 @@
-"""Pydantic schemas for visual label capture (kiwi#79)."""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from pydantic import BaseModel, Field
-
-
-class LabelCaptureResponse(BaseModel):
-    """Extraction result returned after the user photographs a nutrition label."""
-    barcode: str
-    product_name: Optional[str] = None
-    brand: Optional[str] = None
-    serving_size_g: Optional[float] = None
-    calories: Optional[float] = None
-    fat_g: Optional[float] = None
-    saturated_fat_g: Optional[float] = None
-    carbs_g: Optional[float] = None
-    sugar_g: Optional[float] = None
-    fiber_g: Optional[float] = None
-    protein_g: Optional[float] = None
-    sodium_mg: Optional[float] = None
-    ingredient_names: List[str] = Field(default_factory=list)
-    allergens: List[str] = Field(default_factory=list)
-    confidence: float = 0.0
-    needs_review: bool = True   # True when confidence < REVIEW_THRESHOLD
-
-
-class LabelConfirmRequest(BaseModel):
-    """User-confirmed extraction to save to the local product cache."""
-    barcode: str
-    product_name: Optional[str] = None
-    brand: Optional[str] = None
-    serving_size_g: Optional[float] = None
-    calories: Optional[float] = None
-    fat_g: Optional[float] = None
-    saturated_fat_g: Optional[float] = None
-    carbs_g: Optional[float] = None
-    sugar_g: Optional[float] = None
-    fiber_g: Optional[float] = None
-    protein_g: Optional[float] = None
-    sodium_mg: Optional[float] = None
-    ingredient_names: List[str] = Field(default_factory=list)
-    allergens: List[str] = Field(default_factory=list)
-    confidence: float = 0.0
-    # When True the confirmed product is also added to inventory
-    location: str = "pantry"
-    quantity: float = 1.0
-    auto_add: bool = True
-
-
-class LabelConfirmResponse(BaseModel):
-    """Result of confirming a captured product."""
-    ok: bool
-    barcode: str
-    product_id: Optional[int] = None
-    inventory_item_id: Optional[int] = None
-    message: str

app/models/schemas/meal_plan.py

@@ -22,10 +22,6 @@ class CreatePlanRequest(BaseModel):
         return v
 
 
-class UpdatePlanRequest(BaseModel):
-    meal_types: list[str]
-
-
 class UpsertSlotRequest(BaseModel):
     recipe_id: int | None = None
     servings: float = Field(2.0, gt=0)

app/models/schemas/recipe.py

@@ -4,35 +4,6 @@ from __future__ import annotations
 from pydantic import BaseModel, Field
 
 
-class LeftoversResponse(BaseModel):
-    """Cooked-leftover shelf-life estimate returned by POST /recipes/{id}/leftovers."""
-    fridge_days: int
-    freeze_days: int | None = None   # None = not recommended
-    freeze_by_day: int | None = None  # day number from cook date to freeze by
-    storage_advice: str
-
-
-class StepAnalysis(BaseModel):
-    """Active/passive classification for one direction step."""
-    is_passive: bool
-    detected_minutes: int | None = None
-
-
-class TimeEffortProfile(BaseModel):
-    """Parsed time and effort profile for a recipe.
-
-    Mirrors app.services.recipe.time_effort.TimeEffortProfile (dataclass).
-    Serialised into RecipeSuggestion so the frontend can render the effort
-    summary without a second round-trip.
-    """
-    active_min: int = 0
-    passive_min: int = 0
-    total_min: int = 0
-    effort_label: str = "moderate"   # "quick" | "moderate" | "involved"
-    equipment: list[str] = Field(default_factory=list)
-    step_analyses: list[StepAnalysis] = Field(default_factory=list)
-
-
 class SwapCandidate(BaseModel):
     original_name: str
     substitute_name: str
@@ -70,10 +41,6 @@ class RecipeSuggestion(BaseModel):
     is_wildcard: bool = False
     nutrition: NutritionPanel | None = None
     source_url: str | None = None
-    complexity: str | None = None  # 'easy' | 'moderate' | 'involved'
-    estimated_time_min: int | None = None  # derived from step count + method signals
-    time_effort: TimeEffortProfile | None = None  # full time/effort profile from parse_time_effort
-    rerank_score: float | None = None  # cross-encoder relevance score (paid+ only, None for free tier)
 
 
 class GroceryLink(BaseModel):
@@ -92,18 +59,6 @@ class RecipeResult(BaseModel):
     orch_fallback: bool = False  # True when orch budget exhausted; fell back to local LLM
 
 
-class RecipeJobQueued(BaseModel):
-    job_id: str
-    status: str = "queued"
-
-
-class RecipeJobStatus(BaseModel):
-    job_id: str
-    status: str
-    result: RecipeResult | None = None
-    error: str | None = None
-
-
 class NutritionFilters(BaseModel):
     """Optional per-serving upper bounds for macro filtering. None = no filter."""
     max_calories: float | None = None
@@ -114,10 +69,6 @@ class NutritionFilters(BaseModel):
 
 class RecipeRequest(BaseModel):
     pantry_items: list[str]
-    # Maps product name → secondary state label for items past nominal expiry
-    # but still within their secondary use window (e.g. {"Bread": "stale"}).
-    # Used by the recipe engine to boost recipes suited to those specific states.
-    secondary_pantry_items: dict[str, str] = Field(default_factory=dict)
     level: int = Field(default=1, ge=1, le=4)
     constraints: list[str] = Field(default_factory=list)
     expiry_first: bool = False
@@ -131,13 +82,7 @@ class RecipeRequest(BaseModel):
     allergies: list[str] = Field(default_factory=list)
     nutrition_filters: NutritionFilters = Field(default_factory=NutritionFilters)
     excluded_ids: list[int] = Field(default_factory=list)
-    exclude_ingredients: list[str] = Field(default_factory=list)
     shopping_mode: bool = False
-    pantry_match_only: bool = False  # when True, only return recipes with zero missing ingredients
-    complexity_filter: str | None = None  # 'easy' | 'moderate' | 'involved' — None = any
-    max_time_min: int | None = None  # filter by estimated cooking time ceiling
-    max_total_min: int | None = None  # filter by parsed total time from recipe directions
-    unit_system: str = "metric"  # "metric" | "imperial"
 
 
 # ── Build Your Own schemas ──────────────────────────────────────────────────
@@ -183,24 +128,3 @@ class BuildRequest(BaseModel):
 
     template_id: str
     role_overrides: dict[str, str] = Field(default_factory=dict)
-
-
-class StreamTokenRequest(BaseModel):
-    """Request body for POST /recipes/stream-token.
-
-    Pantry items and dietary constraints are fetched from the DB at request
-    time — the client does not supply them here.
-    """
-    level: int = Field(4, ge=3, le=4, description="Recipe level: 3=styled, 4=wildcard")
-    wildcard_confirmed: bool = Field(False, description="Required true for level 4")
-
-
-class StreamTokenResponse(BaseModel):
-    """Response from POST /recipes/stream-token.
-
-    The frontend opens EventSource at stream_url?token=<token> to receive
-    SSE chunks directly from the coordinator.
-    """
-    stream_url: str
-    token: str
-    expires_in_s: int

app/models/schemas/shopping.py

@@ -1,60 +0,0 @@
-"""Pydantic schemas for the shopping list endpoints."""
-from __future__ import annotations
-
-from typing import Optional
-from pydantic import BaseModel, Field
-
-
-class ShoppingItemCreate(BaseModel):
-    name: str = Field(..., min_length=1, max_length=200)
-    quantity: Optional[float] = None
-    unit: Optional[str] = None
-    category: Optional[str] = None
-    notes: Optional[str] = None
-    source: str = "manual"
-    recipe_id: Optional[int] = None
-    sort_order: int = 0
-
-
-class ShoppingItemUpdate(BaseModel):
-    name: Optional[str] = Field(None, min_length=1, max_length=200)
-    quantity: Optional[float] = None
-    unit: Optional[str] = None
-    category: Optional[str] = None
-    checked: Optional[bool] = None
-    notes: Optional[str] = None
-    sort_order: Optional[int] = None
-
-
-class GroceryLinkOut(BaseModel):
-    ingredient: str
-    retailer: str
-    url: str
-
-
-class ShoppingItemResponse(BaseModel):
-    id: int
-    name: str
-    quantity: Optional[float]
-    unit: Optional[str]
-    category: Optional[str]
-    checked: bool
-    notes: Optional[str]
-    source: str
-    recipe_id: Optional[int]
-    sort_order: int
-    created_at: str
-    updated_at: str
-    grocery_links: list[GroceryLinkOut] = []
-
-
-class BulkAddFromRecipeRequest(BaseModel):
-    recipe_id: int
-    include_covered: bool = False  # if True, add pantry-covered items too
-
-
-class ConfirmPurchaseRequest(BaseModel):
-    """Move a checked item into pantry inventory."""
-    location: str = "pantry"
-    quantity: Optional[float] = None   # override the list quantity
-    unit: Optional[str] = None

app/services/__init__.py

@@ -3,11 +3,6 @@
 Business logic services for Kiwi.
 """
 
+from app.services.receipt_service import ReceiptService
+
 __all__ = ["ReceiptService"]
-
-
-def __getattr__(name: str):
-    if name == "ReceiptService":
-        from app.services.receipt_service import ReceiptService
-        return ReceiptService
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

app/services/coordinator_proxy.py

@@ -1,94 +0,0 @@
-"""cf-orch coordinator proxy client.
-
-Calls the coordinator's /proxy/authorize endpoint to obtain a one-time
-stream URL + token for LLM streaming. Always raises CoordinatorError on
-failure — callers decide how to handle it (stream-token endpoint returns
-503 or 403 as appropriate).
-"""
-from __future__ import annotations
-
-import logging
-import os
-from dataclasses import dataclass
-
-import httpx
-
-log = logging.getLogger(__name__)
-
-
-class CoordinatorError(Exception):
-    """Raised when the coordinator returns an error or is unreachable."""
-    def __init__(self, message: str, status_code: int = 503):
-        super().__init__(message)
-        self.status_code = status_code
-
-
-@dataclass(frozen=True)
-class StreamTokenResult:
-    stream_url: str
-    token: str
-    expires_in_s: int
-
-
-def _coordinator_url() -> str:
-    return os.environ.get("COORDINATOR_URL", "http://10.1.10.71:7700")
-
-
-def _product_key() -> str:
-    return os.environ.get("COORDINATOR_KIWI_KEY", "")
-
-
-async def coordinator_authorize(
-    prompt: str,
-    caller: str = "kiwi-recipe",
-    ttl_s: int = 300,
-) -> StreamTokenResult:
-    """Call POST /proxy/authorize on the coordinator.
-
-    Returns a StreamTokenResult with the stream URL and one-time token.
-    Raises CoordinatorError on any failure (network, auth, capacity).
-    """
-    url = f"{_coordinator_url()}/proxy/authorize"
-    key = _product_key()
-    if not key:
-        raise CoordinatorError(
-            "COORDINATOR_KIWI_KEY env var is not set — streaming unavailable",
-            status_code=503,
-        )
-
-    payload = {
-        "product": "kiwi",
-        "product_key": key,
-        "caller": caller,
-        "prompt": prompt,
-        "params": {},
-        "ttl_s": ttl_s,
-    }
-
-    try:
-        async with httpx.AsyncClient(timeout=10.0) as client:
-            resp = await client.post(url, json=payload)
-    except httpx.RequestError as exc:
-        log.warning("coordinator_authorize network error: %s", exc)
-        raise CoordinatorError(f"Coordinator unreachable: {exc}", status_code=503)
-
-    if resp.status_code == 401:
-        raise CoordinatorError("Invalid product key", status_code=401)
-    if resp.status_code == 429:
-        raise CoordinatorError("Too many concurrent streams", status_code=429)
-    if resp.status_code == 503:
-        raise CoordinatorError("No GPU available for streaming", status_code=503)
-    if not resp.is_success:
-        raise CoordinatorError(
-            f"Coordinator error {resp.status_code}: {resp.text[:200]}",
-            status_code=503,
-        )
-
-    data = resp.json()
-    # Use public_stream_url if coordinator provides it (cloud mode), else stream_url
-    stream_url = data.get("public_stream_url") or data["stream_url"]
-    return StreamTokenResult(
-        stream_url=stream_url,
-        token=data["token"],
-        expires_in_s=data["expires_in_s"],
-    )

app/services/expiration_predictor.py

@@ -116,270 +116,6 @@ class ExpirationPredictor:
         'prepared_foods': {'fridge': 4, 'freezer': 90},
     }
 
-    # Secondary shelf life in days after a package is opened.
-    # Sources: USDA FoodKeeper app, FDA consumer guides.
-    # Only categories where opening significantly shortens shelf life are listed.
-    # Items not listed default to None (no secondary window tracked).
-    SHELF_LIFE_AFTER_OPENING: dict[str, int] = {
-        # Dairy — once opened, clock ticks fast
-        'dairy': 5,
-        'milk': 5,
-        'cream': 3,
-        'yogurt': 7,
-        'cheese': 14,
-        'butter': 30,
-        # Condiments — refrigerated after opening
-        'condiments': 30,
-        'ketchup': 30,
-        'mustard': 30,
-        'mayo': 14,
-        'salad_dressing': 30,
-        'soy_sauce': 90,
-        # Canned goods — once opened, very short
-        'canned_goods': 4,
-        # Beverages
-        'juice': 7,
-        'soda': 4,
-        # Bread / Bakery
-        'bread': 5,
-        'bakery': 3,
-        # Produce
-        'leafy_greens': 3,
-        'berries': 3,
-        # Pantry staples (open bag)
-        'chips': 14,
-        'cookies': 14,
-        'cereal': 30,
-        'flour': 90,
-    }
-
-    # Post-expiry secondary use window.
-    # These are NOT spoilage extensions — they describe a qualitative state
-    # change where the ingredient is specifically suited for certain preparations.
-    # Sources: USDA FoodKeeper, food science, culinary tradition.
-    #
-    # Fields:
-    #   window_days        — days past nominal expiry still usable in secondary state
-    #   label              — short UI label for the state
-    #   uses               — recipe contexts suited to this state (shown in UI)
-    #   warning            — safety note, calm tone, None if none needed
-    #   discard_signs      — qualitative signs the item has gone past the secondary window
-    #   constraints_exclude — dietary constraint labels that suppress this entry entirely
-    #                         (e.g. alcohol-containing items suppressed for halal/alcohol-free)
-    SECONDARY_WINDOW: dict[str, dict] = {
-        'bread': {
-            'window_days': 5,
-            'label': 'stale',
-            'uses': ['croutons', 'stuffing', 'bread pudding', 'French toast', 'panzanella'],
-            'warning': 'Check for mold before use — discard if any is visible.',
-            'discard_signs': 'Visible mold (any colour), or unpleasant smell beyond dry/yeasty.',
-            'constraints_exclude': [],
-        },
-        'bakery': {
-            'window_days': 3,
-            'label': 'day-old',
-            'uses': ['French toast', 'bread pudding', 'crumbles', 'trifle base', 'cake pops', 'streusel topping', 'bread crumbs'],
-            'warning': 'Check for mold before use — discard if any is visible.',
-            'discard_signs': 'Visible mold, sliminess, or strong sour smell.',
-            'constraints_exclude': [],
-        },
-        'bananas': {
-            'window_days': 5,
-            'label': 'overripe',
-            'uses': ['banana bread', 'smoothies', 'pancakes', 'muffins'],
-            'warning': None,
-            'discard_signs': 'Leaking liquid, fermented smell, or mold on skin.',
-            'constraints_exclude': [],
-        },
-        'milk': {
-            'window_days': 3,
-            'label': 'sour',
-            'uses': ['pancakes', 'scones', 'waffles', 'muffins', 'quick breads', 'béchamel', 'baked mac and cheese'],
-            'warning': 'Use only in cooked recipes — do not drink.',
-            'discard_signs': 'Chunky texture, strong unpleasant smell beyond tangy, or visible separation with grey colour.',
-            'constraints_exclude': [],
-        },
-        'dairy': {
-            'window_days': 2,
-            'label': 'sour',
-            'uses': ['pancakes', 'scones', 'quick breads', 'muffins', 'waffles'],
-            'warning': 'Use only in cooked recipes — do not drink.',
-            'discard_signs': 'Strong unpleasant smell, unusual colour, or chunky texture.',
-            'constraints_exclude': [],
-        },
-        'cheese': {
-            'window_days': 14,
-            'label': 'rind-ready',
-            'uses': ['parmesan broth', 'minestrone', 'ribollita', 'risotto', 'polenta', 'bean soups', 'gratins'],
-            'warning': None,
-            'discard_signs': 'Soft or wet texture on hard cheese, pink or black mold (white/green surface mold on hard cheese can be cut off with 1cm margin).',
-            'constraints_exclude': [],
-        },
-        'rice': {
-            'window_days': 2,
-            'label': 'day-old',
-            'uses': ['fried rice', 'onigiri', 'rice porridge', 'congee', 'arancini', 'stuffed peppers', 'rice fritters'],
-            'warning': 'Refrigerate immediately after cooking — do not leave at room temp.',
-            'discard_signs': 'Slimy texture, unusual smell, or more than 4 days since cooking.',
-            'constraints_exclude': [],
-        },
-        'tortillas': {
-            'window_days': 5,
-            'label': 'stale',
-            'uses': ['chilaquiles', 'migas', 'tortilla soup', 'casserole'],
-            'warning': 'Check for mold, especially if stored in a sealed bag — discard if any is visible.',
-            'discard_signs': 'Visible mold (check seams and edges), or strong sour smell.',
-            'constraints_exclude': [],
-        },
-        # ── New entries ──────────────────────────────────────────────────────
-        'apples': {
-            'window_days': 7,
-            'label': 'soft',
-            'uses': ['applesauce', 'apple butter', 'baked apples', 'apple crisp', 'smoothies', 'chutney'],
-            'warning': None,
-            'discard_signs': 'Large bruised areas with fermented smell, visible mold, or liquid leaking from skin.',
-            'constraints_exclude': [],
-        },
-        'leafy_greens': {
-            'window_days': 2,
-            'label': 'wilting',
-            'uses': ['sautéed greens', 'soups', 'smoothies', 'frittata', 'pasta add-in', 'stir fry'],
-            'warning': None,
-            'discard_signs': 'Slimy texture, strong unpleasant smell, or yellowed and mushy leaves.',
-            'constraints_exclude': [],
-        },
-        'tomatoes': {
-            'window_days': 4,
-            'label': 'soft',
-            'uses': ['roasted tomatoes', 'tomato sauce', 'shakshuka', 'bruschetta', 'soup', 'salsa'],
-            'warning': None,
-            'discard_signs': 'Broken skin with liquid pooling, mold, or fermented smell.',
-            'constraints_exclude': [],
-        },
-        'cooked_pasta': {
-            'window_days': 3,
-            'label': 'day-old',
-            'uses': ['pasta frittata', 'pasta salad', 'baked pasta', 'soup add-in', 'fried pasta cakes'],
-            'warning': 'Refrigerate within 2 hours of cooking.',
-            'discard_signs': 'Slimy texture, off smell, or more than 4 days since cooking.',
-            'constraints_exclude': [],
-        },
-        'cooked_potatoes': {
-            'window_days': 3,
-            'label': 'day-old',
-            'uses': ['potato pancakes', 'hash browns', 'potato soup', 'gnocchi', 'twice-baked potatoes', 'croquettes'],
-            'warning': 'Refrigerate within 2 hours of cooking.',
-            'discard_signs': 'Slimy texture, off smell, or more than 4 days since cooking.',
-            'constraints_exclude': [],
-        },
-        'yogurt': {
-            'window_days': 7,
-            'label': 'tangy',
-            'uses': ['marinades', 'flatbreads', 'smoothies', 'tzatziki', 'baked goods', 'salad dressings'],
-            'warning': None,
-            'discard_signs': 'Pink or orange discolouration, visible mold, or strongly unpleasant smell (not just tangy).',
-            'constraints_exclude': [],
-        },
-        'cream': {
-            'window_days': 2,
-            'label': 'sour',
-            'uses': ['soups', 'sauces', 'scones', 'quick breads', 'mashed potatoes'],
-            'warning': 'Use in cooked recipes only. Discard if the smell is strongly unpleasant rather than tangy.',
-            'discard_signs': 'Strong unpleasant smell beyond tangy, unusual colour, or chunky texture.',
-            'constraints_exclude': [],
-        },
-        'wine': {
-            'window_days': 4,
-            'label': 'open',
-            'uses': ['pan sauces', 'braises', 'risotto', 'marinades', 'poaching liquid', 'wine reduction'],
-            'warning': None,
-            'discard_signs': 'Strong vinegar smell (still usable in braises/marinades), or visible cloudiness with off-smell.',
-            'constraints_exclude': ['halal', 'alcohol-free'],
-        },
-        'cooked_beans': {
-            'window_days': 3,
-            'label': 'day-old',
-            'uses': ['refried beans', 'bean soup', 'bean fritters', 'hummus', 'bean dip', 'grain bowls'],
-            'warning': 'Refrigerate within 2 hours of cooking.',
-            'discard_signs': 'Slimy texture, off smell, or more than 4 days since cooking.',
-            'constraints_exclude': [],
-        },
-        'cooked_meat': {
-            'window_days': 2,
-            'label': 'leftover',
-            'uses': ['grain bowls', 'tacos', 'soups', 'fried rice', 'sandwiches', 'hash', 'pasta add-in'],
-            'warning': 'Refrigerate within 2 hours of cooking.',
-            'discard_signs': 'Off smell, slimy texture, or more than 3–4 days since cooking.',
-            'constraints_exclude': [],
-        },
-    }
-
-    def days_after_opening(self, category: str | None) -> int | None:
-        """Return days of shelf life remaining once a package is opened.
-
-        Returns None if the category is unknown or not tracked after opening
-        (e.g. frozen items, raw meat — category check irrelevant once opened).
-        """
-        if not category:
-            return None
-        return self.SHELF_LIFE_AFTER_OPENING.get(category.lower())
-
-    def secondary_state(
-        self, category: str | None, expiry_date: str | None
-    ) -> dict | None:
-        """Return secondary use info if the item is in its post-expiry secondary window.
-
-        Returns a dict with label, uses, warning, discard_signs, constraints_exclude,
-        days_past, and window_days when the item is past its nominal expiry date but
-        still within the secondary use window.
-        Returns None in all other cases (unknown category, no window defined, not yet
-        expired, or past the secondary window).
-
-        Callers should apply constraints_exclude against user dietary constraints
-        and suppress the result entirely if any excluded constraint is active.
-        See filter_secondary_by_constraints().
-        """
-        if not category or not expiry_date:
-            return None
-        entry = self.SECONDARY_WINDOW.get(category.lower())
-        if not entry:
-            return None
-        try:
-            from datetime import date
-            today = date.today()
-            exp = date.fromisoformat(expiry_date)
-            days_past = (today - exp).days
-            if 0 <= days_past <= entry['window_days']:
-                return {
-                    'label': entry['label'],
-                    'uses': list(entry['uses']),
-                    'warning': entry['warning'],
-                    'discard_signs': entry.get('discard_signs'),
-                    'constraints_exclude': list(entry.get('constraints_exclude') or []),
-                    'days_past': days_past,
-                    'window_days': entry['window_days'],
-                }
-        except ValueError:
-            pass
-        return None
-
-    @staticmethod
-    def filter_secondary_by_constraints(
-        sec: dict | None,
-        user_constraints: list[str],
-    ) -> dict | None:
-        """Suppress secondary state entirely if any excluded constraint is active.
-
-        Call after secondary_state() when user dietary constraints are available.
-        Returns sec unchanged when no constraints match, or None when suppressed.
-        """
-        if sec is None:
-            return None
-        excluded = sec.get('constraints_exclude') or []
-        if any(c.lower() in [e.lower() for e in excluded] for c in user_constraints):
-            return None
-        return sec
-
     # Keyword lists are checked in declaration order — most specific first.
     # Rules:
     #  - canned/processed goods BEFORE raw-meat terms (canned chicken != raw chicken)

app/services/label_capture.py

@@ -1,140 +0,0 @@
-"""Visual label capture service for unenriched products (kiwi#79).
-
-Wraps the cf-core VisionRouter to extract structured nutrition data from a
-photographed nutrition facts panel.  When the VisionRouter is not yet wired
-(NotImplementedError) the service falls back to a mock extraction so the
-barcode scan flow can be exercised end-to-end in development.
-
-JSON contract returned by the vision model (and mock):
-  {
-    "product_name": str | null,
-    "brand":        str | null,
-    "serving_size_g": number | null,
-    "calories":       number | null,
-    "fat_g":          number | null,
-    "saturated_fat_g": number | null,
-    "carbs_g":        number | null,
-    "sugar_g":        number | null,
-    "fiber_g":        number | null,
-    "protein_g":      number | null,
-    "sodium_mg":      number | null,
-    "ingredient_names": [str],
-    "allergens":        [str],
-    "confidence":       number (0.0–1.0)
-  }
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-from typing import Any
-
-log = logging.getLogger(__name__)
-
-# Confidence below this threshold surfaces amber highlights in the UI.
-REVIEW_THRESHOLD = 0.7
-
-_MOCK_EXTRACTION: dict[str, Any] = {
-    "product_name": "Unknown Product",
-    "brand": None,
-    "serving_size_g": None,
-    "calories": None,
-    "fat_g": None,
-    "saturated_fat_g": None,
-    "carbs_g": None,
-    "sugar_g": None,
-    "fiber_g": None,
-    "protein_g": None,
-    "sodium_mg": None,
-    "ingredient_names": [],
-    "allergens": [],
-    "confidence": 0.0,
-}
-
-_EXTRACTION_PROMPT = """You are reading a nutrition facts label photograph.
-Extract the following fields as a JSON object with no extra text:
-
-{
-  "product_name": <product name or null>,
-  "brand": <brand name or null>,
-  "serving_size_g": <serving size in grams as a number or null>,
-  "calories": <calories per serving as a number or null>,
-  "fat_g": <total fat grams or null>,
-  "saturated_fat_g": <saturated fat grams or null>,
-  "carbs_g": <total carbohydrates grams or null>,
-  "sugar_g": <sugars grams or null>,
-  "fiber_g": <dietary fiber grams or null>,
-  "protein_g": <protein grams or null>,
-  "sodium_mg": <sodium milligrams or null>,
-  "ingredient_names": [list of individual ingredients as strings],
-  "allergens": [list of allergens explicitly stated on label],
-  "confidence": <your confidence this extraction is correct, 0.0 to 1.0>
-}
-
-Use null for any field you cannot read clearly. Do not guess values.
-Respond with JSON only."""
-
-
-def extract_label(image_bytes: bytes) -> dict[str, Any]:
-    """Run vision model extraction on raw label image bytes.
-
-    Returns a dict matching the nutrition JSON contract above.
-    Falls back to a zero-confidence mock if the VisionRouter is not yet
-    implemented (stub) or if the model returns unparseable output.
-    """
-    # Allow unit tests to bypass the vision model entirely.
-    if os.environ.get("KIWI_LABEL_CAPTURE_MOCK") == "1":
-        log.debug("label_capture: mock mode active")
-        return dict(_MOCK_EXTRACTION)
-
-    try:
-        from circuitforge_core.vision import caption as vision_caption
-        result = vision_caption(image_bytes, prompt=_EXTRACTION_PROMPT)
-        raw = result.caption or ""
-        return _parse_extraction(raw)
-    except Exception as exc:
-        log.warning("label_capture: extraction failed (%s) — returning mock extraction", exc)
-        return dict(_MOCK_EXTRACTION)
-
-
-def _parse_extraction(raw: str) -> dict[str, Any]:
-    """Parse the JSON string returned by the vision model.
-
-    Strips markdown code fences if present.  Validates required shape.
-    Returns the mock on any parse error.
-    """
-    text = raw.strip()
-    if text.startswith("```"):
-        # Strip ```json ... ``` fences
-        lines = text.splitlines()
-        text = "\n".join(lines[1:-1] if lines[-1].strip() == "```" else lines[1:])
-
-    try:
-        data = json.loads(text)
-    except json.JSONDecodeError as exc:
-        log.warning("label_capture: could not parse vision response: %s", exc)
-        return dict(_MOCK_EXTRACTION)
-
-    if not isinstance(data, dict):
-        log.warning("label_capture: vision response is not a dict")
-        return dict(_MOCK_EXTRACTION)
-
-    # Normalise list fields — model may return None instead of []
-    for list_key in ("ingredient_names", "allergens"):
-        if not isinstance(data.get(list_key), list):
-            data[list_key] = []
-
-    # Clamp confidence to [0, 1]
-    confidence = data.get("confidence")
-    if not isinstance(confidence, (int, float)):
-        confidence = 0.0
-    data["confidence"] = max(0.0, min(1.0, float(confidence)))
-
-    return data
-
-
-def needs_review(extraction: dict[str, Any]) -> bool:
-    """Return True when the extraction confidence is below REVIEW_THRESHOLD."""
-    return float(extraction.get("confidence", 0.0)) < REVIEW_THRESHOLD

app/services/leftovers_predictor.py

@@ -1,233 +0,0 @@
-# app/services/leftovers_predictor.py
-"""Cooked-leftovers shelf-life predictor.
-
-Fast path: deterministic lookup anchored to FDA/USDA safe food handling.
-Fallback: LLM for unclassifiable edge cases (same gate as expiry_llm_matching).
-
-Design notes:
-  - shortest-component-wins for proteins: a fish taco is bounded by the fish.
-  - category/keyword signals override ingredient signals for assembled dishes
-    (soup, stew, casserole) where the cooking method matters more than the
-    dominant protein.
-  - no urgency/panic framing — see feedback_kiwi_no_panic.md.
-"""
-from __future__ import annotations
-
-import logging
-import re
-from dataclasses import dataclass, field
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class LeftoversResult:
-    fridge_days: int
-    freeze_days: int | None        # None = "not recommended"
-    freeze_by_day: int | None      # day number from cook date to freeze by; None = no need
-    storage_advice: str
-
-
-# ---------------------------------------------------------------------------
-# Protein priority table — shorter shelf life wins when multiple match.
-# Values: (fridge_days, freeze_days).  All fridge values are conservative.
-# Sources: USDA FoodKeeper, FDA Safe Food Handling.
-# ---------------------------------------------------------------------------
-_PROTEIN_SIGNALS: list[tuple[list[str], int, int | None]] = [
-    # (keyword_list, fridge_days, freeze_days)
-    (["fish", "salmon", "tuna", "cod", "tilapia", "halibut", "trout", "bass",
-      "mahi", "snapper", "flounder", "catfish", "swordfish", "sardine", "anchovy"],
-     2, 90),
-    (["shrimp", "prawn", "scallop", "crab", "lobster", "clam", "mussel",
-      "oyster", "squid", "octopus", "seafood"],
-     2, 90),
-    (["ground beef", "ground turkey", "ground pork", "ground chicken",
-      "ground meat", "hamburger", "mince"],
-     3, 90),
-    (["chicken", "turkey", "poultry", "duck", "hen"],
-     3, 90),
-    (["pork", "ham", "bacon", "sausage", "chorizo", "bratwurst", "kielbasa",
-      "salami", "pepperoni"],
-     4, 120),
-    (["beef", "steak", "brisket", "roast", "lamb", "veal", "venison"],
-     4, 180),
-    (["egg", "eggs", "frittata", "quiche", "omelette"],
-     3, None),
-    (["tofu", "tempeh", "seitan"],
-     4, 90),
-]
-
-# ---------------------------------------------------------------------------
-# Dish-type signals — override protein signal when a structural match fires.
-# Ordered from most-perishable to least.
-# ---------------------------------------------------------------------------
-_DISH_SIGNALS: list[tuple[list[str], int, int | None, str]] = [
-    # (keywords, fridge_days, freeze_days, storage_advice_fragment)
-
-    # Ceviche: acid denatures proteins but does not kill pathogens.
-    # FDA/USDA classify it as raw seafood — 2-day fridge max, do not freeze.
-    (["ceviche", "tiradito", "leche de tigre"],
-     2, None,
-     "Acid marination is not the same as heat cooking — treat as raw seafood. "
-     "Best eaten the day it's made; 2 days maximum in the fridge."),
-
-    # Fermented / salt-cured dishes — preservation extends shelf life significantly.
-    # This matches dish names, not just presence of the ingredient (lardo in a pasta
-    # follows normal pasta rules, not this entry).
-    (["kimchi", "sauerkraut", "preserved lemon"],
-     14, None,
-     "Fermented and salt-preserved dishes keep well. Store submerged in their brine."),
-
-    (["confit", "gravlax", "gravad lax", "lardo"],
-     7, 60,
-     "Store covered in its fat or cure. Keep cold and away from strong-smelling foods."),
-
-    (["soup", "stew", "broth", "chowder", "bisque", "gumbo", "chili"],
-     4, 120,
-     "Soups and stews keep well in the fridge. Cool to room temperature before covering."),
-    (["curry"],
-     4, 90,
-     "Store curry in an airtight container. The flavours deepen overnight."),
-    (["casserole", "bake", "gratin", "lasagna", "lasagne", "moussaka",
-      "shepherd's pie", "pot pie"],
-     5, 90,
-     "Cover tightly. Reheat individual portions rather than the whole dish."),
-    (["pasta", "noodle", "spaghetti", "penne", "linguine", "fettuccine",
-      "macaroni", "risotto"],
-     4, 60,
-     "Store pasta and sauce separately if possible to prevent sogginess."),
-    (["rice", "fried rice", "pilaf", "biryani"],
-     3, 90,
-     "Cool rice quickly — spread on a tray if needed. Don't leave at room temperature for more than 1 hour."),
-    (["salad"],
-     2, None,
-     "Keep dressing separate. Once dressed, best eaten the same day."),
-    (["stir fry", "stir-fry"],
-     3, 60,
-     "Reheat in a hot pan or wok rather than a microwave to keep texture."),
-    (["sandwich", "wrap", "taco", "burrito"],
-     2, None,
-     "Assemble fresh when possible. Fillings keep better stored separately."),
-    (["pizza"],
-     4, 60,
-     "Reheat in a dry skillet for a crisp base rather than a microwave."),
-    (["muffin", "bread", "biscuit", "scone", "roll"],
-     3, 90,
-     "Wrap tightly or seal in a bag to prevent drying out."),
-    (["cake", "pie", "cookie", "brownie", "dessert", "pudding"],
-     5, 90,
-     "Store covered at room temperature or in the fridge depending on fillings."),
-    (["smoothie", "juice", "shake"],
-     1, 7,
-     "Best consumed fresh. Stir or shake well before drinking."),
-]
-
-# Default when no signals match.
-_DEFAULT_FRIDGE = 4
-_DEFAULT_FREEZE = 90
-_DEFAULT_ADVICE = "Store in an airtight container in the fridge. Reheat until piping hot before eating."
-
-
-def _contains_any(text: str, keywords: list[str]) -> bool:
-    for kw in keywords:
-        if re.search(rf"\b{re.escape(kw)}\b", text, re.IGNORECASE):
-            return True
-    return False
-
-
-def _scan_ingredients(ingredients: list[str]) -> tuple[int, int | None] | None:
-    """Return (fridge_days, freeze_days) for the most-perishable protein found."""
-    joined = " ".join(str(i) for i in ingredients).lower()
-    best: tuple[int, int | None] | None = None
-    for keywords, fridge, freeze in _PROTEIN_SIGNALS:
-        if _contains_any(joined, keywords):
-            if best is None or fridge < best[0]:
-                best = (fridge, freeze)
-    return best
-
-
-def _scan_dish_type(text: str) -> tuple[int, int | None, str] | None:
-    """Return (fridge_days, freeze_days, advice) for the first matching dish type."""
-    for keywords, fridge, freeze, advice in _DISH_SIGNALS:
-        if _contains_any(text, keywords):
-            return fridge, freeze, advice
-    return None
-
-
-def predict_leftovers(
-    title: str,
-    ingredients: list[str],
-    category: str | None = None,
-    keywords: list[str] | None = None,
-) -> LeftoversResult:
-    """Predict cooked-leftover shelf life deterministically.
-
-    Falls back gracefully — always returns a result even for unknown recipes.
-    """
-    # Build a combined text blob for dish-type scanning.
-    search_text = " ".join(filter(None, [
-        title,
-        category or "",
-        " ".join(keywords or []),
-    ]))
-
-    # Dish-type match takes structural priority over raw ingredient protein signal.
-    dish = _scan_dish_type(search_text)
-    protein = _scan_ingredients(ingredients)
-
-    if dish:
-        fridge_days, freeze_days, base_advice = dish
-        # Still apply shortest-protein-wins if protein is more perishable than dish default.
-        if protein and protein[0] < fridge_days:
-            fridge_days = protein[0]
-            if protein[1] is not None and (freeze_days is None or protein[1] < freeze_days):
-                freeze_days = protein[1]
-        advice = base_advice
-    elif protein:
-        fridge_days, freeze_days = protein
-        advice = _DEFAULT_ADVICE
-    else:
-        fridge_days = _DEFAULT_FRIDGE
-        freeze_days = _DEFAULT_FREEZE
-        advice = _DEFAULT_ADVICE
-
-    # freeze_by_day: recommend freezing on day 2 if fridge window is tight (≤3 days).
-    freeze_by_day: int | None = None
-    if freeze_days is not None and fridge_days <= 3:
-        freeze_by_day = 2
-
-    return LeftoversResult(
-        fridge_days=fridge_days,
-        freeze_days=freeze_days,
-        freeze_by_day=freeze_by_day,
-        storage_advice=advice,
-    )
-
-
-def predict_leftovers_from_row(recipe: dict[str, Any]) -> LeftoversResult:
-    """Convenience wrapper that accepts a Store row dict directly."""
-    import json as _json
-
-    title = recipe.get("title") or ""
-
-    raw_ingredients = recipe.get("ingredient_names") or []
-    if isinstance(raw_ingredients, str):
-        try:
-            raw_ingredients = _json.loads(raw_ingredients)
-        except Exception:
-            raw_ingredients = [raw_ingredients]
-
-    raw_keywords = recipe.get("keywords") or []
-    if isinstance(raw_keywords, str):
-        try:
-            raw_keywords = _json.loads(raw_keywords)
-        except Exception:
-            raw_keywords = [raw_keywords]
-
-    return predict_leftovers(
-        title=title,
-        ingredients=[str(i) for i in raw_ingredients],
-        category=recipe.get("category"),
-        keywords=[str(k) for k in raw_keywords],
-    )

app/services/magpie_hook.py

@@ -1,97 +0,0 @@
-"""Magpie data-flywheel hook.
-
-Fires anonymized recipe-signal events to the Magpie ingest endpoint when a
-user saves or rates a recipe.  This is the Kiwi side of the flywheel — Magpie
-does not have a receiver endpoint yet, so the hook stubs out gracefully: if
-``MAGPIE_INGEST_URL`` is unset, or the request fails for any reason, it logs
-at DEBUG level and returns without raising.
-"""
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-_INGEST_PATH = "/api/v1/ingest/recipe-signal"
-
-
-async def fire_recipe_signal(
-    db_path: Path,
-    recipe_id: int,
-    rating: int | None,
-    style_tags: list[str],
-) -> None:
-    """Post an anonymized recipe signal to Magpie if the user has opted in.
-
-    Args:
-        db_path:    Path to the user's SQLite database.
-        recipe_id:  Internal Kiwi recipe ID being rated/saved.
-        rating:     Star rating (0–5) or None if not yet rated.
-        style_tags: Style tags applied to the saved recipe.
-    """
-    from app.core.config import settings
-
-    if not settings.MAGPIE_INGEST_URL:
-        return
-
-    # Check per-user opt-in via a short-lived Store (own connection, own thread
-    # context is fine — this runs in the async event loop as a background task
-    # so we open and close the connection immediately).
-    from app.db.store import Store
-
-    try:
-        store = Store(db_path)
-        try:
-            opt_in = store.get_setting("magpie_opt_in")
-        finally:
-            store.close()
-    except Exception as exc:  # noqa: BLE001
-        logger.debug("magpie_hook: could not read magpie_opt_in setting: %s", exc)
-        return
-
-    if opt_in != "true":
-        return
-
-    # Fetch the recipe to get its external_id (source URL slug / corpus key).
-    try:
-        store = Store(db_path)
-        try:
-            recipe = store.get_recipe(recipe_id)
-        finally:
-            store.close()
-    except Exception as exc:  # noqa: BLE001
-        logger.debug("magpie_hook: could not fetch recipe %d: %s", recipe_id, exc)
-        return
-
-    if recipe is None:
-        logger.debug("magpie_hook: recipe %d not found, skipping", recipe_id)
-        return
-
-    external_id: str | None = recipe.get("external_id") if isinstance(recipe, dict) else getattr(recipe, "external_id", None)
-    if not external_id:
-        # Corpus recipe not yet enriched with a source identifier — skip quietly.
-        logger.debug("magpie_hook: recipe %d has no external_id, skipping", recipe_id)
-        return
-
-    payload = {
-        "product": "kiwi",
-        "signal": "recipe_rating",
-        "external_id": external_id,
-        "rating": rating,
-        "style_tags": style_tags,
-    }
-
-    url = settings.MAGPIE_INGEST_URL.rstrip("/") + _INGEST_PATH
-
-    try:
-        import httpx
-
-        async with httpx.AsyncClient(timeout=3.0) as client:
-            response = await client.post(url, json=payload)
-            logger.debug(
-                "magpie_hook: POST %s → %d", url, response.status_code
-            )
-    except Exception as exc:  # noqa: BLE001
-        # Magpie may not have a receiver yet — log and swallow.
-        logger.debug("magpie_hook: ingest request failed (stub): %s", exc)

app/services/openfoodfacts.py

@@ -15,72 +15,63 @@ logger = logging.getLogger(__name__)
 
 class OpenFoodFactsService:
     """
-    Service for interacting with the Open*Facts family of databases.
+    Service for interacting with the OpenFoodFacts API.
 
-    Primary: OpenFoodFacts (food products).
+    OpenFoodFacts is a free, open database of food products with
-    Fallback chain: Open Beauty Facts (personal care) → Open Products Facts (household).
+    ingredients, allergens, and nutrition facts.
-    All three databases share the same API path and JSON format.
     """
 
     BASE_URL = "https://world.openfoodfacts.org/api/v2"
     USER_AGENT = "Kiwi/0.1.0 (https://circuitforge.tech)"
 
-    # Fallback databases tried in order when OFFs returns no match.
-    # Same API format as OFFs — only the host differs.
-    _FALLBACK_DATABASES = [
-        "https://world.openbeautyfacts.org/api/v2",
-        "https://world.openproductsfacts.org/api/v2",
-    ]
-
-    async def _lookup_in_database(
-        self, barcode: str, base_url: str, client: httpx.AsyncClient
-    ) -> Optional[Dict[str, Any]]:
-        """Try one Open*Facts database using an existing client. Returns parsed product dict or None."""
-        try:
-            response = await client.get(
-                f"{base_url}/product/{barcode}.json",
-                headers={"User-Agent": self.USER_AGENT},
-                timeout=10.0,
-            )
-            if response.status_code == 404:
-                return None
-            response.raise_for_status()
-            data = response.json()
-            if data.get("status") != 1:
-                return None
-            return self._parse_product_data(data, barcode)
-        except httpx.HTTPError as e:
-            logger.debug("HTTP error for %s at %s: %s", barcode, base_url, e)
-            return None
-        except Exception as e:
-            logger.debug("Lookup failed for %s at %s: %s", barcode, base_url, e)
-            return None
-
     async def lookup_product(self, barcode: str) -> Optional[Dict[str, Any]]:
         """
-        Look up a product by barcode, trying OFFs then fallback databases.
+        Look up a product by barcode in the OpenFoodFacts database.
-
-        A single httpx.AsyncClient is created for the whole lookup chain so that
-        connection pooling and TLS session reuse apply across all database attempts.
 
         Args:
             barcode: UPC/EAN barcode (8-13 digits)
 
         Returns:
-            Dictionary with product information, or None if not found in any database.
+            Dictionary with product information, or None if not found
+
+        Example response:
+        {
+            "name": "Organic Milk",
+            "brand": "Horizon",
+            "categories": ["Dairy", "Milk"],
+            "image_url": "https://...",
+            "nutrition_data": {...},
+            "raw_data": {...}  # Full API response
+        }
         """
+        try:
             async with httpx.AsyncClient() as client:
-            result = await self._lookup_in_database(barcode, self.BASE_URL, client)
+                url = f"{self.BASE_URL}/product/{barcode}.json"
-            if result:
-                return result
 
-            for db_url in self._FALLBACK_DATABASES:
+                response = await client.get(
-                result = await self._lookup_in_database(barcode, db_url, client)
+                    url,
-                if result:
+                    headers={"User-Agent": self.USER_AGENT},
-                    logger.info("Barcode %s found in fallback database: %s", barcode, db_url)
+                    timeout=10.0,
-                    return result
+                )
 
-        logger.info("Barcode %s not found in any Open*Facts database", barcode)
+                if response.status_code == 404:
+                    logger.info(f"Product not found in OpenFoodFacts: {barcode}")
+                    return None
+
+                response.raise_for_status()
+                data = response.json()
+
+                if data.get("status") != 1:
+                    logger.info(f"Product not found in OpenFoodFacts: {barcode}")
+                    return None
+
+                return self._parse_product_data(data, barcode)
+
+        except httpx.HTTPError as e:
+            logger.error(f"HTTP error looking up barcode {barcode}: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"Error looking up barcode {barcode}: {e}")
             return None
 
     def _parse_product_data(self, data: Dict[str, Any], barcode: str) -> Dict[str, Any]:
@@ -123,9 +114,6 @@ class OpenFoodFactsService:
         allergens = product.get("allergens_tags", [])
         labels = product.get("labels_tags", [])
 
-        # Pack size detection: prefer explicit unit_count, fall back to serving count
-        pack_quantity, pack_unit = self._extract_pack_size(product)
-
         return {
             "name": name,
             "brand": brand,
@@ -136,47 +124,9 @@ class OpenFoodFactsService:
             "nutrition_data": nutrition_data,
             "allergens": allergens,
             "labels": labels,
-            "pack_quantity": pack_quantity,
-            "pack_unit": pack_unit,
             "raw_data": product,  # Store full response for debugging
         }
 
-    def _extract_pack_size(self, product: Dict[str, Any]) -> tuple[float | None, str | None]:
-        """Return (quantity, unit) for multi-pack products, or (None, None).
-
-        OFFs fields tried in order:
-          1. `number_of_units` (explicit count, highest confidence)
-          2. `serving_quantity` + `product_quantity_unit` (e.g. 6 x 150g yoghurt)
-          3. Parse `quantity` string like "4 x 113 g" or "6 pack"
-
-        Returns None, None when data is absent, ambiguous, or single-unit.
-        """
-        import re
-
-        # Field 1: explicit unit count
-        unit_count = product.get("number_of_units")
-        if unit_count:
-            try:
-                n = float(unit_count)
-                if n > 1:
-                    return n, product.get("serving_size_unit") or "unit"
-            except (ValueError, TypeError):
-                pass
-
-        # Field 2: parse quantity string for "N x ..." pattern
-        qty_str = product.get("quantity", "")
-        if qty_str:
-            m = re.match(r"^(\d+(?:\.\d+)?)\s*[xX×]\s*", qty_str.strip())
-            if m:
-                n = float(m.group(1))
-                if n > 1:
-                    # Try to get a sensible sub-unit label from the rest
-                    rest = qty_str[m.end():].strip()
-                    unit_label = re.sub(r"[\d.,\s]+", "", rest).strip()[:20] or "unit"
-                    return n, unit_label
-
-        return None, None
-
     def _extract_nutrition_data(self, product: Dict[str, Any]) -> Dict[str, Any]:
         """
         Extract nutrition facts from product data.

app/services/recipe/browse_counts_cache.py

@@ -1,256 +0,0 @@
-"""
-Browse counts cache — pre-computes and persists recipe counts for all
-browse domain keyword sets so category/subcategory page loads never
-hit the 3.8 GB FTS index at request time.
-
-Counts change only when the corpus changes (after a pipeline run).
-The cache is a small SQLite file separate from both the read-only
-corpus DB and per-user kiwi.db files, so the container can write it.
-
-Refresh triggers:
-  1. Startup     — if cache is missing or older than STALE_DAYS
-  2. Nightly     — asyncio background task started in main.py lifespan
-  3. Pipeline    — infer_recipe_tags.py calls refresh() at end of run
-
-The in-memory _COUNT_CACHE in store.py is pre-warmed from this file
-on startup, so FTS queries are never needed for known keyword sets.
-"""
-from __future__ import annotations
-
-import logging
-import sqlite3
-from datetime import datetime, timezone
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-STALE_DAYS = 7
-
-
-# ---------------------------------------------------------------------------
-# Internal helpers
-# ---------------------------------------------------------------------------
-
-def _kw_key(keywords: list[str]) -> str:
-    """Stable string key for a keyword list — sorted and pipe-joined."""
-    return "|".join(sorted(keywords))
-
-
-def _fts_match_expr(keywords: list[str]) -> str:
-    phrases = ['"' + kw.replace('"', '""') + '"' for kw in keywords]
-    return " OR ".join(phrases)
-
-
-def _ensure_schema(conn: sqlite3.Connection) -> None:
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS browse_counts (
-            keywords_key  TEXT PRIMARY KEY,
-            count         INTEGER NOT NULL,
-            computed_at   TEXT NOT NULL
-        )
-    """)
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS browse_counts_meta (
-            key   TEXT PRIMARY KEY,
-            value TEXT NOT NULL
-        )
-    """)
-    conn.commit()
-
-
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
-
-def is_stale(cache_path: Path, max_age_days: int = STALE_DAYS) -> bool:
-    """Return True if the cache is missing, empty, or older than max_age_days."""
-    if not cache_path.exists():
-        return True
-    try:
-        conn = sqlite3.connect(cache_path)
-        row = conn.execute(
-            "SELECT value FROM browse_counts_meta WHERE key = 'refreshed_at'"
-        ).fetchone()
-        conn.close()
-        if row is None:
-            return True
-        age = (datetime.now(timezone.utc) - datetime.fromisoformat(row[0])).days
-        return age >= max_age_days
-    except Exception:
-        return True
-
-
-def load_into_memory(cache_path: Path, count_cache: dict, corpus_path: str) -> int:
-    """
-    Load all rows from the cache file into the in-memory count_cache dict.
-
-    Uses corpus_path (the current RECIPE_DB_PATH env value) as the cache key,
-    not what was stored in the file — the file may have been built against a
-    different mount path (e.g. pipeline ran on host, container sees a different
-    path). Counts are corpus-content-derived and path-independent.
-
-    Returns the number of entries loaded.
-    """
-    if not cache_path.exists():
-        return 0
-    try:
-        conn = sqlite3.connect(cache_path)
-        rows = conn.execute("SELECT keywords_key, count FROM browse_counts").fetchall()
-        conn.close()
-        loaded = 0
-        for kw_key, count in rows:
-            keywords = kw_key.split("|") if kw_key else []
-            cache_key = (corpus_path, *sorted(keywords))
-            count_cache[cache_key] = count
-            loaded += 1
-        logger.info("browse_counts: warmed %d entries from %s", loaded, cache_path)
-        return loaded
-    except Exception as exc:
-        logger.warning("browse_counts: load failed: %s", exc)
-        return 0
-
-
-def refresh(corpus_path: str, cache_path: Path) -> int:
-    """
-    Run FTS5 queries for every keyword set in browser_domains.DOMAINS
-    and write results to cache_path.
-
-    Safe to call from both the host pipeline script and the in-container
-    nightly task. The corpus_path must be reachable and readable from
-    the calling process.
-
-    Returns the number of keyword sets computed.
-    """
-    from app.services.recipe.browser_domains import DOMAINS  # local import — avoid circular
-
-    cache_path.parent.mkdir(parents=True, exist_ok=True)
-    cache_conn = sqlite3.connect(cache_path)
-    _ensure_schema(cache_conn)
-
-    # Collect every unique keyword list across all domains/categories/subcategories.
-    # DOMAINS structure: {domain: {label: str, categories: {cat_name: {keywords, subcategories}}}}
-    seen: dict[str, list[str]] = {}
-    for domain_data in DOMAINS.values():
-        for cat_data in domain_data.get("categories", {}).values():
-            if not isinstance(cat_data, dict):
-                continue
-            top_kws = cat_data.get("keywords", [])
-            if top_kws:
-                seen[_kw_key(top_kws)] = top_kws
-            for subcat_kws in cat_data.get("subcategories", {}).values():
-                if subcat_kws:
-                    seen[_kw_key(subcat_kws)] = subcat_kws
-
-    try:
-        corpus_conn = sqlite3.connect(f"file:{corpus_path}?mode=ro", uri=True)
-    except Exception as exc:
-        logger.error("browse_counts: cannot open corpus %s: %s", corpus_path, exc)
-        cache_conn.close()
-        return 0
-
-    now = datetime.now(timezone.utc).isoformat()
-    computed = 0
-
-    try:
-        for kw_key, kws in seen.items():
-            try:
-                row = corpus_conn.execute(
-                    "SELECT count(*) FROM recipe_browser_fts WHERE recipe_browser_fts MATCH ?",
-                    (_fts_match_expr(kws),),
-                ).fetchone()
-                count = row[0] if row else 0
-                cache_conn.execute(
-                    "INSERT OR REPLACE INTO browse_counts (keywords_key, count, computed_at)"
-                    " VALUES (?, ?, ?)",
-                    (kw_key, count, now),
-                )
-                computed += 1
-            except Exception as exc:
-                logger.warning("browse_counts: query failed key=%r: %s", kw_key[:60], exc)
-
-        # Merge accepted community tags into counts.
-        # For each (domain, category, subcategory) that has accepted community
-        # tags, add the count of distinct tagged recipe_ids to the FTS count.
-        # The two overlap rarely (community tags exist precisely because FTS
-        # missed those recipes), so simple addition is accurate enough.
-        try:
-            _merge_community_tag_counts(cache_conn, DOMAINS, now)
-        except Exception as exc:
-            logger.warning("browse_counts: community merge skipped: %s", exc)
-
-        cache_conn.execute(
-            "INSERT OR REPLACE INTO browse_counts_meta (key, value) VALUES ('refreshed_at', ?)",
-            (now,),
-        )
-        cache_conn.execute(
-            "INSERT OR REPLACE INTO browse_counts_meta (key, value) VALUES ('corpus_path', ?)",
-            (corpus_path,),
-        )
-        cache_conn.commit()
-        logger.info("browse_counts: wrote %d counts → %s", computed, cache_path)
-    finally:
-        corpus_conn.close()
-        cache_conn.close()
-
-    return computed
-
-
-def _merge_community_tag_counts(
-    cache_conn: sqlite3.Connection,
-    domains: dict,
-    now: str,
-    threshold: int = 2,
-) -> None:
-    """Add accepted community tag counts on top of FTS counts in the cache.
-
-    Queries the community PostgreSQL store (if available) for accepted tags
-    grouped by (domain, category, subcategory), maps each back to its keyword
-    set key, then increments the cached count.
-
-    Silently skips if community features are unavailable.
-    """
-    try:
-        from app.api.endpoints.community import _get_community_store
-        store = _get_community_store()
-        if store is None:
-            return
-    except Exception:
-        return
-
-    for domain_id, domain_data in domains.items():
-        for cat_name, cat_data in domain_data.get("categories", {}).items():
-            if not isinstance(cat_data, dict):
-                continue
-            # Check subcategories
-            for subcat_name, subcat_kws in cat_data.get("subcategories", {}).items():
-                if not subcat_kws:
-                    continue
-                ids = store.get_accepted_recipe_ids_for_subcategory(
-                    domain=domain_id,
-                    category=cat_name,
-                    subcategory=subcat_name,
-                    threshold=threshold,
-                )
-                if not ids:
-                    continue
-                kw_key = _kw_key(subcat_kws)
-                cache_conn.execute(
-                    "UPDATE browse_counts SET count = count + ? WHERE keywords_key = ?",
-                    (len(ids), kw_key),
-                )
-            # Check category-level tags (subcategory IS NULL)
-            top_kws = cat_data.get("keywords", [])
-            if top_kws:
-                ids = store.get_accepted_recipe_ids_for_subcategory(
-                    domain=domain_id,
-                    category=cat_name,
-                    subcategory=None,
-                    threshold=threshold,
-                )
-                if ids:
-                    kw_key = _kw_key(top_kws)
-                    cache_conn.execute(
-                        "UPDATE browse_counts SET count = count + ? WHERE keywords_key = ?",
-                        (len(ids), kw_key),
-                    )
-    logger.info("browse_counts: community tag counts merged")

app/services/recipe/browser_domains.py

@@ -5,12 +5,6 @@ Each domain provides a two-level category hierarchy for browsing the recipe corp
 Keyword matching is case-insensitive against the recipes.category column and the
 recipes.keywords JSON array. A recipe may appear in multiple categories (correct).
 
-Category values are either:
-  - list[str]  — flat keyword list (no subcategories)
-  - dict       — {"keywords": list[str], "subcategories": {name: list[str]}}
-                  keywords covers the whole category (used for "All X" browse);
-                  subcategories each have their own narrower keyword list.
-
 These are starter mappings based on the food.com dataset structure. Run:
 
     SELECT category, count(*) FROM recipes
@@ -25,477 +19,24 @@ DOMAINS: dict[str, dict] = {
     "cuisine": {
         "label": "Cuisine",
         "categories": {
-            "Italian": {
+            "Italian":        ["italian", "pasta", "pizza", "risotto", "lasagna", "carbonara"],
-                "keywords": ["italian", "pasta", "pizza", "risotto", "lasagna", "carbonara"],
+            "Mexican":        ["mexican", "tex-mex", "taco", "enchilada", "burrito", "salsa", "guacamole"],
-                "subcategories": {
+            "Asian":          ["asian", "chinese", "japanese", "thai", "korean", "vietnamese", "stir fry", "stir-fry", "ramen", "sushi"],
-                    "Sicilian":   ["sicilian", "sicily", "arancini", "caponata",
+            "American":       ["american", "southern", "bbq", "barbecue", "comfort food", "cajun", "creole"],
-                                   "involtini", "cannoli"],
+            "Mediterranean":  ["mediterranean", "greek", "middle eastern", "turkish", "moroccan", "lebanese"],
-                    "Neapolitan": ["neapolitan", "naples", "pizza napoletana",
+            "Indian":         ["indian", "curry", "lentil", "dal", "tikka", "masala", "biryani"],
-                                   "sfogliatelle", "ragù"],
+            "European":       ["french", "german", "spanish", "british", "irish", "scandinavian"],
-                    "Tuscan":     ["tuscan", "tuscany", "ribollita", "bistecca",
+            "Latin American": ["latin american", "peruvian", "argentinian", "colombian", "cuban", "caribbean"],
-                                   "pappardelle", "crostini"],
-                    "Roman":      ["roman", "rome", "cacio e pepe", "carbonara",
-                                   "amatriciana", "gricia", "supplì"],
-                    "Venetian":   ["venetian", "venice", "risotto", "bigoli",
-                                   "baccalà", "sarde in saor"],
-                    "Ligurian":   ["ligurian", "liguria", "pesto", "focaccia",
-                                   "trofie", "farinata"],
-                },
-            },
-            "Mexican": {
-                "keywords": ["mexican", "taco", "enchilada", "burrito", "salsa",
-                             "guacamole", "mole", "tamale"],
-                "subcategories": {
-                    "Oaxacan":      ["oaxacan", "oaxaca", "mole negro", "tlayuda",
-                                     "chapulines", "mezcal", "tasajo", "memelas"],
-                    "Yucatecan":    ["yucatecan", "yucatan", "cochinita pibil", "poc chuc",
-                                     "sopa de lima", "panuchos", "papadzules"],
-                    "Veracruz":     ["veracruz", "veracruzana", "huachinango",
-                                     "picadas", "enfrijoladas", "caldo de mariscos"],
-                    "Street Food":  ["taco", "elote", "tlacoyos", "torta", "tamale",
-                                     "quesadilla", "tostada", "sope", "gordita"],
-                    "Mole":         ["mole", "mole negro", "mole rojo", "mole verde",
-                                     "mole poblano", "mole amarillo", "pipián"],
-                    "Baja / Cal-Mex": ["baja", "baja california", "cal-mex", "baja fish taco",
-                                       "fish taco", "carne asada fries", "california burrito",
-                                       "birria", "birria tacos", "quesabirria",
-                                       "lobster puerto nuevo", "tijuana", "ensenada",
-                                       "agua fresca", "caesar salad tijuana"],
-                    "Mexico City":  ["mexico city", "chilaquiles", "tlayuda cdmx",
-                                     "tacos de canasta", "torta ahogada", "pozole",
-                                     "chiles en nogada"],
-                },
-            },
-            "Asian": {
-                "keywords": ["asian", "chinese", "japanese", "thai", "korean", "vietnamese",
-                             "stir fry", "stir-fry", "ramen", "sushi", "malaysian",
-                             "taiwanese", "singaporean", "burmese", "cambodian",
-                             "laotian", "mongolian", "hong kong"],
-                "subcategories": {
-                    "Korean":       ["korean", "kimchi", "bibimbap", "bulgogi", "japchae",
-                                     "doenjang", "gochujang", "tteokbokki", "sundubu",
-                                     "galbi", "jjigae", "kbbq", "korean fried chicken"],
-                    "Japanese":     ["japanese", "sushi", "ramen", "tempura", "miso",
-                                     "teriyaki", "udon", "soba", "bento", "yakitori",
-                                     "tonkatsu", "onigiri", "okonomiyaki", "takoyaki",
-                                     "kaiseki", "izakaya"],
-                    "Chinese":      ["chinese", "dim sum", "fried rice", "dumplings", "wonton",
-                                     "spring roll", "szechuan", "sichuan", "cantonese",
-                                     "chow mein", "mapo tofu", "lo mein", "hot pot",
-                                     "peking duck", "char siu", "congee"],
-                    "Thai":         ["thai", "pad thai", "green curry", "red curry",
-                                     "coconut milk", "lemongrass", "satay", "tom yum",
-                                     "larb", "khao man gai", "massaman", "pad see ew"],
-                    "Vietnamese":   ["vietnamese", "pho", "banh mi", "spring rolls",
-                                     "vermicelli", "nuoc cham", "bun bo hue",
-                                     "banh xeo", "com tam", "bun cha"],
-                    "Filipino":     ["filipino", "adobo", "sinigang", "pancit", "lumpia",
-                                     "kare-kare", "lechon", "sisig", "halo-halo",
-                                     "dinuguan", "tinola", "bistek"],
-                    "Indonesian":   ["indonesian", "rendang", "nasi goreng", "gado-gado",
-                                     "tempeh", "sambal", "soto", "opor ayam",
-                                     "bakso", "mie goreng", "nasi uduk"],
-                    "Malaysian":    ["malaysian", "laksa", "nasi lemak", "char kway teow",
-                                     "satay malaysia", "roti canai", "bak kut teh",
-                                     "cendol", "mee goreng mamak", "curry laksa"],
-                    "Taiwanese":    ["taiwanese", "beef noodle soup", "lu rou fan",
-                                     "oyster vermicelli", "scallion pancake taiwan",
-                                     "pork chop rice", "three cup chicken",
-                                     "bubble tea", "stinky tofu", "ba wan"],
-                    "Singaporean":  ["singaporean", "chicken rice", "chili crab",
-                                     "singaporean laksa", "bak chor mee", "rojak",
-                                     "kaya toast", "nasi padang", "satay singapore"],
-                    "Burmese":      ["burmese", "myanmar", "mohinga", "laphet thoke",
-                                     "tea leaf salad", "ohn no khao swe",
-                                     "mont di", "nangyi thoke"],
-                    "Hong Kong":    ["hong kong", "hk style", "pineapple bun",
-                                     "wonton noodle soup", "hk milk tea", "egg tart",
-                                     "typhoon shelter crab", "char siu bao", "jook",
-                                     "congee hk", "silk stocking tea", "dan tat",
-                                     "siu mai hk", "cheung fun"],
-                    "Cambodian":    ["cambodian", "khmer", "amok", "lok lak",
-                                     "kuy teav", "bai sach chrouk", "nom banh chok",
-                                     "samlor korko", "beef loc lac"],
-                    "Laotian":      ["laotian", "lao", "larb", "tam mak hoong",
-                                     "or lam", "khao niaw", "ping kai",
-                                     "naem khao", "khao piak sen", "mok pa"],
-                    "Mongolian":    ["mongolian", "buuz", "khuushuur", "tsuivan",
-                                     "boodog", "airag", "khorkhog", "bansh",
-                                     "guriltai shol", "suutei tsai"],
-                    "South Asian Fusion": ["south asian fusion", "indo-chinese",
-                                           "hakka chinese", "chilli chicken",
-                                           "manchurian", "schezwan"],
-                },
-            },
-            "Indian": {
-                "keywords": ["indian", "curry", "lentil", "dal", "tikka", "masala",
-                             "biryani", "naan", "chutney", "pakistani", "sri lankan",
-                             "bangladeshi", "nepali"],
-                "subcategories": {
-                    "North Indian":  ["north indian", "punjabi", "mughal", "tikka masala",
-                                      "naan", "tandoori", "butter chicken", "palak paneer",
-                                      "chole", "rajma", "aloo gobi"],
-                    "South Indian":  ["south indian", "tamil", "kerala", "dosa", "idli",
-                                      "sambar", "rasam", "coconut chutney", "appam",
-                                      "fish curry kerala", "puttu", "payasam"],
-                    "Bengali":       ["bengali", "mustard fish", "hilsa", "shorshe ilish",
-                                      "mishti doi", "rasgulla", "kosha mangsho"],
-                    "Gujarati":      ["gujarati", "dhokla", "thepla", "undhiyu",
-                                      "khandvi", "fafda", "gujarati dal"],
-                    "Pakistani":     ["pakistani", "nihari", "haleem", "seekh kebab",
-                                      "karahi", "biryani karachi", "chapli kebab",
-                                      "halwa puri", "paya"],
-                    "Sri Lankan":    ["sri lankan", "kottu roti", "hoppers", "pol sambol",
-                                      "sri lankan curry", "lamprais", "string hoppers",
-                                      "wambatu moju"],
-                    "Bangladeshi":   ["bangladeshi", "bangladesh", "dhaka biryani",
-                                      "shutki", "pitha", "hilsa curry", "kacchi biryani",
-                                      "bhuna khichuri", "doi maach", "rezala"],
-                    "Nepali":        ["nepali", "dal bhat", "momos", "sekuwa",
-                                      "sel roti", "gundruk", "thukpa"],
-                },
-            },
-            "Mediterranean": {
-                "keywords": ["mediterranean", "greek", "middle eastern", "turkish",
-                             "lebanese", "jewish", "palestinian", "yemeni", "egyptian",
-                             "syrian", "iraqi", "jordanian"],
-                "subcategories": {
-                    "Greek":          ["greek", "feta", "tzatziki", "moussaka", "spanakopita",
-                                       "souvlaki", "dolmades", "spanakopita", "tiropita",
-                                       "galaktoboureko"],
-                    "Turkish":        ["turkish", "kebab", "borek", "meze", "baklava",
-                                       "lahmacun", "menemen", "pide", "iskender",
-                                       "kisir", "simit"],
-                    "Syrian":         ["syrian", "fattet hummus", "kibbeh syria",
-                                       "muhammara", "maklouba syria", "sfeeha",
-                                       "halawet el jibn"],
-                    "Lebanese":       ["lebanese", "middle eastern", "hummus", "falafel",
-                                       "tabbouleh", "kibbeh", "fattoush", "manakish",
-                                       "kafta", "sfiha"],
-                    "Jewish":         ["jewish", "israeli", "ashkenazi", "sephardic",
-                                       "shakshuka", "sabich", "za'atar", "tahini",
-                                       "zhug", "zhoug", "s'khug", "z'houg",
-                                       "hawaiij", "hawaij", "hawayej",
-                                       "matzo", "latke", "rugelach", "babka", "challah",
-                                       "cholent", "gefilte fish", "brisket", "kugel",
-                                       "new york jewish", "new york deli", "pastrami",
-                                       "knish", "lox", "bagel and lox", "jewish deli"],
-                    "Palestinian":    ["palestinian", "musakhan", "maqluba", "knafeh",
-                                       "maftoul", "freekeh", "sumac chicken"],
-                    "Yemeni":         ["yemeni", "saltah", "lahoh", "bint al-sahn",
-                                       "zhug", "zhoug", "hulba", "fahsa",
-                                       "hawaiij", "hawaij", "hawayej"],
-                    "Egyptian":       ["egyptian", "koshari", "molokhia", "mahshi",
-                                       "ful medames", "ta'ameya", "feteer meshaltet"],
-                },
-            },
-            "American": {
-                "keywords": ["american", "southern", "comfort food", "cajun", "creole",
-                             "hawaiian", "tex-mex", "soul food"],
-                "subcategories": {
-                    "Southern":     ["southern", "soul food", "fried chicken",
-                                     "collard greens", "cornbread", "biscuits and gravy",
-                                     "mac and cheese", "sweet potato pie", "okra"],
-                    "Cajun/Creole": ["cajun", "creole", "new orleans", "gumbo",
-                                     "jambalaya", "etouffee", "dirty rice", "po'boy",
-                                     "muffuletta", "red beans and rice"],
-                    "Tex-Mex":      ["tex-mex", "southwestern", "chili", "fajita",
-                                     "queso", "breakfast taco", "chile con carne"],
-                    "New England":  ["new england", "chowder", "lobster", "clam",
-                                     "maple", "yankee", "boston baked beans",
-                                     "johnnycake", "fish and chips"],
-                    "Pacific Northwest": ["pacific northwest", "pnw", "dungeness crab",
-                                          "salmon", "cedar plank", "razor clam",
-                                          "geoduck", "chanterelle", "marionberry"],
-                    "Hawaiian":     ["hawaiian", "hawaii", "plate lunch", "loco moco",
-                                     "poke", "spam musubi", "kalua pig", "lau lau",
-                                     "haupia", "poi", "manapua", "garlic shrimp",
-                                     "saimin", "huli huli", "malasada"],
-                },
-            },
-            "BBQ & Smoke": {
-                # Top-level keywords use broad corpus-friendly terms that appear in
-                # food.com keyword/category fields (e.g. "BBQ", "Oven BBQ", "Smoker").
-                # Subcategory keywords remain specific for drill-down filtering.
-                "keywords": ["bbq", "barbecue", "barbeque", "smoked", "smoky",
-                             "smoke", "pit", "smoke ring", "low and slow",
-                             "brisket", "pulled pork", "ribs", "spare ribs",
-                             "baby back", "baby back ribs", "dry rub", "wet rub",
-                             "cookout", "smoker", "smoked meat", "smoked chicken",
-                             "smoked pork", "smoked beef", "smoked turkey",
-                             "pit smoked", "wood smoked", "slow smoked",
-                             "charcoal", "chargrilled", "burnt ends"],
-                "subcategories": {
-                    "Texas BBQ":       ["texas bbq", "central texas bbq", "brisket",
-                                        "beef brisket", "beef ribs", "smoked brisket",
-                                        "post oak", "salt and pepper rub",
-                                        "east texas bbq", "lockhart", "franklin style"],
-                    "Carolina BBQ":    ["carolina bbq", "north carolina bbq", "whole hog",
-                                        "vinegar sauce", "vinegar bbq", "lexington style",
-                                        "eastern nc", "south carolina bbq", "mustard sauce",
-                                        "carolina pulled pork"],
-                    "Kansas City BBQ": ["kansas city bbq", "kc bbq", "burnt ends",
-                                        "sweet bbq sauce", "tomato molasses sauce",
-                                        "baby back ribs", "kansas city ribs"],
-                    "Memphis BBQ":     ["memphis bbq", "dry rub ribs", "wet ribs",
-                                        "memphis style", "dry rub pork", "memphis ribs"],
-                    "Alabama BBQ":     ["alabama bbq", "white sauce", "alabama white sauce",
-                                        "smoked chicken", "white bbq sauce"],
-                    "Kentucky BBQ":    ["kentucky bbq", "mutton bbq", "owensboro bbq",
-                                        "black dip", "western kentucky barbecue", "mutton"],
-                    "St. Louis BBQ":   ["st louis bbq", "st louis ribs", "st. louis ribs",
-                                        "st louis cut ribs", "spare ribs st louis"],
-                    "Backyard Grill":  ["backyard bbq", "cookout", "grilled burgers",
-                                        "charcoal grill", "kettle grill", "tailgate",
-                                        "grill out", "backyard grilling"],
-                },
-            },
-            "European": {
-                "keywords": ["french", "german", "spanish", "british", "irish", "scottish",
-                             "welsh", "scandinavian", "nordic", "eastern european"],
-                "subcategories": {
-                    "French":        ["french", "provencal", "beurre", "crepe",
-                                      "ratatouille", "cassoulet", "bouillabaisse"],
-                    "Spanish":       ["spanish", "paella", "tapas", "gazpacho",
-                                      "tortilla espanola", "chorizo"],
-                    "German":        ["german", "bratwurst", "sauerkraut", "schnitzel",
-                                      "pretzel", "strudel"],
-                    "British":       ["british", "english", "pub food", "cornish",
-                                      "shepherd's pie", "bangers", "toad in the hole",
-                                      "coronation chicken", "london", "londoner",
-                                      "cornish pasty", "ploughman's"],
-                    "Irish":         ["irish", "ireland", "colcannon", "coddle",
-                                      "irish stew", "soda bread", "boxty", "champ"],
-                    "Scottish":      ["scottish", "scotland", "haggis", "cullen skink",
-                                      "cranachan", "scotch broth", "glaswegian",
-                                      "neeps and tatties", "tablet"],
-                    "Scandinavian":  ["scandinavian", "nordic", "swedish", "norwegian",
-                                      "danish", "finnish", "gravlax", "swedish meatballs",
-                                      "lefse", "smörgåsbord", "fika", "crispbread",
-                                      "cardamom bun", "herring", "æbleskiver",
-                                      "lingonberry", "lutefisk", "janssons frestelse",
-                                      "knäckebröd", "kladdkaka"],
-                    "Eastern European": ["eastern european", "polish", "russian", "ukrainian",
-                                         "czech", "hungarian", "pierogi", "borscht",
-                                         "goulash", "kielbasa", "varenyky", "pelmeni"],
-                },
-            },
-            "Latin American": {
-                "keywords": ["latin american", "peruvian", "argentinian", "colombian",
-                             "cuban", "caribbean", "brazilian", "venezuelan", "chilean"],
-                "subcategories": {
-                    "Peruvian":    ["peruvian", "ceviche", "lomo saltado", "anticucho",
-                                    "aji amarillo", "causa", "leche de tigre",
-                                    "arroz con leche peru", "pollo a la brasa"],
-                    "Brazilian":   ["brazilian", "churrasco", "feijoada", "pao de queijo",
-                                    "brigadeiro", "coxinha", "moqueca", "vatapa",
-                                    "caipirinha", "acai bowl"],
-                    "Colombian":   ["colombian", "bandeja paisa", "arepas", "empanadas",
-                                    "sancocho", "ajiaco", "buñuelos", "changua"],
-                    "Argentinian": ["argentinian", "asado", "chimichurri", "empanadas argentina",
-                                    "milanesa", "locro", "dulce de leche", "medialunas"],
-                    "Venezuelan":  ["venezuelan", "pabellón criollo", "arepas venezuela",
-                                    "hallacas", "cachapas", "tequeños", "caraotas"],
-                    "Chilean":     ["chilean", "cazuela", "pastel de choclo", "curanto",
-                                    "sopaipillas", "charquicán", "completo"],
-                    "Cuban":       ["cuban", "ropa vieja", "moros y cristianos",
-                                    "picadillo", "lechon cubano", "vaca frita",
-                                    "tostones", "platanos maduros"],
-                    "Jamaican":    ["jamaican", "jerk chicken", "jerk pork", "ackee saltfish",
-                                    "curry goat", "rice and peas", "escovitch",
-                                    "jamaican patty", "callaloo jamaica", "festival"],
-                    "Puerto Rican": ["puerto rican", "mofongo", "pernil", "arroz con gandules",
-                                     "sofrito", "pasteles", "tostones pr", "tembleque",
-                                     "coquito", "asopao"],
-                    "Dominican":   ["dominican", "mangu", "sancocho dominicano",
-                                    "pollo guisado", "habichuelas guisadas",
-                                    "tostones dominicanos", "morir soñando"],
-                    "Haitian":     ["haitian", "griot", "pikliz", "riz et pois",
-                                    "joumou", "akra", "pain patate", "labouyi"],
-                    "Trinidad":    ["trinidadian", "doubles", "roti trinidad", "pelau",
-                                    "callaloo trinidad", "bake and shark",
-                                    "curry duck", "oil down"],
-                },
-            },
-            "Central American": {
-                "keywords": ["central american", "salvadoran", "guatemalan",
-                             "honduran", "nicaraguan", "costa rican", "panamanian"],
-                "subcategories": {
-                    "Salvadoran":   ["salvadoran", "el salvador", "pupusas", "curtido",
-                                     "sopa de pata", "nuégados", "atol shuco"],
-                    "Guatemalan":   ["guatemalan", "pepián", "jocon", "kak'ik",
-                                     "hilachas", "rellenitos", "fiambre"],
-                    "Costa Rican":  ["costa rican", "gallo pinto", "casado",
-                                     "olla de carne", "arroz con leche cr",
-                                     "tres leches cr"],
-                    "Honduran":     ["honduran", "baleadas", "sopa de caracol",
-                                     "tapado", "machuca", "catrachitas"],
-                    "Nicaraguan":   ["nicaraguan", "nacatamal", "vigorón", "indio viejo",
-                                     "gallo pinto nicaragua", "güirilas"],
-                },
-            },
-            "African": {
-                "keywords": ["african", "west african", "east african", "ethiopian",
-                             "nigerian", "ghanaian", "kenyan", "south african",
-                             "senegalese", "tunisian"],
-                "subcategories": {
-                    "West African":        ["west african", "nigerian", "ghanaian",
-                                            "jollof rice", "egusi soup", "fufu", "suya",
-                                            "groundnut stew", "kelewele", "kontomire",
-                                            "waakye", "ofam", "bitterleaf soup"],
-                    "Senegalese":          ["senegalese", "senegal", "thieboudienne",
-                                            "yassa", "mafe", "thiou", "ceebu jen",
-                                            "domoda"],
-                    "Ethiopian & Eritrean": ["ethiopian", "eritrean", "injera", "doro wat",
-                                             "kitfo", "tibs", "shiro", "misir wat",
-                                             "gomen", "ful ethiopian", "tegamino"],
-                    "East African":        ["east african", "kenyan", "tanzanian", "ugandan",
-                                            "nyama choma", "ugali", "sukuma wiki",
-                                            "pilau kenya", "mandazi", "matoke",
-                                            "githeri", "irio"],
-                    "North African":       ["north african", "tunisian", "algerian", "libyan",
-                                            "brik", "lablabi", "merguez", "shakshuka tunisian",
-                                            "harissa tunisian", "couscous algerian"],
-                    "South African":       ["south african", "braai", "bobotie", "boerewors",
-                                            "bunny chow", "pap", "chakalaka", "biltong",
-                                            "malva pudding", "koeksister", "potjiekos"],
-                    "Moroccan":            ["moroccan", "tagine", "couscous morocco",
-                                            "harissa", "chermoula", "preserved lemon",
-                                            "pastilla", "mechoui", "bastilla"],
-                },
-            },
-            "Pacific & Oceania": {
-                "keywords": ["pacific", "oceania", "polynesian", "melanesian",
-                             "micronesian", "maori", "fijian", "samoan", "tongan",
-                             "hawaiian", "australian", "new zealand"],
-                "subcategories": {
-                    "Māori / New Zealand": ["maori", "new zealand", "hangi", "rewena bread",
-                                            "boil-up", "paua", "kumara", "pavlova nz",
-                                            "whitebait fritter", "kina", "hokey pokey"],
-                    "Australian":          ["australian", "meat pie", "lamington",
-                                            "anzac biscuits", "damper", "barramundi",
-                                            "vegemite", "pavlova australia", "tim tam",
-                                            "sausage sizzle", "chiko roll", "fairy bread"],
-                    "Fijian":              ["fijian", "fiji", "kokoda", "lovo",
-                                            "rourou", "palusami fiji", "duruka",
-                                            "vakalolo"],
-                    "Samoan":              ["samoan", "samoa", "palusami", "oka",
-                                            "fa'ausi", "chop suey samoa", "sapasui",
-                                            "koko alaisa", "supo esi"],
-                    "Tongan":              ["tongan", "tonga", "lu pulu", "'ota 'ika",
-                                            "fekkai", "faikakai topai", "kapisi pulu"],
-                    "Papua New Guinean":   ["papua new guinea", "png", "mumu",
-                                            "sago", "aibika", "kaukau",
-                                            "taro png", "coconut crab"],
-                    "Hawaiian":            ["hawaiian", "hawaii", "poke", "loco moco",
-                                            "plate lunch", "kalua pig", "haupia",
-                                            "spam musubi", "poi", "malasada"],
-                },
-            },
-            "Central Asian & Caucasus": {
-                "keywords": ["central asian", "caucasus", "georgian", "armenian", "uzbek",
-                             "afghan", "persian", "iranian", "azerbaijani", "kazakh"],
-                "subcategories": {
-                    "Persian / Iranian": ["persian", "iranian", "ghormeh sabzi", "fesenjan",
-                                          "tahdig", "joojeh kabab", "ash reshteh",
-                                          "zereshk polo", "khoresh", "mast o khiar",
-                                          "kashk-e-bademjan", "mirza ghasemi",
-                                          "baghali polo"],
-                    "Georgian":          ["georgian", "georgia", "khachapuri", "khinkali",
-                                          "churchkhela", "ajapsandali", "satsivi",
-                                          "pkhali", "lobiani", "badrijani nigvzit"],
-                    "Armenian":          ["armenian", "dolma armenia", "lahmajoun",
-                                          "manti armenia", "ghapama", "basturma",
-                                          "harissa armenia", "nazook", "tolma"],
-                    "Azerbaijani":       ["azerbaijani", "azerbaijan", "plov azerbaijan",
-                                          "dolma azeri", "dushbara", "levengi",
-                                          "shah plov", "gutab"],
-                    "Uzbek":             ["uzbek", "uzbekistan", "plov", "samsa",
-                                          "lagman", "shashlik", "manti uzbek",
-                                          "non bread", "dimlama", "sumalak"],
-                    "Afghan":            ["afghan", "afghanistan", "kabuli pulao", "mantu",
-                                          "bolani", "qorma", "ashak", "shorwa",
-                                          "aushak", "borani banjan"],
-                    "Kazakh":            ["kazakh", "beshbarmak", "kuyrdak", "baursak",
-                                          "kurt", "shubat", "kazy"],
-                },
-            },
         },
     },
     "meal_type": {
         "label": "Meal Type",
         "categories": {
-            "Breakfast": {
+            "Breakfast":   ["breakfast", "brunch", "eggs", "pancakes", "waffles", "oatmeal", "muffin"],
-                "keywords": ["breakfast", "brunch", "eggs", "pancakes", "waffles",
+            "Lunch":       ["lunch", "sandwich", "wrap", "salad", "soup", "light meal"],
-                             "oatmeal", "muffin"],
+            "Dinner":      ["dinner", "main dish", "entree", "main course", "supper"],
-                "subcategories": {
+            "Snack":       ["snack", "appetizer", "finger food", "dip", "bite", "starter"],
-                    "Eggs":              ["egg", "omelette", "frittata", "quiche",
+            "Dessert":     ["dessert", "cake", "cookie", "pie", "sweet", "pudding", "ice cream", "brownie"],
-                                          "scrambled", "benedict", "shakshuka"],
-                    "Pancakes & Waffles": ["pancake", "waffle", "crepe", "french toast"],
-                    "Baked Goods":       ["muffin", "scone", "biscuit", "quick bread",
-                                          "coffee cake", "danish"],
-                    "Oats & Grains":     ["oatmeal", "granola", "porridge", "muesli",
-                                          "overnight oats"],
-                },
-            },
-            "Lunch": {
-                "keywords": ["lunch", "sandwich", "wrap", "salad", "soup", "light meal"],
-                "subcategories": {
-                    "Sandwiches": ["sandwich", "sub", "hoagie", "panini", "club",
-                                   "grilled cheese", "blt"],
-                    "Salads":     ["salad", "grain bowl", "chopped", "caesar",
-                                   "niçoise", "cobb"],
-                    "Soups":      ["soup", "bisque", "chowder", "gazpacho",
-                                   "minestrone", "lentil soup"],
-                    "Wraps":      ["wrap", "burrito bowl", "pita", "lettuce wrap",
-                                   "quesadilla"],
-                },
-            },
-            "Dinner": {
-                "keywords": ["dinner", "main dish", "entree", "main course", "supper"],
-                "subcategories": {
-                    "Casseroles": ["casserole", "bake", "gratin", "lasagna",
-                                   "sheperd's pie", "pot pie"],
-                    "Stews":      ["stew", "braise", "slow cooker", "pot roast",
-                                   "daube", "ragù"],
-                    "Grilled":    ["grilled", "grill", "barbecue", "charred",
-                                   "kebab", "skewer"],
-                    "Stir-Fries": ["stir fry", "stir-fry", "wok", "sauté",
-                                   "sauteed"],
-                    "Roasts":     ["roast", "roasted", "oven", "baked chicken",
-                                   "pot roast"],
-                },
-            },
-            "Snack": {
-                "keywords": ["snack", "appetizer", "finger food", "dip", "bite",
-                             "starter"],
-                "subcategories": {
-                    "Dips & Spreads": ["dip", "spread", "hummus", "guacamole",
-                                       "salsa", "pate"],
-                    "Finger Foods":   ["finger food", "bite", "skewer", "slider",
-                                       "wing", "nugget"],
-                    "Chips & Crackers": ["chip", "cracker", "crisp", "popcorn",
-                                          "pretzel"],
-                },
-            },
-            "Dessert": {
-                "keywords": ["dessert", "cake", "cookie", "pie", "sweet", "pudding",
-                             "ice cream", "brownie"],
-                "subcategories": {
-                    "Cakes":         ["cake", "cupcake", "layer cake", "bundt",
-                                      "cheesecake", "torte"],
-                    "Cookies & Bars": ["cookie", "brownie", "blondie", "bar",
-                                       "biscotti", "shortbread"],
-                    "Pies & Tarts":  ["pie", "tart", "galette", "cobbler", "crisp",
-                                       "crumble"],
-                    "Frozen":        ["ice cream", "gelato", "sorbet", "frozen dessert",
-                                      "popsicle", "granita"],
-                    "Puddings":      ["pudding", "custard", "mousse", "panna cotta",
-                                      "flan", "creme brulee"],
-                    "Candy":         ["candy", "fudge", "truffle", "brittle",
-                                      "caramel", "toffee"],
-                },
-            },
             "Beverage":    ["drink", "smoothie", "cocktail", "beverage", "juice", "shake"],
             "Side Dish":   ["side dish", "side", "accompaniment", "garnish"],
         },
@@ -515,128 +56,31 @@ DOMAINS: dict[str, dict] = {
     "main_ingredient": {
         "label": "Main Ingredient",
         "categories": {
-            # keywords use exact inferred_tag strings (main:X) — indexed into recipe_browser_fts.
+            "Chicken":    ["chicken", "poultry", "turkey"],
-            "Chicken": {
+            "Beef":       ["beef", "ground beef", "steak", "brisket", "pot roast"],
-                "keywords": ["main:Chicken"],
+            "Pork":       ["pork", "bacon", "ham", "sausage", "prosciutto"],
-                "subcategories": {
+            "Fish":       ["fish", "salmon", "tuna", "tilapia", "cod", "halibut", "shrimp", "seafood"],
-                    "Baked":    ["baked chicken", "roast chicken", "chicken casserole",
+            "Pasta":      ["pasta", "noodle", "spaghetti", "penne", "fettuccine", "linguine"],
-                                 "chicken bake"],
+            "Vegetables": ["vegetable", "veggie", "cauliflower", "broccoli", "zucchini", "eggplant"],
-                    "Grilled":  ["grilled chicken", "chicken kebab", "bbq chicken",
+            "Eggs":       ["egg", "frittata", "omelette", "omelet", "quiche"],
-                                 "chicken skewer"],
+            "Legumes":    ["bean", "lentil", "chickpea", "tofu", "tempeh", "edamame"],
-                    "Fried":    ["fried chicken", "chicken cutlet", "chicken schnitzel",
+            "Grains":     ["rice", "quinoa", "barley", "farro", "oat", "grain"],
-                                 "crispy chicken"],
+            "Cheese":     ["cheese", "ricotta", "mozzarella", "parmesan", "cheddar"],
-                    "Stewed":   ["chicken stew", "chicken soup", "coq au vin",
-                                 "chicken curry", "chicken braise"],
-                },
-            },
-            "Beef": {
-                "keywords": ["main:Beef"],
-                "subcategories": {
-                    "Ground Beef": ["ground beef", "hamburger", "meatball", "meatloaf",
-                                    "bolognese", "burger"],
-                    "Steak":       ["steak", "sirloin", "ribeye", "flank steak",
-                                    "filet mignon", "t-bone"],
-                    "Roasts":      ["beef roast", "pot roast", "brisket", "prime rib",
-                                    "chuck roast"],
-                    "Stews":       ["beef stew", "beef braise", "beef bourguignon",
-                                    "short ribs"],
-                },
-            },
-            "Pork": {
-                "keywords": ["main:Pork"],
-                "subcategories": {
-                    "Chops":        ["pork chop", "pork loin", "pork cutlet"],
-                    "Pulled/Slow":  ["pulled pork", "pork shoulder", "pork butt",
-                                     "carnitas", "slow cooker pork"],
-                    "Sausage":      ["sausage", "bratwurst", "chorizo", "andouille",
-                                     "Italian sausage"],
-                    "Ribs":         ["pork ribs", "baby back ribs", "spare ribs",
-                                     "pork belly"],
-                },
-            },
-            "Fish": {
-                "keywords": ["main:Fish"],
-                "subcategories": {
-                    "Salmon":    ["salmon", "smoked salmon", "gravlax"],
-                    "Tuna":      ["tuna", "albacore", "ahi"],
-                    "White Fish": ["cod", "tilapia", "halibut", "sole", "snapper",
-                                   "flounder", "bass"],
-                    "Shellfish": ["shrimp", "prawn", "crab", "lobster", "scallop",
-                                  "mussel", "clam", "oyster"],
-                },
-            },
-            "Pasta":      ["main:Pasta"],
-            "Vegetables": {
-                "keywords": ["main:Vegetables"],
-                "subcategories": {
-                    "Root Veg":    ["potato", "sweet potato", "carrot", "beet",
-                                    "parsnip", "turnip"],
-                    "Leafy":       ["spinach", "kale", "chard", "arugula",
-                                    "collard greens", "lettuce"],
-                    "Brassicas":   ["broccoli", "cauliflower", "brussels sprouts",
-                                    "cabbage", "bok choy"],
-                    "Nightshades": ["tomato", "eggplant", "bell pepper", "zucchini",
-                                    "squash"],
-                    "Mushrooms":   ["mushroom", "portobello", "shiitake", "oyster mushroom",
-                                    "chanterelle"],
-                },
-            },
-            "Eggs":    ["main:Eggs"],
-            "Legumes": ["main:Legumes"],
-            "Grains":  ["main:Grains"],
-            "Cheese":  ["main:Cheese"],
         },
     },
 }
 
 
-def _get_category_def(domain: str, category: str) -> list[str] | dict | None:
-    """Return the raw category definition, or None if not found."""
-    return DOMAINS.get(domain, {}).get("categories", {}).get(category)
-
-
 def get_domain_labels() -> list[dict]:
     """Return [{id, label}] for all available domains."""
     return [{"id": k, "label": v["label"]} for k, v in DOMAINS.items()]
 
 
 def get_keywords_for_category(domain: str, category: str) -> list[str]:
-    """Return the keyword list for the category (top-level, covers all subcategories).
+    """Return the keyword list for a domain/category pair, or [] if not found."""
-
+    domain_data = DOMAINS.get(domain, {})
-    For flat categories returns the list directly.
+    categories = domain_data.get("categories", {})
-    For nested categories returns the 'keywords' key.
+    return categories.get(category, [])
-    Returns [] if category or domain not found.
-    """
-    cat_def = _get_category_def(domain, category)
-    if cat_def is None:
-        return []
-    if isinstance(cat_def, list):
-        return cat_def
-    return cat_def.get("keywords", [])
-
-
-def category_has_subcategories(domain: str, category: str) -> bool:
-    """Return True when a category has a subcategory level."""
-    cat_def = _get_category_def(domain, category)
-    if not isinstance(cat_def, dict):
-        return False
-    return bool(cat_def.get("subcategories"))
-
-
-def get_subcategory_names(domain: str, category: str) -> list[str]:
-    """Return subcategory names for a category, or [] if none exist."""
-    cat_def = _get_category_def(domain, category)
-    if not isinstance(cat_def, dict):
-        return []
-    return list(cat_def.get("subcategories", {}).keys())
-
-
-def get_keywords_for_subcategory(domain: str, category: str, subcategory: str) -> list[str]:
-    """Return keyword list for a specific subcategory, or [] if not found."""
-    cat_def = _get_category_def(domain, category)
-    if not isinstance(cat_def, dict):
-        return []
-    return cat_def.get("subcategories", {}).get(subcategory, [])
 
 
 def get_category_names(domain: str) -> list[str]:

app/services/recipe/element_classifier.py

@@ -84,9 +84,8 @@ class ElementClassifier:
         name = ingredient_name.lower().strip()
         if not name:
             return IngredientProfile(name="", elements=[], source="heuristic")
-        c = self._store._cp
         row = self._store._fetch_one(
-            f"SELECT * FROM {c}ingredient_profiles WHERE name = ?", (name,)
+            "SELECT * FROM ingredient_profiles WHERE name = ?", (name,)
         )
         if row:
             return self._row_to_profile(row)

app/services/recipe/grocery_links.py

@@ -13,7 +13,6 @@ Walmart is kept inline until cf-core adds Impact network support:
 
 Links are always generated (plain URLs are useful even without affiliate IDs).
 Walmart links only appear when WALMART_AFFILIATE_ID is set.
-Instacart and Walmart are US/CA-only; other locales get Amazon only.
 """
 from __future__ import annotations
 
@@ -24,26 +23,18 @@ from urllib.parse import quote_plus
 from circuitforge_core.affiliates import wrap_url
 
 from app.models.schemas.recipe import GroceryLink
-from app.services.recipe.locale_config import get_locale
 
 logger = logging.getLogger(__name__)
 
 
-def _amazon_link(ingredient: str, locale: str) -> GroceryLink:
+def _amazon_fresh_link(ingredient: str) -> GroceryLink:
-    cfg = get_locale(locale)
     q = quote_plus(ingredient)
-    domain = cfg["amazon_domain"]
+    base = f"https://www.amazon.com/s?k={q}&i=amazonfresh"
-    dept = cfg["amazon_grocery_dept"]
+    return GroceryLink(ingredient=ingredient, retailer="Amazon Fresh", url=wrap_url(base, "amazon"))
-    base = f"https://www.{domain}/s?k={q}&{dept}"
-    retailer = "Amazon" if locale != "us" else "Amazon Fresh"
-    return GroceryLink(ingredient=ingredient, retailer=retailer, url=wrap_url(base, "amazon"))
 
 
-def _instacart_link(ingredient: str, locale: str) -> GroceryLink:
+def _instacart_link(ingredient: str) -> GroceryLink:
     q = quote_plus(ingredient)
-    if locale == "ca":
-        base = f"https://www.instacart.ca/store/s?k={q}"
-    else:
     base = f"https://www.instacart.com/store/s?k={q}"
     return GroceryLink(ingredient=ingredient, retailer="Instacart", url=wrap_url(base, "instacart"))
 
@@ -59,28 +50,26 @@ def _walmart_link(ingredient: str, affiliate_id: str) -> GroceryLink:
 
 
 class GroceryLinkBuilder:
-    def __init__(self, tier: str = "free", has_byok: bool = False, locale: str = "us") -> None:
+    def __init__(self, tier: str = "free", has_byok: bool = False) -> None:
         self._tier = tier
-        self._locale = locale
-        self._locale_cfg = get_locale(locale)
         self._walmart_id = os.environ.get("WALMART_AFFILIATE_ID", "").strip()
 
     def build_links(self, ingredient: str) -> list[GroceryLink]:
         """Build grocery deeplinks for a single ingredient.
 
-        Amazon link is always included, routed to the user's locale domain.
+        Amazon Fresh and Instacart links are always included; wrap_url handles
-        Instacart and Walmart are only shown where they operate (US/CA).
+        affiliate ID injection (or returns a plain URL if none is configured).
-        wrap_url handles affiliate ID injection for supported programs.
+        Walmart requires WALMART_AFFILIATE_ID to be set (Impact network uses a
+        path-based redirect that doesn't degrade cleanly to a plain URL).
         """
         if not ingredient.strip():
             return []
 
-        links: list[GroceryLink] = [_amazon_link(ingredient, self._locale)]
+        links: list[GroceryLink] = [
-
+            _amazon_fresh_link(ingredient),
-        if self._locale_cfg["instacart"]:
+            _instacart_link(ingredient),
-            links.append(_instacart_link(ingredient, self._locale))
+        ]
-
+        if self._walmart_id:
-        if self._locale_cfg["walmart"] and self._walmart_id:
             links.append(_walmart_link(ingredient, self._walmart_id))
 
         return links

app/services/recipe/llm_recipe.py

@@ -68,9 +68,6 @@ class LLMRecipeGenerator:
         if allergy_list:
             lines.append(f"IMPORTANT — must NOT contain: {', '.join(allergy_list)}")
 
-        if req.exclude_ingredients:
-            lines.append(f"IMPORTANT — user does not want these today: {', '.join(req.exclude_ingredients)}. Do not include them.")
-
         lines.append("")
         lines.append(f"Covered culinary elements: {', '.join(covered_elements) or 'none'}")
 
@@ -87,13 +84,7 @@ class LLMRecipeGenerator:
                 if template.aromatics:
                     lines.append(f"Preferred aromatics: {', '.join(template.aromatics[:4])}")
 
-        unit_line = (
-            "Use metric units (grams, ml, Celsius) for all quantities and temperatures."
-            if req.unit_system == "metric"
-            else "Use imperial units (oz, cups, Fahrenheit) for all quantities and temperatures."
-        )
         lines += [
-            unit_line,
             "",
             "Reply using EXACTLY this plain-text format — no markdown, no bold, no extra commentary:",
             "Title: <name of the dish>",
@@ -127,17 +118,8 @@ class LLMRecipeGenerator:
         if allergy_list:
             lines.append(f"Must NOT contain: {', '.join(allergy_list)}")
 
-        if req.exclude_ingredients:
-            lines.append(f"Do not use today: {', '.join(req.exclude_ingredients)}")
-
-        unit_line = (
-            "Use metric units (grams, ml, Celsius) for all quantities and temperatures."
-            if req.unit_system == "metric"
-            else "Use imperial units (oz, cups, Fahrenheit) for all quantities and temperatures."
-        )
         lines += [
             "Treat any mystery ingredient as a wildcard — use your imagination.",
-            unit_line,
             "Reply using EXACTLY this plain-text format — no markdown, no bold:",
             "Title: <name of the dish>",
             "Ingredients: <comma-separated list>",
@@ -149,15 +131,12 @@ class LLMRecipeGenerator:
 
         return "\n".join(lines)
 
-    _SERVICE_TYPE = "vllm"
+    _MODEL_CANDIDATES: list[str] = ["Ouro-2.6B-Thinking", "Ouro-1.4B"]
-    _MODEL_CANDIDATES = ["Qwen2.5-3B-Instruct", "Phi-4-mini-instruct"]
-    _TTL_S = 300.0
-    _CALLER = "kiwi-recipe"
 
     def _get_llm_context(self):
         """Return a sync context manager that yields an Allocation or None.
 
-        When CF_ORCH_URL is set, uses CFOrchClient to acquire a cf-text allocation
+        When CF_ORCH_URL is set, uses CFOrchClient to acquire a vLLM allocation
         (which handles service lifecycle and VRAM). Falls back to nullcontext(None)
         when the env var is absent or CFOrchClient raises on construction.
         """
@@ -167,11 +146,10 @@ class LLMRecipeGenerator:
                 from circuitforge_orch.client import CFOrchClient
                 client = CFOrchClient(cf_orch_url)
                 return client.allocate(
-                    service=self._SERVICE_TYPE,
+                    service="vllm",
                     model_candidates=self._MODEL_CANDIDATES,
-                    ttl_s=self._TTL_S,
+                    ttl_s=300.0,
-                    caller=self._CALLER,
+                    caller="kiwi-recipe",
-                    pipeline=os.environ.get("CF_APP_NAME") or None,
                 )
             except Exception as exc:
                 logger.debug("CFOrchClient init failed, falling back to direct URL: %s", exc)
@@ -190,19 +168,6 @@ class LLMRecipeGenerator:
         try:
             alloc = ctx.__enter__()
         except Exception as exc:
-            msg = str(exc)
-            # 429 = coordinator at capacity (all nodes at max_concurrent limit).
-            # Don't fall back to LLMRouter — it's also overloaded and the slow
-            # fallback causes nginx 504s. Return "" fast so the caller degrades
-            # gracefully (empty recipe result) rather than timing out.
-            if "429" in msg or "max_concurrent" in msg.lower():
-                logger.info("cf-orch at capacity — returning empty result (graceful degradation)")
-                if ctx is not None:
-                    try:
-                        ctx.__exit__(None, None, None)
-                    except Exception:
-                        pass
-                return ""
             logger.debug("cf-orch allocation failed, falling back to LLMRouter: %s", exc)
             ctx = None  # __enter__ raised — do not call __exit__
 

app/services/recipe/locale_config.py

@@ -1,160 +0,0 @@
-"""
-Shopping locale configuration.
-
-Maps a locale key to Amazon domain, currency metadata, and retailer availability.
-Instacart and Walmart are US/CA-only; all other locales get Amazon only.
-Amazon Fresh (&i=amazonfresh) is US-only — international domains use the general
-grocery department (&rh=n:16310101) where available, plain search elsewhere.
-"""
-from __future__ import annotations
-
-from typing import TypedDict
-
-
-class LocaleConfig(TypedDict):
-    amazon_domain: str
-    amazon_grocery_dept: str   # URL fragment for grocery department on this locale's site
-    currency_code: str
-    currency_symbol: str
-    instacart: bool
-    walmart: bool
-
-
-LOCALES: dict[str, LocaleConfig] = {
-    "us": {
-        "amazon_domain":       "amazon.com",
-        "amazon_grocery_dept": "i=amazonfresh",
-        "currency_code":       "USD",
-        "currency_symbol":     "$",
-        "instacart":           True,
-        "walmart":             True,
-    },
-    "ca": {
-        "amazon_domain":       "amazon.ca",
-        "amazon_grocery_dept": "rh=n:6967215011",   # Grocery dept on .ca  # gitleaks:allow
-        "currency_code":       "CAD",
-        "currency_symbol":     "CA$",
-        "instacart":           True,
-        "walmart":             False,
-    },
-    "gb": {
-        "amazon_domain":       "amazon.co.uk",
-        "amazon_grocery_dept": "rh=n:340831031",    # Grocery dept on .co.uk
-        "currency_code":       "GBP",
-        "currency_symbol":     "£",
-        "instacart":           False,
-        "walmart":             False,
-    },
-    "au": {
-        "amazon_domain":       "amazon.com.au",
-        "amazon_grocery_dept": "rh=n:5765081051",   # Pantry/grocery on .com.au  # gitleaks:allow
-        "currency_code":       "AUD",
-        "currency_symbol":     "A$",
-        "instacart":           False,
-        "walmart":             False,
-    },
-    "nz": {
-        # NZ has no Amazon storefront — route to .com.au as nearest option
-        "amazon_domain":       "amazon.com.au",
-        "amazon_grocery_dept": "rh=n:5765081051",  # gitleaks:allow
-        "currency_code":       "NZD",
-        "currency_symbol":     "NZ$",
-        "instacart":           False,
-        "walmart":             False,
-    },
-    "de": {
-        "amazon_domain":       "amazon.de",
-        "amazon_grocery_dept": "rh=n:340843031",    # Lebensmittel & Getränke
-        "currency_code":       "EUR",
-        "currency_symbol":     "€",
-        "instacart":           False,
-        "walmart":             False,
-    },
-    "fr": {
-        "amazon_domain":       "amazon.fr",
-        "amazon_grocery_dept": "rh=n:197858031",
-        "currency_code":       "EUR",
-        "currency_symbol":     "€",
-        "instacart":           False,
-        "walmart":             False,
-    },
-    "it": {
-        "amazon_domain":       "amazon.it",
-        "amazon_grocery_dept": "rh=n:525616031",
-        "currency_code":       "EUR",
-        "currency_symbol":     "€",
-        "instacart":           False,
-        "walmart":             False,
-    },
-    "es": {
-        "amazon_domain":       "amazon.es",
-        "amazon_grocery_dept": "rh=n:599364031",
-        "currency_code":       "EUR",
-        "currency_symbol":     "€",
-        "instacart":           False,
-        "walmart":             False,
-    },
-    "nl": {
-        "amazon_domain":       "amazon.nl",
-        "amazon_grocery_dept": "rh=n:16584827031",
-        "currency_code":       "EUR",
-        "currency_symbol":     "€",
-        "instacart":           False,
-        "walmart":             False,
-    },
-    "se": {
-        "amazon_domain":       "amazon.se",
-        "amazon_grocery_dept": "rh=n:20741393031",
-        "currency_code":       "SEK",
-        "currency_symbol":     "kr",
-        "instacart":           False,
-        "walmart":             False,
-    },
-    "jp": {
-        "amazon_domain":       "amazon.co.jp",
-        "amazon_grocery_dept": "rh=n:2246283051",  # gitleaks:allow
-        "currency_code":       "JPY",
-        "currency_symbol":     "¥",
-        "instacart":           False,
-        "walmart":             False,
-    },
-    "in": {
-        "amazon_domain":       "amazon.in",
-        "amazon_grocery_dept": "rh=n:2454178031",  # gitleaks:allow
-        "currency_code":       "INR",
-        "currency_symbol":     "₹",
-        "instacart":           False,
-        "walmart":             False,
-    },
-    "mx": {
-        "amazon_domain":       "amazon.com.mx",
-        "amazon_grocery_dept": "rh=n:10737659011",
-        "currency_code":       "MXN",
-        "currency_symbol":     "MX$",
-        "instacart":           False,
-        "walmart":             False,
-    },
-    "br": {
-        "amazon_domain":       "amazon.com.br",
-        "amazon_grocery_dept": "rh=n:17878420011",
-        "currency_code":       "BRL",
-        "currency_symbol":     "R$",
-        "instacart":           False,
-        "walmart":             False,
-    },
-    "sg": {
-        "amazon_domain":       "amazon.sg",
-        "amazon_grocery_dept": "rh=n:6981647051",  # gitleaks:allow
-        "currency_code":       "SGD",
-        "currency_symbol":     "S$",
-        "instacart":           False,
-        "walmart":             False,
-    },
-}
-
-DEFAULT_LOCALE = "us"
-
-
-def get_locale(key: str) -> LocaleConfig:
-    """Return locale config for *key*, falling back to US if unknown."""
-    return LOCALES.get(key, LOCALES[DEFAULT_LOCALE])

app/services/recipe/recipe_engine.py

@@ -20,13 +20,10 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from app.db.store import Store
 
-from app.models.schemas.recipe import GroceryLink, NutritionPanel, RecipeRequest, RecipeResult, RecipeSuggestion, StepAnalysis, TimeEffortProfile, SwapCandidate
+from app.models.schemas.recipe import GroceryLink, NutritionPanel, RecipeRequest, RecipeResult, RecipeSuggestion, SwapCandidate
 from app.services.recipe.element_classifier import ElementClassifier
 from app.services.recipe.grocery_links import GroceryLinkBuilder
 from app.services.recipe.substitution_engine import SubstitutionEngine
-from app.services.recipe.sensory import SensoryExclude, build_sensory_exclude, passes_sensory_filter
-from app.services.recipe.time_effort import parse_time_effort
-from app.services.recipe.reranker import rerank_suggestions
 
 _LEFTOVER_DAILY_MAX_FREE = 5
 
@@ -36,38 +33,6 @@ _SWAP_STOPWORDS = frozenset({
     "to", "from", "at", "by", "as", "on",
 })
 
-# Marketing / prep / packaging words stripped when tokenising product-label names
-# into individual ingredient tokens.  Parallel to Store._FTS_TOKEN_STOPWORDS —
-# both lists should agree.  Kept here to avoid a circular import at runtime.
-_PRODUCT_TOKEN_STOPWORDS = frozenset({
-    # Basic English stopwords
-    "a", "an", "the", "of", "in", "for", "with", "and", "or", "to",
-    "from", "at", "by", "as", "on", "into",
-    # Brand / marketing words that appear in product names
-    "lean", "cuisine", "healthy", "choice", "stouffer", "original",
-    "classic", "deluxe", "homestyle", "family", "style", "grade",
-    "premium", "select", "natural", "organic", "fresh", "lite",
-    "ready", "quick", "easy", "instant", "microwave", "frozen",
-    "brand", "size", "large", "small", "medium", "extra",
-    # Plant-based / alt-meat brand names
-    "daring", "gardein", "morningstar", "lightlife", "tofurky",
-    "quorn", "omni", "nuggs", "simulate",
-    # Preparation states
-    "cut", "diced", "sliced", "chopped", "minced", "shredded",
-    "cooked", "raw", "whole", "boneless", "skinless", "trimmed",
-    "pre", "prepared", "marinated", "seasoned", "breaded", "battered",
-    "grilled", "roasted", "smoked", "canned", "dried", "dehydrated",
-    "pieces", "piece", "strips", "strip", "chunks", "chunk",
-    "fillets", "fillet", "cutlets", "cutlet", "tenders", "nuggets",
-    # Units / packaging
-    "oz", "lb", "lbs", "pkg", "pack", "box", "can", "bag", "jar",
-    # Adjectives that aren't ingredients
-    "firm", "soft", "silken", "hard", "crispy", "crunchy", "smooth",
-    "mild", "spicy", "hot", "sweet", "savory", "unsalted", "salted",
-    "low", "high", "reduced", "free", "fat", "sodium", "sugar", "calorie",
-    "dairy", "gluten", "vegan", "plant", "based", "free",
-})
-
 # Maps product-label substrings to recipe-corpus canonical terms.
 # Kept in sync with Store._FTS_SYNONYMS — both must agree on canonical names.
 # Used to expand pantry_set so single-word recipe ingredients can match
@@ -190,56 +155,6 @@ _PANTRY_LABEL_SYNONYMS: dict[str, str] = {
 }
 
 
-# When a pantry item is in a secondary state (e.g. bread → "stale"), expand
-# the pantry set with terms that recipe ingredients commonly use to describe
-# that state.  This lets "stale bread" in a recipe ingredient match a pantry
-# entry that is simply called "Bread" but is past its nominal use-by date.
-# Each key is (category_in_SECONDARY_WINDOW, label_returned_by_secondary_state).
-# Values are additional strings added to the pantry set for FTS coverage.
-_SECONDARY_STATE_SYNONYMS: dict[tuple[str, str], list[str]] = {
-    # ── Existing entries (corrected) ─────────────────────────────────────────
-    ("bread", "stale"):         ["stale bread", "day-old bread", "old bread", "dried bread"],
-    ("bakery", "day-old"):      ["day-old bread", "stale bread", "stale pastry",
-                                  "day-old croissant", "stale croissant", "day-old muffin",
-                                  "stale cake", "old pastry", "day-old baguette"],
-    ("bananas", "overripe"):    ["overripe bananas", "very ripe bananas", "spotty bananas",
-                                  "brown bananas", "black bananas", "mushy bananas",
-                                  "mashed banana", "ripe bananas"],
-    ("milk", "sour"):           ["sour milk", "slightly sour milk", "buttermilk",
-                                  "soured milk", "off milk", "milk gone sour"],
-    ("dairy", "sour"):          ["sour milk", "slightly sour milk", "soured milk"],
-    ("cheese", "rind-ready"):   ["parmesan rind", "cheese rind", "aged cheese",
-                                  "hard cheese rind", "parmigiano rind", "grana padano rind",
-                                  "pecorino rind", "dry cheese"],
-    ("rice", "day-old"):        ["day-old rice", "leftover rice", "cold rice", "cooked rice",
-                                  "old rice"],
-    ("tortillas", "stale"):     ["stale tortillas", "dried tortillas", "day-old tortillas"],
-    # ── New entries ──────────────────────────────────────────────────────────
-    ("apples", "soft"):         ["soft apples", "mealy apples", "overripe apples",
-                                  "bruised apples", "mushy apple"],
-    ("leafy_greens", "wilting"):["wilted spinach", "wilted greens", "limp lettuce",
-                                  "wilted kale", "tired greens"],
-    ("tomatoes", "soft"):       ["overripe tomatoes", "very ripe tomatoes", "ripe tomatoes",
-                                  "soft tomatoes", "bruised tomatoes"],
-    ("cooked_pasta", "day-old"):["leftover pasta", "cooked pasta", "day-old pasta",
-                                  "cold pasta", "pre-cooked pasta"],
-    ("cooked_potatoes", "day-old"): ["leftover potatoes", "cooked potatoes", "day-old potatoes",
-                                      "mashed potatoes", "baked potatoes"],
-    ("yogurt", "tangy"):        ["sour yogurt", "tangy yogurt", "past-date yogurt",
-                                  "older yogurt", "well-cultured yogurt"],
-    ("cream", "sour"):          ["slightly soured cream", "cultured cream",
-                                  "heavy cream gone sour", "soured cream"],
-    ("wine", "open"):           ["open wine", "leftover wine", "day-old wine",
-                                  "cooking wine", "red wine", "white wine"],
-    ("cooked_beans", "day-old"):["leftover beans", "cooked beans", "day-old beans",
-                                  "cold beans", "pre-cooked beans",
-                                  "cooked chickpeas", "cooked lentils"],
-    ("cooked_meat", "leftover"):["leftover chicken", "shredded chicken", "leftover beef",
-                                  "cooked chicken", "pulled chicken", "leftover pork",
-                                  "cooked meat", "rotisserie chicken"],
-}
-
-
 # Matches leading quantity/unit prefixes in recipe ingredient strings,
 # e.g. "2 cups flour" → "flour", "1/2 c. ketchup" → "ketchup",
 #      "3 oz. butter" → "butter"
@@ -369,24 +284,14 @@ def _prep_note_for(ingredient: str) -> str | None:
     return template.format(ingredient=ingredient_name)
 
 
-def _expand_pantry_set(
+def _expand_pantry_set(pantry_items: list[str]) -> set[str]:
-    pantry_items: list[str],
-    secondary_pantry_items: dict[str, str] | None = None,
-) -> set[str]:
     """Return pantry_set expanded with canonical recipe-corpus synonyms.
 
     For each pantry item, checks _PANTRY_LABEL_SYNONYMS for substring matches
     and adds the canonical form.  This lets single-word recipe ingredients
     ("hamburger", "chicken") match product-label pantry entries
     ("burger patties", "rotisserie chicken").
-
-    If secondary_pantry_items is provided (product_name → state label), items
-    in a secondary state also receive state-specific synonym expansion so that
-    recipe ingredients like "stale bread" or "day-old rice" are matched.
     """
-    from app.services.expiration_predictor import ExpirationPredictor
-    _predictor = ExpirationPredictor()
-
     expanded: set[str] = set()
     for item in pantry_items:
         lower = item.lower().strip()
@@ -394,22 +299,6 @@ def _expand_pantry_set(
         for pattern, canonical in _PANTRY_LABEL_SYNONYMS.items():
             if pattern in lower:
                 expanded.add(canonical)
-
-        # Extract individual ingredient tokens from multi-word product names.
-        # "Organic Extra Firm Tofu" → adds "tofu"; "Brown Basmati Rice" → adds "rice".
-        # This catches plain ingredients that _PANTRY_LABEL_SYNONYMS doesn't translate.
-        for token in lower.split():
-            if len(token) >= 4 and token not in _PRODUCT_TOKEN_STOPWORDS:
-                expanded.add(token)
-
-        # Secondary state expansion — adds terms like "stale bread", "day-old rice"
-        if secondary_pantry_items and item in secondary_pantry_items:
-            state_label = secondary_pantry_items[item]
-            category = _predictor.get_category_from_product(item)
-            if category:
-                synonyms = _SECONDARY_STATE_SYNONYMS.get((category, state_label), [])
-                expanded.update(synonyms)
-
     return expanded
 
 
@@ -673,34 +562,6 @@ def _hard_day_sort_tier(
     return 2
 
 
-def _estimate_time_min(directions: list[str], complexity: str) -> int:
-    """Rough cooking time estimate from step count and method complexity.
-
-    Not precise — intended for filtering and display hints only.
-    """
-    steps = len(directions)
-    if complexity == "easy":
-        return max(5, 10 + steps * 3)
-    if complexity == "involved":
-        return max(20, 30 + steps * 6)
-    return max(10, 20 + steps * 4)  # moderate
-
-
-def _within_time(directions: list[str], max_total_min: int) -> bool:
-    """Return True if parsed total time (active + passive) is within max_total_min.
-
-    Graceful degradation:
-    - Empty directions -> True (no data, don't hide)
-    - total_min == 0 (no time signals found) -> True (unparseable, don't hide)
-    """
-    if not directions:
-        return True
-    profile = parse_time_effort(directions)
-    if profile.total_min == 0:
-        return True
-    return profile.total_min <= max_total_min
-
-
 def _classify_method_complexity(
     directions: list[str],
     available_equipment: list[str] | None = None,
@@ -760,8 +621,7 @@ class RecipeEngine:
 
         profiles = self._classifier.classify_batch(req.pantry_items)
         gaps = self._classifier.identify_gaps(profiles)
-        pantry_set = _expand_pantry_set(req.pantry_items, req.secondary_pantry_items or None)
+        pantry_set = _expand_pantry_set(req.pantry_items)
-        exclude_set = _expand_pantry_set(req.exclude_ingredients) if req.exclude_ingredients else set()
 
         if req.level >= 3:
             from app.services.recipe.llm_recipe import LLMRecipeGenerator
@@ -775,13 +635,9 @@ class RecipeEngine:
         #   - match ratio: require ≥60% ingredient coverage to avoid low-signal results
         _l1 = req.level == 1 and not req.shopping_mode
         nf = req.nutrition_filters
-        # L1 uses a larger candidate pool — the ratio gate below will prune
-        # aggressively anyway, so we need more raw candidates to end up with
-        # enough results for a packaged-food / plant-based pantry.
-        _fts_limit = 60 if _l1 else 20
         rows = self._store.search_recipes_by_ingredients(
             req.pantry_items,
-            limit=_fts_limit,
+            limit=20,
             category=req.category or None,
             max_calories=nf.max_calories,
             max_sugar_g=nf.max_sugar_g,
@@ -792,21 +648,14 @@ class RecipeEngine:
         )
 
         # L1 strict defaults: cap missing ingredients and require a minimum ratio.
-        # 0.35 allows ~1/3 ingredient coverage — low enough for packaged/plant-based
-        # pantries that rarely match raw-ingredient corpus recipes 1:1, but still
-        # filters out recipes where only one common staple matched.
         _L1_MAX_MISSING_DEFAULT = 2
-        _L1_MIN_MATCH_RATIO = 0.35
+        _L1_MIN_MATCH_RATIO = 0.6
         effective_max_missing = req.max_missing
         if _l1 and effective_max_missing is None:
             effective_max_missing = _L1_MAX_MISSING_DEFAULT
 
-        # Load sensory preferences -- applied as silent post-score filter
-        _sensory_prefs_json = self._store.get_setting("sensory_preferences")
-        _sensory_exclude = build_sensory_exclude(_sensory_prefs_json)
-
         suggestions = []
-        hard_day_tier_map: dict[int, int] = {}  # recipe_id -> tier when hard_day_mode
+        hard_day_tier_map: dict[int, int] = {}  # recipe_id → tier when hard_day_mode
 
         for row in rows:
             ingredient_names: list[str] = row.get("ingredient_names") or []
@@ -816,15 +665,6 @@ class RecipeEngine:
                 except Exception:
                     ingredient_names = []
 
-            # Skip recipes that require any ingredient the user has excluded.
-            if exclude_set and any(_ingredient_in_pantry(n, exclude_set) for n in ingredient_names):
-                continue
-
-            # Sensory filter -- silent exclusion of recipes exceeding user tolerance
-            if not _sensory_exclude.is_empty():
-                if not passes_sensory_filter(row.get("sensory_tags"), _sensory_exclude):
-                    continue
-
             # Compute missing ingredients, detecting pantry coverage first.
             # When covered, collect any prep-state annotations (e.g. "melted butter"
             # → note "Melt the butter before starting.") to surface separately.
@@ -859,11 +699,6 @@ class RecipeEngine:
             if not req.shopping_mode and effective_max_missing is not None and len(missing) > effective_max_missing:
                 continue
 
-            # "Can make now" toggle: drop any recipe that still has missing ingredients
-            # after swaps are applied. Swapped items count as covered.
-            if req.pantry_match_only and missing:
-                continue
-
             # L1 match ratio gate: drop results where less than 60% of the recipe's
             # ingredients are in the pantry. Prevents low-signal results like a
             # 10-ingredient recipe matching on only one common item.
@@ -872,22 +707,16 @@ class RecipeEngine:
                 if match_ratio < _L1_MIN_MATCH_RATIO:
                     continue
 
-            # Parse directions — needed for complexity, hard_day_mode, and time estimate.
+            # Filter and tier-rank by hard_day_mode
+            if req.hard_day_mode:
                 directions: list[str] = row.get("directions") or []
                 if isinstance(directions, str):
                     try:
                         directions = json.loads(directions)
                     except Exception:
                         directions = [directions]
-
+                complexity = _classify_method_complexity(directions, available_equipment)
-            # Compute complexity + parse time effort once — reused for filters and response.
+                if complexity == "involved":
-            row_complexity = _classify_method_complexity(directions, available_equipment)
-            row_time_min = _estimate_time_min(directions, row_complexity)
-            row_time_effort = parse_time_effort(directions)
-
-            # Filter and tier-rank by hard_day_mode
-            if req.hard_day_mode:
-                if row_complexity == "involved":
                     continue
                 hard_day_tier_map[row["id"]] = _hard_day_sort_tier(
                     title=row.get("title", ""),
@@ -895,25 +724,6 @@ class RecipeEngine:
                     directions=directions,
                 )
 
-            # Complexity filter (#58)
-            if req.complexity_filter and row_complexity != req.complexity_filter:
-                continue
-
-            # Max time filter (#58)
-            if req.max_time_min is not None and row_time_min > req.max_time_min:
-                continue
-
-            # Total time filter (kiwi#52).
-            # Prefer parsed time extracted from direction text (explicit "15 minutes" mentions).
-            # When directions contain no parseable time signals, fall back to the
-            # step-count estimate so the filter still has teeth on the corpus majority.
-            if req.max_total_min is not None:
-                if row_time_effort.total_min > 0:
-                    if row_time_effort.total_min > req.max_total_min:
-                        continue
-                elif row_time_min > req.max_total_min:
-                    continue
-
             # Level 2: also add dietary constraint swaps from substitution_pairs
             if req.level == 2 and req.constraints:
                 for ing in ingredient_names:
@@ -951,20 +761,6 @@ class RecipeEngine:
                 v is not None
                 for v in (nutrition.calories, nutrition.sugar_g, nutrition.carbs_g)
             )
-            te = TimeEffortProfile(
-                active_min=row_time_effort.active_min,
-                passive_min=row_time_effort.passive_min,
-                total_min=row_time_effort.total_min,
-                effort_label=row_time_effort.effort_label,
-                equipment=list(row_time_effort.equipment),
-                step_analyses=[
-                    StepAnalysis(
-                        is_passive=sa.is_passive,
-                        detected_minutes=sa.detected_minutes,
-                    )
-                    for sa in row_time_effort.step_analyses
-                ],
-            )
             suggestions.append(RecipeSuggestion(
                 id=row["id"],
                 title=row["title"],
@@ -973,31 +769,17 @@ class RecipeEngine:
                 swap_candidates=swap_candidates,
                 matched_ingredients=matched,
                 missing_ingredients=missing,
-                directions=directions,
                 prep_notes=sorted(prep_note_set),
                 level=req.level,
                 nutrition=nutrition if has_nutrition else None,
                 source_url=_build_source_url(row),
-                complexity=row_complexity,
-                estimated_time_min=row_time_min,
-                time_effort=te,
             ))
 
-        # Sort corpus results.
+        # Sort corpus results — assembly templates are now served from a dedicated tab.
-        # Paid+ tier: cross-encoder reranker orders by full pantry + dietary fit.
+        # Hard day mode: primary sort by tier (0=premade, 1=simple, 2=moderate),
-        # Free tier (or reranker failure): overlap sort with hard_day_mode tier grouping.
+        # then by match_count within each tier.
-        reranked = rerank_suggestions(req, suggestions)
+        # Normal mode: sort by match_count descending.
-        if reranked is not None:
-            # Reranker provided relevance order. In hard_day_mode, still respect
-            # tier grouping as primary sort; reranker order applies within each tier.
         if req.hard_day_mode and hard_day_tier_map:
-                suggestions = sorted(
-                    reranked,
-                    key=lambda s: hard_day_tier_map.get(s.id, 1),
-                )
-            else:
-                suggestions = reranked
-        elif req.hard_day_mode and hard_day_tier_map:
             suggestions = sorted(
                 suggestions,
                 key=lambda s: (hard_day_tier_map.get(s.id, 1), -s.match_count),

app/services/recipe/reranker.py

@@ -1,175 +0,0 @@
-"""
-Reranker integration for recipe suggestions.
-
-Wraps circuitforge_core.reranker to score recipe candidates against a
-natural-language query built from the user's pantry, constraints, and
-preferences. Paid+ tier only; free tier returns None (caller keeps
-existing sort). All exceptions are caught and logged — the reranker
-must never break recipe suggestions.
-
-Environment:
-    CF_RERANKER_MOCK=1  — force mock backend (tests, no model required)
-"""
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass, field
-
-from app.models.schemas.recipe import RecipeRequest, RecipeSuggestion
-
-log = logging.getLogger(__name__)
-
-# Tiers that get reranker access.
-_RERANKER_TIERS: frozenset[str] = frozenset({"paid", "premium", "local"})
-
-# Minimum candidates worth reranking — below this the cross-encoder
-# overhead is not justified and the overlap sort is fine.
-_MIN_CANDIDATES: int = 3
-
-
-@dataclass(frozen=True)
-class RerankerInput:
-    """Intermediate representation passed to the reranker."""
-    query: str
-    candidates: list[str]
-    suggestion_ids: list[int]  # parallel to candidates, for re-mapping
-
-
-# ── Query builder ─────────────────────────────────────────────────────────────
-
-def build_query(req: RecipeRequest) -> str:
-    """Build a natural-language query string from the recipe request.
-
-    Encodes the user's full context so the cross-encoder can score
-    relevance, dietary fit, and expiry urgency in a single pass.
-    Only non-empty segments are included.
-    """
-    parts: list[str] = []
-
-    if req.pantry_items:
-        parts.append(f"Recipe using: {', '.join(req.pantry_items)}")
-
-    if req.exclude_ingredients:
-        parts.append(f"Avoid: {', '.join(req.exclude_ingredients)}")
-
-    if req.allergies:
-        parts.append(f"Allergies: {', '.join(req.allergies)}")
-
-    if req.constraints:
-        parts.append(f"Dietary: {', '.join(req.constraints)}")
-
-    if req.category:
-        parts.append(f"Category: {req.category}")
-
-    if req.style_id:
-        parts.append(f"Style: {req.style_id}")
-
-    if req.complexity_filter:
-        parts.append(f"Prefer: {req.complexity_filter}")
-
-    if req.hard_day_mode:
-        parts.append("Prefer: easy, minimal effort")
-
-    # Secondary pantry items carry a state label (e.g. "stale", "overripe")
-    # that helps the reranker favour recipes suited to those specific states.
-    if req.secondary_pantry_items:
-        expiry_parts = [f"{name} ({state})" for name, state in req.secondary_pantry_items.items()]
-        parts.append(f"Use soon: {', '.join(expiry_parts)}")
-    elif req.expiry_first:
-        parts.append("Prefer: recipes that use expiring items first")
-
-    return ". ".join(parts) + "." if parts else "Recipe."
-
-
-# ── Candidate builder ─────────────────────────────────────────────────────────
-
-def build_candidate_string(suggestion: RecipeSuggestion) -> str:
-    """Build a candidate string for a single recipe suggestion.
-
-    Format: "{title}. Ingredients: {comma-joined ingredients}"
-    Matched ingredients appear before missing ones.
-    Directions excluded to stay within BGE's 512-token window.
-    """
-    ingredients = suggestion.matched_ingredients + suggestion.missing_ingredients
-    if not ingredients:
-        return suggestion.title
-    return f"{suggestion.title}. Ingredients: {', '.join(ingredients)}"
-
-
-# ── Input assembler ───────────────────────────────────────────────────────────
-
-def build_reranker_input(
-    req: RecipeRequest,
-    suggestions: list[RecipeSuggestion],
-) -> RerankerInput:
-    """Assemble query and candidate strings for the reranker."""
-    query = build_query(req)
-    candidates: list[str] = []
-    ids: list[int] = []
-    for s in suggestions:
-        candidates.append(build_candidate_string(s))
-        ids.append(s.id)
-    return RerankerInput(query=query, candidates=candidates, suggestion_ids=ids)
-
-
-# ── cf-core seam (isolated for monkeypatching in tests) ──────────────────────
-
-def _do_rerank(query: str, candidates: list[str], top_n: int = 0):
-    """Thin wrapper around cf-core rerank(). Extracted so tests can patch it."""
-    from circuitforge_core.reranker import rerank
-    return rerank(query, candidates, top_n=top_n)
-
-
-# ── Public entry point ────────────────────────────────────────────────────────
-
-def rerank_suggestions(
-    req: RecipeRequest,
-    suggestions: list[RecipeSuggestion],
-) -> list[RecipeSuggestion] | None:
-    """Rerank suggestions using the cf-core cross-encoder.
-
-    Returns a reordered list with rerank_score populated, or None when:
-    - Tier is not paid+ (free tier keeps overlap sort)
-    - Fewer than _MIN_CANDIDATES suggestions (not worth the overhead)
-    - Any exception is raised (graceful fallback to existing sort)
-
-    The caller should treat None as "keep existing sort order".
-    Original suggestions are never mutated.
-    """
-    if req.tier not in _RERANKER_TIERS:
-        return None
-
-    if len(suggestions) < _MIN_CANDIDATES:
-        return None
-
-    try:
-        rinput = build_reranker_input(req, suggestions)
-        results = _do_rerank(rinput.query, rinput.candidates, top_n=0)
-
-        # Map reranked results back to RecipeSuggestion objects using the
-        # candidate string as key (build_candidate_string is deterministic).
-        candidate_map: dict[str, RecipeSuggestion] = {
-            build_candidate_string(s): s for s in suggestions
-        }
-
-        reranked: list[RecipeSuggestion] = []
-        for rr in results:
-            suggestion = candidate_map.get(rr.candidate)
-            if suggestion is not None:
-                reranked.append(suggestion.model_copy(
-                    update={"rerank_score": round(float(rr.score), 4)}
-                ))
-
-        if len(reranked) < len(suggestions):
-            log.warning(
-                "Reranker lost %d/%d suggestions during mapping, falling back",
-                len(suggestions) - len(reranked),
-                len(suggestions),
-            )
-            return None
-
-        return reranked
-
-    except Exception:
-        log.exception("Reranker failed, falling back to overlap sort")
-        return None

app/services/recipe/sensory.py

@@ -1,133 +0,0 @@
-"""
-Sensory filter dataclass and helpers.
-
-SensoryExclude bridges user preferences (from user_settings) to the
-store browse methods and recipe engine suggest flow.
-
-Recipes with sensory_tags = '{}' (untagged) pass ALL filters --
-graceful degradation when tag_sensory_profiles.py has not run.
-"""
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass, field
-
-_SMELL_LEVELS: tuple[str, ...] = ("mild", "aromatic", "pungent", "fermented")
-_NOISE_LEVELS: tuple[str, ...] = ("quiet", "moderate", "loud", "very_loud")
-
-
-@dataclass(frozen=True)
-class SensoryExclude:
-    """Derived filter criteria from user sensory preferences.
-
-    textures:    texture tags to exclude (empty tuple = no texture filter)
-    smell_above: if set, exclude recipes whose smell level is strictly above
-                 this level in the smell spectrum
-    noise_above: if set, exclude recipes whose noise level is strictly above
-                 this level in the noise spectrum
-    """
-    textures: tuple[str, ...] = field(default_factory=tuple)
-    smell_above: str | None = None
-    noise_above: str | None = None
-
-    @classmethod
-    def empty(cls) -> "SensoryExclude":
-        """No filtering -- pass-through for users with no preferences set."""
-        return cls()
-
-    def is_empty(self) -> bool:
-        """True when no filtering will be applied."""
-        return not self.textures and self.smell_above is None and self.noise_above is None
-
-
-def build_sensory_exclude(prefs_json: str | None) -> SensoryExclude:
-    """Parse user_settings value for 'sensory_preferences' into a SensoryExclude.
-
-    Expected JSON shape:
-      {
-        "avoid_textures": ["mushy", "slimy"],
-        "max_smell":      "pungent",
-        "max_noise":      "loud"
-      }
-
-    Returns SensoryExclude.empty() on missing, null, or malformed input.
-    """
-    if not prefs_json:
-        return SensoryExclude.empty()
-    try:
-        prefs = json.loads(prefs_json)
-    except (json.JSONDecodeError, TypeError):
-        return SensoryExclude.empty()
-    if not isinstance(prefs, dict):
-        return SensoryExclude.empty()
-
-    avoid_textures = tuple(
-        t for t in (prefs.get("avoid_textures") or [])
-        if isinstance(t, str)
-    )
-    max_smell: str | None = prefs.get("max_smell") or None
-    max_noise: str | None = prefs.get("max_noise") or None
-
-    if max_smell and max_smell not in _SMELL_LEVELS:
-        max_smell = None
-    if max_noise and max_noise not in _NOISE_LEVELS:
-        max_noise = None
-
-    return SensoryExclude(
-        textures=avoid_textures,
-        smell_above=max_smell,
-        noise_above=max_noise,
-    )
-
-
-def passes_sensory_filter(
-    sensory_tags_raw: str | dict | None,
-    exclude: SensoryExclude,
-) -> bool:
-    """Return True if the recipe passes the sensory exclude criteria.
-
-    sensory_tags_raw: the sensory_tags column value (JSON string or already-parsed dict).
-    exclude:          derived filter criteria.
-
-    Untagged recipes (empty dict or '{}') always pass -- graceful degradation.
-    Empty SensoryExclude always passes -- no preferences set.
-    """
-    if exclude.is_empty():
-        return True
-
-    if sensory_tags_raw is None:
-        return True
-    if isinstance(sensory_tags_raw, str):
-        try:
-            tags: dict = json.loads(sensory_tags_raw)
-        except (json.JSONDecodeError, TypeError):
-            return True
-    else:
-        tags = sensory_tags_raw
-
-    if not tags:
-        return True
-
-    if exclude.textures:
-        recipe_textures: list[str] = tags.get("textures") or []
-        for t in recipe_textures:
-            if t in exclude.textures:
-                return False
-
-    if exclude.smell_above is not None:
-        recipe_smell: str | None = tags.get("smell")
-        if recipe_smell and recipe_smell in _SMELL_LEVELS:
-            max_idx = _SMELL_LEVELS.index(exclude.smell_above)
-            recipe_idx = _SMELL_LEVELS.index(recipe_smell)
-            if recipe_idx > max_idx:
-                return False
-
-    if exclude.noise_above is not None:
-        recipe_noise: str | None = tags.get("noise")
-        if recipe_noise and recipe_noise in _NOISE_LEVELS:
-            max_idx = _NOISE_LEVELS.index(exclude.noise_above)
-            recipe_idx = _NOISE_LEVELS.index(recipe_noise)
-            if recipe_idx > max_idx:
-                return False
-
-    return True

app/services/recipe/style_classifier.py

@@ -1,139 +0,0 @@
-# app/services/recipe/style_classifier.py
-# BSL 1.1 — LLM feature
-"""LLM style-tag classifier for saved recipes.
-
-Reads recipe title, ingredients, and directions and suggests 3–5 style tags
-from the curated vocabulary shared with SaveRecipeModal.vue.
-
-Cloud (CF_ORCH_URL set): allocates a cf-text service via cf-orch (2 GB VRAM).
-Local: falls back to LLMRouter (ollama / vllm / openai-compat).
-"""
-from __future__ import annotations
-
-import json
-import logging
-import os
-import re
-from contextlib import nullcontext
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-_SERVICE_TYPE = "cf-text"
-_TTL_S = 60.0
-_CALLER = "kiwi-style-classify"
-
-# Canonical vocabulary — must stay in sync with SUGGESTED_TAGS in SaveRecipeModal.vue.
-STYLE_TAG_VOCAB: frozenset[str] = frozenset({
-    "comforting", "light", "spicy", "umami", "sweet", "savory", "rich",
-    "crispy", "creamy", "hearty", "quick", "hands-off", "meal-prep-friendly",
-    "fancy", "one-pot",
-})
-
-_SYSTEM_PROMPT = """\
-You are a culinary tagger. Given a recipe, suggest 3 to 5 style tags that best \
-describe its character. You MUST only use tags from this list:
-
-comforting, light, spicy, umami, sweet, savory, rich, crispy, creamy, hearty, \
-quick, hands-off, meal-prep-friendly, fancy, one-pot
-
-Return ONLY a JSON array of strings, no explanation. Example:
-["comforting", "hearty", "one-pot"]
-"""
-
-
-def _build_router():
-    """Return (router, context_manager) for style classify tasks.
-
-    Tries cf-orch cf-text allocation first; falls back to LLMRouter.
-    Returns (None, nullcontext) if no backend is available.
-    """
-    cf_orch_url = os.environ.get("CF_ORCH_URL")
-    if cf_orch_url:
-        try:
-            from app.services.meal_plan.llm_router import _OrchTextRouter  # reuse adapter
-            from circuitforge_orch.client import CFOrchClient
-            client = CFOrchClient(cf_orch_url)
-            ctx = client.allocate(service=_SERVICE_TYPE, ttl_s=_TTL_S, caller=_CALLER)
-            alloc = ctx.__enter__()
-            if alloc is not None:
-                return _OrchTextRouter(alloc.url), ctx
-        except Exception as exc:
-            logger.debug("cf-orch allocation failed for style classify, falling back: %s", exc)
-
-    try:
-        from circuitforge_core.llm.router import LLMRouter
-        return LLMRouter(), nullcontext(None)
-    except FileNotFoundError:
-        logger.debug("LLMRouter: no llm.yaml — style classifier LLM disabled")
-        return None, nullcontext(None)
-    except Exception as exc:
-        logger.debug("LLMRouter init failed: %s", exc)
-        return None, nullcontext(None)
-
-
-def _parse_tags(raw: str) -> list[str]:
-    """Extract valid vocab tags from raw LLM output.
-
-    Tries JSON parse first; falls back to extracting any vocab word present
-    in the response text so minor formatting deviations still work.
-    """
-    # Strip markdown fences
-    raw = re.sub(r"```[a-z]*", "", raw).strip()
-    try:
-        parsed = json.loads(raw)
-        if isinstance(parsed, list):
-            return [t for t in parsed if isinstance(t, str) and t in STYLE_TAG_VOCAB][:5]
-    except (json.JSONDecodeError, ValueError):
-        pass
-
-    # Fallback: scan for vocab words
-    found = [t for t in STYLE_TAG_VOCAB if re.search(rf"\b{re.escape(t)}\b", raw, re.IGNORECASE)]
-    return sorted(found, key=lambda t: raw.lower().index(t.lower()))[:5]
-
-
-def classify_style(recipe: dict[str, Any]) -> list[str]:
-    """Return 3–5 suggested style tags for *recipe*.
-
-    *recipe* is a Store row dict with at least ``title``, ``ingredient_names``
-    (list[str]), and ``directions`` (list[str] or str).
-
-    Returns an empty list if no LLM backend is available.
-    """
-    router, ctx = _build_router()
-    if router is None:
-        return []
-
-    title = recipe.get("title") or "Unknown"
-    ingredients = recipe.get("ingredient_names") or []
-    if isinstance(ingredients, str):
-        try:
-            ingredients = json.loads(ingredients)
-        except Exception:
-            ingredients = [ingredients]
-
-    directions = recipe.get("directions") or []
-    if isinstance(directions, str):
-        try:
-            directions = json.loads(directions)
-        except Exception:
-            directions = [directions]
-
-    user_prompt = (
-        f"Recipe: {title}\n"
-        f"Ingredients: {', '.join(str(i) for i in ingredients[:20])}\n"
-        f"Steps: {' '.join(str(d) for d in directions[:8])[:600]}"
-    )
-
-    try:
-        with ctx:
-            raw = router.complete(
-                system=_SYSTEM_PROMPT,
-                user=user_prompt,
-                max_tokens=64,
-                temperature=0.3,
-            )
-        return _parse_tags(raw)
-    except Exception as exc:
-        logger.warning("Style classifier LLM call failed: %s", exc)
-        return []

app/services/recipe/substitution_engine.py

@@ -55,12 +55,11 @@ class SubstitutionEngine:
         ingredient_name: str,
         constraint: str,
     ) -> list[SubstitutionSwap]:
-        c = self._store._cp
+        rows = self._store._fetch_all("""
-        rows = self._store._fetch_all(f"""
             SELECT substitute_name, constraint_label,
                    fat_delta, moisture_delta, glutamate_delta, protein_delta,
                    occurrence_count, compensation_hints
-            FROM {c}substitution_pairs
+            FROM substitution_pairs
             WHERE original_name = ? AND constraint_label = ?
             ORDER BY occurrence_count DESC
         """, (ingredient_name.lower(), constraint))

app/services/recipe/tag_inferrer.py

@@ -68,15 +68,6 @@ _CUISINE_SIGNALS: list[tuple[str, list[str]]] = [
     ("cuisine:Cajun",          ["cajun", "creole", "gumbo", "jambalaya", "andouille", "etouffee"]),
     ("cuisine:African",        ["injera", "berbere", "jollof", "suya", "egusi", "fufu", "tagine"]),
     ("cuisine:Caribbean",      ["jerk", "scotch bonnet", "callaloo", "ackee"]),
-    # BBQ detection: match on title terms and key ingredients; these rarely appear
-    # in food.com's own keyword/category taxonomy so we derive the tag from content.
-    ("cuisine:BBQ",            ["brisket", "pulled pork", "spare ribs", "baby back ribs",
-                                 "baby back", "burnt ends", "pit smoked", "smoke ring",
-                                 "low and slow", "hickory", "mesquite", "liquid smoke",
-                                 "bbq brisket", "smoked brisket", "barbecue brisket",
-                                 "carolina bbq", "texas bbq", "kansas city bbq",
-                                 "memphis bbq", "smoked ribs", "smoked pulled pork",
-                                 "dry rub ribs", "wet rub ribs", "beer can chicken smoked"]),
 ]
 
 _DIETARY_SIGNALS: list[tuple[str, list[str]]] = [
@@ -121,21 +112,6 @@ _TIME_SIGNALS: list[tuple[str, list[str]]] = [
     ("time:Slow Cook",    ["slow cooker", "crockpot", "< 4 hours", "braise"]),
 ]
 
-_MAIN_INGREDIENT_SIGNALS: list[tuple[str, list[str]]] = [
-    ("main:Chicken",    ["chicken", "poultry", "turkey"]),
-    ("main:Beef",       ["beef", "ground beef", "steak", "brisket", "pot roast"]),
-    ("main:Pork",       ["pork", "bacon", "ham", "sausage", "prosciutto"]),
-    ("main:Fish",       ["salmon", "tuna", "tilapia", "cod", "halibut", "shrimp", "seafood", "fish"]),
-    ("main:Pasta",      ["pasta", "noodle", "spaghetti", "penne", "fettuccine", "linguine"]),
-    ("main:Vegetables", ["broccoli", "cauliflower", "zucchini", "eggplant", "carrot",
-                          "vegetable", "veggie"]),
-    ("main:Eggs",       ["egg", "frittata", "omelette", "omelet", "quiche"]),
-    ("main:Legumes",    ["bean", "lentil", "chickpea", "tofu", "tempeh", "edamame"]),
-    ("main:Grains",     ["rice", "quinoa", "barley", "farro", "oat", "grain"]),
-    ("main:Cheese",     ["cheddar", "mozzarella", "parmesan", "ricotta", "brie",
-                          "cheese"]),
-]
-
 # food.com corpus tag -> normalized tags
 _CORPUS_TAG_MAP: dict[str, list[str]] = {
     "european":        ["cuisine:Italian", "cuisine:French", "cuisine:German",
@@ -256,7 +232,6 @@ def infer_tags(
     tags.update(_match_signals(text, _CUISINE_SIGNALS))
     tags.update(_match_signals(text, _DIETARY_SIGNALS))
     tags.update(_match_signals(text, _FLAVOR_SIGNALS))
-    tags.update(_match_signals(text, _MAIN_INGREDIENT_SIGNALS))
 
     # 3. Time signals from corpus keywords + text
     corpus_text = " ".join(kw.lower() for kw in corpus_keywords)

app/services/recipe/time_effort.py

@@ -1,197 +0,0 @@
-"""
-Runtime parser for active/passive time split and equipment detection.
-
-Operates over a list of direction strings. No I/O — pure Python functions.
-Sub-millisecond for up to 20 recipes (20 × ~10 steps each = 200 regex calls).
-"""
-from __future__ import annotations
-
-import math
-import re
-from dataclasses import dataclass
-from typing import Final
-
-# ── Passive step keywords (whole-word, case-insensitive) ──────────────────
-
-_PASSIVE_PATTERNS: Final[list[str]] = [
-    "simmer", "bake", "roast", "broil", "refrigerate", "marinate",
-    "chill", "cool", "freeze", "rest", "stand", "set", "soak",
-    "steep", "proof", "rise", "let", "wait", "overnight", "braise",
-    r"slow\s+cook", r"pressure\s+cook",
-]
-
-# Pre-compiled as a single alternation — avoids re-compiling on every call.
-_PASSIVE_RE: re.Pattern[str] = re.compile(
-    r"\b(?:" + "|".join(_PASSIVE_PATTERNS) + r")\b",
-    re.IGNORECASE,
-)
-
-# ── Time extraction regex ─────────────────────────────────────────────────
-
-# Two-branch pattern:
-#   Branch A (groups 1-3): range  "15-20 minutes", "15–20 min"
-#   Branch B (groups 4-5): single "10 minutes", "2 hours", "30 sec"
-#
-# Separator characters: plain hyphen (-), en-dash (–), or literal "-to-"
-_TIME_RE: re.Pattern[str] = re.compile(
-    r"(\d+)\s*(?:[-\u2013]|-to-)\s*(\d+)\s*(hour|hr|minute|min|second|sec)s?"
-    r"|"
-    r"(\d+)\s*(hour|hr|minute|min|second|sec)s?",
-    re.IGNORECASE,
-)
-
-_MAX_MINUTES_PER_STEP: Final[int] = 480  # 8 hours sanity cap
-
-# ── Equipment detection (keyword → label, in detection priority order) ────
-
-_EQUIPMENT_RULES: Final[list[tuple[re.Pattern[str], str]]] = [
-    (re.compile(r"\b(?:chop|dice|mince|slice|julienne)\b", re.IGNORECASE), "Knife"),
-    (re.compile(r"\b(?:skillet|sauté|saute|fry|sear|pan-fry|pan fry)\b", re.IGNORECASE), "Skillet"),
-    (re.compile(r"\b(?:wooden spoon|spatula|stir|fold)\b", re.IGNORECASE), "Spoon"),
-    (re.compile(r"\b(?:pot|boil|simmer|blanch|stock)\b", re.IGNORECASE), "Pot"),
-    (re.compile(r"\b(?:oven|bake|roast|preheat|broil)\b", re.IGNORECASE), "Oven"),
-    (re.compile(r"\b(?:blender|blend|purée|puree|food processor)\b", re.IGNORECASE), "Blender"),
-    (re.compile(r"\b(?:stand mixer|hand mixer|whip|beat)\b", re.IGNORECASE), "Mixer"),
-    (re.compile(r"\b(?:grill|barbecue|char|griddle)\b", re.IGNORECASE), "Grill"),
-    (re.compile(r"\b(?:slow cooker|crockpot|low and slow)\b", re.IGNORECASE), "Slow cooker"),
-    (re.compile(r"\b(?:pressure cooker|instant pot)\b", re.IGNORECASE), "Pressure cooker"),
-    (re.compile(r"\b(?:drain|strain|colander|rinse pasta)\b", re.IGNORECASE), "Colander"),
-]
-
-# ── Dataclasses ───────────────────────────────────────────────────────────
-
-
-@dataclass(frozen=True)
-class StepAnalysis:
-    """Analysis result for a single direction step."""
-    is_passive: bool
-    detected_minutes: int | None  # None when no time mention found in text
-
-
-@dataclass(frozen=True)
-class TimeEffortProfile:
-    """Aggregated time and effort profile for a full recipe."""
-    active_min: int                    # total minutes requiring active attention
-    passive_min: int                   # total minutes the cook can step away
-    total_min: int                     # active_min + passive_min
-    step_analyses: list[StepAnalysis]  # one entry per direction step
-    equipment: list[str]               # ordered, deduplicated equipment labels
-    effort_label: str                  # "quick" | "moderate" | "involved"
-
-
-# ── Core parsing logic ────────────────────────────────────────────────────
-
-
-def _extract_minutes(text: str) -> int | None:
-    """Return the number of minutes mentioned in text, or None.
-
-    Range values (e.g. "15-20 minutes") return the integer midpoint.
-    Hours are converted to minutes. Seconds are rounded up to 1 minute minimum.
-    Result is capped at _MAX_MINUTES_PER_STEP.
-    """
-    m = _TIME_RE.search(text)
-    if m is None:
-        return None
-
-    if m.group(1) is not None:
-        # Branch A: range match (e.g. "15-20 minutes")
-        low = int(m.group(1))
-        high = int(m.group(2))
-        unit = m.group(3).lower()
-        raw_value: float = (low + high) / 2
-    else:
-        # Branch B: single value match (e.g. "10 minutes")
-        low = int(m.group(4))
-        unit = m.group(5).lower()
-        raw_value = float(low)
-
-    if unit in ("hour", "hr"):
-        minutes: float = raw_value * 60
-    elif unit in ("second", "sec"):
-        minutes = max(1.0, math.ceil(raw_value / 60))
-    else:
-        minutes = raw_value
-
-    return min(int(minutes), _MAX_MINUTES_PER_STEP)
-
-
-def _classify_passive(text: str) -> bool:
-    """Return True if the step text matches any passive keyword (whole-word)."""
-    return _PASSIVE_RE.search(text) is not None
-
-
-def _detect_equipment(all_text: str, has_passive: bool) -> list[str]:
-    """Return ordered, deduplicated list of equipment labels detected in text.
-
-    all_text should be all direction steps joined with spaces.
-    has_passive controls whether 'Timer' is appended at the end.
-    """
-    seen: set[str] = set()
-    result: list[str] = []
-    for pattern, label in _EQUIPMENT_RULES:
-        if label not in seen and pattern.search(all_text):
-            seen.add(label)
-            result.append(label)
-    if has_passive and "Timer" not in seen:
-        result.append("Timer")
-    return result
-
-
-def _effort_label(step_count: int) -> str:
-    """Derive effort label from step count."""
-    if step_count <= 3:
-        return "quick"
-    if step_count <= 7:
-        return "moderate"
-    return "involved"
-
-
-def parse_time_effort(directions: list[str]) -> TimeEffortProfile:
-    """Parse a list of direction strings into a TimeEffortProfile.
-
-    Returns a zero-value profile with empty lists when directions is empty.
-    Never raises — all failures silently produce sensible defaults.
-    """
-    if not directions:
-        return TimeEffortProfile(
-            active_min=0,
-            passive_min=0,
-            total_min=0,
-            step_analyses=[],
-            equipment=[],
-            effort_label="quick",
-        )
-
-    step_analyses: list[StepAnalysis] = []
-    active_min = 0
-    passive_min = 0
-    has_any_passive = False
-
-    for step in directions:
-        is_passive = _classify_passive(step)
-        detected = _extract_minutes(step)
-
-        if is_passive:
-            has_any_passive = True
-            if detected is not None:
-                passive_min += detected
-        else:
-            if detected is not None:
-                active_min += detected
-
-        step_analyses.append(StepAnalysis(
-            is_passive=is_passive,
-            detected_minutes=detected,
-        ))
-
-    combined_text = " ".join(directions)
-    equipment = _detect_equipment(combined_text, has_any_passive)
-
-    return TimeEffortProfile(
-        active_min=active_min,
-        passive_min=passive_min,
-        total_min=active_min + passive_min,
-        step_analyses=step_analyses,
-        equipment=equipment,
-        effort_label=_effort_label(len(directions)),
-    )

app/tasks/runner.py

@@ -22,7 +22,7 @@ from app.services.expiration_predictor import ExpirationPredictor
 
 log = logging.getLogger(__name__)
 
-LLM_TASK_TYPES: frozenset[str] = frozenset({"expiry_llm_fallback", "recipe_llm"})
+LLM_TASK_TYPES: frozenset[str] = frozenset({"expiry_llm_fallback"})
 
 VRAM_BUDGETS: dict[str, float] = {
     # ExpirationPredictor uses a small LLM (16 tokens out, single pass).
@@ -88,8 +88,6 @@ def run_task(
     try:
         if task_type == "expiry_llm_fallback":
             _run_expiry_llm_fallback(db_path, job_id, params)
-        elif task_type == "recipe_llm":
-            _run_recipe_llm(db_path, job_id, params)
         else:
             raise ValueError(f"Unknown kiwi task type: {task_type!r}")
         _update_task_status(db_path, task_id, "completed")
@@ -145,41 +143,3 @@ def _run_expiry_llm_fallback(
         expiry,
         days,
     )
-
-
-def _run_recipe_llm(db_path: Path, _job_id_int: int, params: str | None) -> None:
-    """Run LLM recipe generation for an async recipe job.
-
-    params JSON keys:
-        job_id  (required) — recipe_jobs.job_id string (e.g. "rec_a1b2c3...")
-
-    Creates its own Store — follows same pattern as _suggest_in_thread.
-    MUST call store.fail_recipe_job() before re-raising so recipe_jobs.status
-    doesn't stay 'running' while background_tasks shows 'failed'.
-    """
-    from app.db.store import Store
-    from app.models.schemas.recipe import RecipeRequest
-    from app.services.recipe.recipe_engine import RecipeEngine
-
-    p = json.loads(params or "{}")
-    recipe_job_id: str = p.get("job_id", "")
-    if not recipe_job_id:
-        raise ValueError("recipe_llm: 'job_id' is required in params")
-
-    store = Store(db_path)
-    try:
-        store.update_recipe_job_running(recipe_job_id)
-        row = store._fetch_one(
-            "SELECT request FROM recipe_jobs WHERE job_id=?", (recipe_job_id,)
-        )
-        if row is None:
-            raise ValueError(f"recipe_llm: recipe_jobs row not found: {recipe_job_id!r}")
-        req = RecipeRequest.model_validate_json(row["request"])
-        result = RecipeEngine(store).suggest(req)
-        store.complete_recipe_job(recipe_job_id, result.model_dump_json())
-        log.info("recipe_llm: job %s completed (%d suggestion(s))", recipe_job_id, len(result.suggestions))
-    except Exception as exc:
-        store.fail_recipe_job(recipe_job_id, str(exc))
-        raise
-    finally:
-        store.close()

app/tasks/scheduler.py

@@ -1,10 +1,5 @@
 # app/tasks/scheduler.py
-"""Kiwi LLM task scheduler — thin shim over circuitforge_core.tasks.scheduler.
+"""Kiwi LLM task scheduler — thin shim over circuitforge_core.tasks.scheduler."""
-
-Local mode (CLOUD_MODE unset): LocalScheduler — simple FIFO, no coordinator.
-Cloud mode (CLOUD_MODE=true): OrchestratedScheduler — coordinator-aware, fans
-out concurrent jobs across all registered cf-orch GPU nodes.
-"""
 from __future__ import annotations
 
 from pathlib import Path
@@ -12,68 +7,15 @@ from pathlib import Path
 from circuitforge_core.tasks.scheduler import (
     TaskScheduler,
     get_scheduler as _base_get_scheduler,
-    reset_scheduler as _reset_local,  # re-export for tests
+    reset_scheduler,  # re-export for tests
 )
 
-from app.cloud_session import CLOUD_MODE
 from app.core.config import settings
 from app.tasks.runner import LLM_TASK_TYPES, VRAM_BUDGETS, run_task
 
 
-def _orch_available() -> bool:
-    """Return True if circuitforge_orch is installed in this environment."""
-    try:
-        import circuitforge_orch  # noqa: F401
-        return True
-    except ImportError:
-        return False
-
-
-def _use_orch() -> bool:
-    """Return True if the OrchestratedScheduler should be used.
-
-    Priority order:
-      1. USE_ORCH_SCHEDULER env var — explicit override always wins.
-      2. CLOUD_MODE=true — use orch in managed cloud deployments.
-      3. circuitforge_orch installed — paid+ local users who have cf-orch
-         set up get coordinator-aware scheduling (local GPU first) automatically.
-    """
-    override = settings.USE_ORCH_SCHEDULER
-    if override is not None:
-        return override
-    return CLOUD_MODE or _orch_available()
-
-
 def get_scheduler(db_path: Path) -> TaskScheduler:
-    """Return the process-level TaskScheduler singleton for Kiwi.
+    """Return the process-level TaskScheduler singleton for Kiwi."""
-
-    OrchestratedScheduler: coordinator-aware, fans out concurrent jobs across
-    all registered cf-orch GPU nodes. Active when USE_ORCH_SCHEDULER=true,
-    CLOUD_MODE=true, or circuitforge_orch is installed locally (paid+ users
-    running their own cf-orch stack get this automatically; local GPU is
-    preferred by the coordinator's allocation queue).
-
-    LocalScheduler: serial FIFO, no coordinator dependency. Free-tier local
-    installs without circuitforge_orch installed use this automatically.
-    """
-    if _use_orch():
-        try:
-            from circuitforge_orch.scheduler import get_orch_scheduler
-        except ImportError:
-            import logging
-            logging.getLogger(__name__).warning(
-                "circuitforge_orch not installed — falling back to LocalScheduler"
-            )
-        else:
-            return get_orch_scheduler(
-                db_path=db_path,
-                run_task_fn=run_task,
-                task_types=LLM_TASK_TYPES,
-                vram_budgets=VRAM_BUDGETS,
-                coordinator_url=settings.COORDINATOR_URL,
-                service_name="kiwi",
-            )
-
     return _base_get_scheduler(
         db_path=db_path,
         run_task_fn=run_task,
@@ -82,15 +24,3 @@ def get_scheduler(db_path: Path) -> TaskScheduler:
         coordinator_url=settings.COORDINATOR_URL,
         service_name="kiwi",
     )
-
-
-def reset_scheduler() -> None:
-    """Shut down and clear the active scheduler singleton. TEST TEARDOWN ONLY."""
-    if _use_orch():
-        try:
-            from circuitforge_orch.scheduler import reset_orch_scheduler
-            reset_orch_scheduler()
-            return
-        except ImportError:
-            pass
-    _reset_local()

app/tiers.py

@@ -44,7 +44,6 @@ KIWI_FEATURES: dict[str, str] = {
 
     # Paid tier
     "receipt_ocr":           "paid",   # BYOK-unlockable
-    "visual_label_capture":  "paid",   # Camera capture for unenriched barcodes (kiwi#79)
     "recipe_suggestions":    "paid",   # BYOK-unlockable
     "expiry_llm_matching":   "paid",   # BYOK-unlockable
     "meal_planning":         "free",

compose.cloud.yml

@@ -13,7 +13,6 @@ services:
     environment:
       CLOUD_MODE: "true"
       CLOUD_DATA_ROOT: /devl/kiwi-cloud-data
-      RECIPE_DB_PATH: /devl/kiwi-corpus/recipes.db
       KIWI_BASE_URL: https://menagerie.circuitforge.tech/kiwi
       # DIRECTUS_JWT_SECRET, HEIMDALL_URL, HEIMDALL_ADMIN_TOKEN — set in .env
       # DEV ONLY: comma-separated IPs that bypass JWT auth (LAN testing without Caddy).
@@ -21,12 +20,6 @@ services:
       CLOUD_AUTH_BYPASS_IPS: ${CLOUD_AUTH_BYPASS_IPS:-}
       # cf-orch: route LLM calls through the coordinator for managed GPU inference
       CF_ORCH_URL: http://host.docker.internal:7700
-      # Product identifier for coordinator analytics — per-product VRAM/request breakdown
-      CF_APP_NAME: kiwi
-      # cf-orch streaming proxy — coordinator URL + product key for /proxy/authorize
-      # COORDINATOR_KIWI_KEY must be set in .env (never commit the value)
-      COORDINATOR_URL: http://10.1.10.71:7700
-      COORDINATOR_KIWI_KEY: ${COORDINATOR_KIWI_KEY:-}
       # Community PostgreSQL — shared across CF products; unset = community features unavailable (fail soft)
       COMMUNITY_DB_URL: ${COMMUNITY_DB_URL:-}
       COMMUNITY_PSEUDONYM_SALT: ${COMMUNITY_PSEUDONYM_SALT:-}
@@ -34,8 +27,6 @@ services:
       - "host.docker.internal:host-gateway"
     volumes:
       - /devl/kiwi-cloud-data:/devl/kiwi-cloud-data
-      # Recipe corpus — shared read-only NFS-backed SQLite (3.1M recipes, 2.9GB)
-      - /Library/Assets/kiwi/kiwi.db:/devl/kiwi-corpus/recipes.db:ro
       # LLM config — shared with other CF products; read-only in container
       - ${HOME}/.config/circuitforge:/root/.config/circuitforge:ro
     networks:

compose.override.yml

@@ -8,6 +8,23 @@ services:
       # Docker can follow the symlink inside the container.
       - /Library/Assets/kiwi:/Library/Assets/kiwi:rw
 
-  # cf-orch agent sidecar removed 2026-04-24: Sif is now a dedicated compute node
+  # cf-orch agent sidecar: registers kiwi as a GPU node with the coordinator.
-  # with its own systemd cf-orch-agent service (port 7703, advertise-host 10.1.10.158).
+  # The API scheduler uses COORDINATOR_URL to lease VRAM cooperatively; this
-  # This sidecar was only valid when Kiwi ran on Sif directly.
+  # agent makes kiwi's VRAM usage visible on the orchestrator dashboard.
+  cf-orch-agent:
+    image: kiwi-api  # reuse local api image — cf-core already installed there
+    network_mode: host
+    env_file: .env
+    environment:
+      # Override coordinator URL here or via .env
+      COORDINATOR_URL: ${COORDINATOR_URL:-http://10.1.10.71:7700}
+    command: >
+      conda run -n kiwi cf-orch agent
+      --coordinator ${COORDINATOR_URL:-http://10.1.10.71:7700}
+      --node-id kiwi
+      --host 0.0.0.0
+      --port 7702
+      --advertise-host ${CF_ORCH_ADVERTISE_HOST:-10.1.10.71}
+    restart: unless-stopped
+    depends_on:
+      - api

config/llm.yaml.example

@@ -1,74 +0,0 @@
-# Kiwi — LLM backend configuration
-#
-# Copy to ~/.config/circuitforge/llm.yaml (shared across all CF products)
-# or to config/llm.yaml (Kiwi-local, takes precedence).
-#
-# Kiwi uses LLMs for:
-#   - Expiry prediction fallback (unknown products not in the lookup table)
-#   - Meal planning suggestions
-#
-# Local inference (Ollama / vLLM) is the default path — no API key required.
-# BYOK (bring your own key): set api_key_env to point at your API key env var.
-# cf-orch trunk: set CF_ORCH_URL env var to allocate cf-text on-demand via
-# the coordinator instead of hitting a static URL.
-
-backends:
-  ollama:
-    type: openai_compat
-    enabled: true
-    base_url: http://localhost:11434/v1
-    model: llama3.2:3b
-    api_key: ollama
-    supports_images: false
-
-  vllm:
-    type: openai_compat
-    enabled: false
-    base_url: http://localhost:8000/v1
-    model: __auto__             # resolved from /v1/models at runtime
-    api_key: ''
-    supports_images: false
-
-  # ── cf-orch trunk services ──────────────────────────────────────────────────
-  # These allocate via cf-orch rather than connecting to a static URL.
-  # cf-orch starts the service on-demand and returns its live URL.
-  # Set CF_ORCH_URL env var or fill in url below; leave enabled: false if
-  # cf-orch is not deployed in your environment.
-
-  cf_text:
-    type: openai_compat
-    enabled: false
-    base_url: http://localhost:8008/v1   # fallback when cf-orch is not available
-    model: __auto__
-    api_key: any
-    supports_images: false
-    cf_orch:
-      service: cf-text
-      # model_candidates: leave empty to use the service's default_model,
-      # or specify a catalog alias (e.g. "qwen2.5-3b").
-      model_candidates: []
-      ttl_s: 3600
-
-  # ── Cloud / BYOK ───────────────────────────────────────────────────────────
-
-  anthropic:
-    type: anthropic
-    enabled: false
-    model: claude-haiku-4-5-20251001
-    api_key_env: ANTHROPIC_API_KEY
-    supports_images: false
-
-  openai:
-    type: openai_compat
-    enabled: false
-    base_url: https://api.openai.com/v1
-    model: gpt-4o-mini
-    api_key_env: OPENAI_API_KEY
-    supports_images: false
-
-fallback_order:
-  - cf_text
-  - ollama
-  - vllm
-  - anthropic
-  - openai

docker/web/nginx.cloud.conf

@@ -8,10 +8,8 @@ server {
     # Proxy API requests to the FastAPI container via Docker bridge network.
     location /api/ {
         proxy_pass http://api:8512;
-        proxy_set_header Host $http_host;
+        proxy_set_header Host $host;
-        # Prefer X-Real-IP set by Caddy (real client address); fall back to $remote_addr
+        proxy_set_header X-Real-IP $remote_addr;
-        # when accessed directly on LAN without Caddy in the path.
-        proxy_set_header X-Real-IP $http_x_real_ip;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
         # Forward the session header injected by Caddy from cf_session cookie.
@@ -20,22 +18,6 @@ server {
         client_max_body_size 20m;
     }
 
-    # Direct-port LAN access (localhost:8515): when VITE_API_BASE='/kiwi', the frontend
-    # builds API calls as /kiwi/api/v1/... — proxy these to the API container.
-    # Through Caddy the /kiwi prefix is stripped before reaching nginx, so this block
-    # is only active for direct-port access without Caddy in the path.
-    # Longer prefix (/kiwi/api/ = 10 chars) beats ^~/kiwi/ (6 chars) per nginx rules.
-    location /kiwi/api/ {
-        rewrite ^/kiwi(/api/.*)$ $1 break;
-        proxy_pass http://api:8512;
-        proxy_set_header Host $http_host;
-        proxy_set_header X-Real-IP $http_x_real_ip;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
-        proxy_set_header X-CF-Session $http_x_cf_session;
-        client_max_body_size 20m;
-    }
-
     # When accessed directly (localhost:8515) instead of via Caddy (/kiwi path-strip),
     # Vite's /kiwi base URL means assets are requested at /kiwi/assets/... but stored
     # at /assets/... in nginx's root. Alias /kiwi/ → root so direct port access works.

docs/getting-started/installation.md

@@ -1,69 +0,0 @@
-# Installation
-
-Kiwi runs as a Docker Compose stack: a FastAPI backend and a Vue 3 frontend served by nginx. No external services are required for the core feature set.
-
-## Prerequisites
-
-- Docker and Docker Compose
-- 500 MB disk for images + space for your pantry database
-
-## Quick setup
-
-```bash
-git clone https://git.opensourcesolarpunk.com/Circuit-Forge/kiwi
-cd kiwi
-cp .env.example .env
-./manage.sh build
-./manage.sh start
-```
-
-The web UI opens at `http://localhost:8511`. The FastAPI backend is at `http://localhost:8512`.
-
-## manage.sh commands
-
-| Command | Description |
-|---------|-------------|
-| `./manage.sh start` | Start all services |
-| `./manage.sh stop` | Stop all services |
-| `./manage.sh restart` | Restart all services |
-| `./manage.sh status` | Show running containers |
-| `./manage.sh logs` | Tail logs (all services) |
-| `./manage.sh build` | Rebuild images |
-| `./manage.sh open` | Open browser to the web UI |
-
-## Environment variables
-
-Copy `.env.example` to `.env` and configure:
-
-```bash
-# Required — generate a random secret
-SECRET_KEY=your-random-secret-here
-
-# Optional — LLM backend for AI features (receipt OCR, recipe suggestions)
-# See LLM Setup guide for details
-LLM_BACKEND=ollama          # ollama | openai-compatible | vllm
-LLM_BASE_URL=http://localhost:11434
-LLM_MODEL=llama3.1
-```
-
-## Data location
-
-By default, Kiwi stores its SQLite database in `./data/kiwi.db` inside the repo directory. The `data/` folder is bind-mounted into the container so your pantry survives image rebuilds.
-
-## Updating
-
-```bash
-git pull
-./manage.sh build
-./manage.sh restart
-```
-
-Database migrations run automatically on startup.
-
-## Uninstalling
-
-```bash
-./manage.sh stop
-docker compose down -v    # removes containers and volumes
-rm -rf data/              # removes local database
-```

docs/getting-started/llm-setup.md

@@ -1,74 +0,0 @@
-# LLM Backend Setup (Optional)
-
-An LLM backend unlocks **receipt OCR**, **recipe suggestions (L3–L4)**, and **style auto-classification**. Everything else works without one.
-
-You can use any OpenAI-compatible inference server: Ollama, vLLM, LM Studio, a local llama.cpp server, or a commercial API.
-
-## BYOK — Bring Your Own Key
-
-BYOK means you provide your own LLM backend. Paid AI features are unlocked at **any tier** when a valid backend is configured. You pay for your own inference; Kiwi just uses it.
-
-## Choosing a backend
-
-| Backend | Best for | Notes |
-|---------|----------|-------|
-| **Ollama** | Local, easy setup | Recommended for getting started |
-| **vLLM** | Local, high throughput | Better for faster hardware |
-| **OpenAI API** | No local GPU | Requires paid API key |
-| **Anthropic API** | No local GPU | Requires paid API key |
-
-## Ollama setup (recommended)
-
-```bash
-# Install Ollama
-curl -fsSL https://ollama.ai/install.sh | sh
-
-# Pull a model — llama3.1 8B works well for recipe tasks
-ollama pull llama3.1
-
-# Verify it's running
-ollama list
-```
-
-In your Kiwi `.env`:
-
-```bash
-LLM_BACKEND=ollama
-LLM_BASE_URL=http://host.docker.internal:11434
-LLM_MODEL=llama3.1
-```
-
-!!! note "Docker networking"
-    Use `host.docker.internal` instead of `localhost` when Ollama is running on your host and Kiwi is in Docker.
-
-## OpenAI-compatible API
-
-```bash
-LLM_BACKEND=openai
-LLM_BASE_URL=https://api.openai.com/v1
-LLM_API_KEY=sk-your-key-here
-LLM_MODEL=gpt-4o-mini
-```
-
-## Verify the connection
-
-In the Kiwi **Settings** page, the LLM status indicator shows whether the backend is reachable. A green checkmark means OCR and L3–L4 recipe suggestions are active.
-
-## What LLM is used for
-
-| Feature | LLM required |
-|---------|-------------|
-| Receipt OCR (line-item extraction) | Yes |
-| Recipe suggestions L1 (pantry match) | No |
-| Recipe suggestions L2 (substitution) | No |
-| Recipe suggestions L3 (style templates) | Yes |
-| Recipe suggestions L4 (full generation) | Yes |
-| Style auto-classifier | Yes |
-
-L1 and L2 suggestions use deterministic matching — they work without any LLM configured. See [Recipe Engine](../reference/recipe-engine.md) for the full algorithm breakdown.
-
-## Model recommendations
-
-- **Receipt OCR**: any model with vision capability (LLaVA, GPT-4o, etc.)
-- **Recipe suggestions**: 7B–13B instruction-tuned models work well; larger models produce more creative L4 output
-- **Style classification**: small models handle this fine (3B+)

docs/getting-started/quick-start.md

@@ -1,52 +0,0 @@
-# Quick Start
-
-This guide walks you through adding your first pantry item and getting a recipe suggestion. No LLM backend needed for these steps.
-
-## 1. Add an item by barcode
-
-Open the **Inventory** tab. Tap the barcode icon or click **Scan barcode**, then point your camera at a product barcode. Kiwi looks up the product in the open barcode database and adds it to your pantry.
-
-If the barcode isn't recognized, you'll be prompted to enter the product name and details manually.
-
-## 2. Add an item manually
-
-Click **Add item** and fill in:
-
-- **Name** — what is it? (e.g., "Canned chickpeas")
-- **Quantity** — how many or how much
-- **Expiry date** — when does it expire? (optional but recommended)
-- **Category** — used for dietary filtering and pantry stats
-
-## 3. Upload a receipt
-
-Click **Receipts** in the sidebar, then **Upload receipt**. Take a photo of a grocery receipt or upload an image from your device.
-
-- **Free tier**: the receipt is stored for you to review; line items are entered manually
-- **Paid / BYOK**: OCR runs automatically and extracts items for you to approve
-
-## 4. Browse recipes
-
-Click **Recipes** in the sidebar. The recipe browser shows your **pantry match percentage** for each recipe — how much of the ingredient list you already have.
-
-Use the filters to narrow by:
-
-- **Cuisine** — Italian, Mexican, Japanese, etc.
-- **Meal type** — breakfast, lunch, dinner, snack
-- **Dietary** — vegetarian, vegan, gluten-free, dairy-free, etc.
-- **Main ingredient** — chicken, pasta, lentils, etc.
-
-## 5. Get a suggestion based on what's expiring
-
-Click **Leftover mode** (the clock icon or toggle). Kiwi re-ranks suggestions to surface recipes that use your nearly-expired items first.
-
-Free accounts get 5 leftover-mode requests per day. Paid accounts get unlimited.
-
-## 6. Save a recipe
-
-Click the bookmark icon on any recipe card to save it. You can add:
-
-- **Notes** — cooking tips, modifications, family preferences
-- **Star rating** — 0 to 5 stars
-- **Style tags** — quick, comforting, weeknight, etc.
-
-Saved recipes appear in the **Saved** tab. Paid accounts can organize them into named collections.

docs/index.md

@@ -1,35 +0,0 @@
-# Kiwi — Pantry Tracker
-
-**Stop throwing food away. Cook what you already have.**
-
-Kiwi tracks your pantry, watches for expiry dates, and suggests recipes based on what's about to go bad. Scan barcodes, photograph receipts, and let Kiwi tell you what to make for dinner — without needing an AI backend to do it.
-
-![Kiwi pantry view](screenshots/01-pantry.png)
-
----
-
-## What Kiwi does
-
-- **Inventory tracking** — add items by barcode scan, receipt photo, or manual entry
-- **Expiry alerts** — know what's about to go bad before it does
-- **Recipe browser** — browse by cuisine, meal type, dietary preference, or main ingredient; see pantry match percentage inline
-- **Leftover mode** — prioritize nearly-expired items when getting recipe suggestions
-- **Receipt OCR** — extract line items from receipt photos automatically (Paid / BYOK)
-- **Recipe suggestions** — four levels from pantry-match corpus to full LLM generation (Paid / BYOK)
-- **Saved recipes** — bookmark any recipe with notes, 0–5 star rating, and style tags
-- **CSV export** — export your full pantry inventory anytime
-
-## Quick links
-
-- [Installation](getting-started/installation.md) — local self-hosted setup
-- [Quick Start](getting-started/quick-start.md) — add your first item and get a recipe
-- [LLM Setup](getting-started/llm-setup.md) — unlock AI features with your own backend
-- [Tier System](reference/tier-system.md) — what's free vs. paid
-
-## No AI required
-
-Inventory tracking, barcode scanning, expiry alerts, the recipe browser, saved recipes, and CSV export all work without any LLM configured. AI features (receipt OCR, recipe suggestions, style auto-classification) are optional and BYOK-unlockable at any tier.
-
-## Free and open core
-
-Discovery and pipeline code is MIT-licensed. AI features are BSL 1.1 — free for personal non-commercial self-hosting, commercial SaaS requires a license. See the [tier table](reference/tier-system.md) for the full breakdown.

docs/plausible.js

@@ -1 +0,0 @@
-(function(){var s=document.createElement("script");s.defer=true;s.dataset.domain="docs.circuitforge.tech,circuitforge.tech";s.dataset.api="https://analytics.circuitforge.tech/api/event";s.src="https://analytics.circuitforge.tech/js/script.js";document.head.appendChild(s);})();

docs/reference/architecture.md

@@ -1,80 +0,0 @@
-# Architecture
-
-Kiwi is a self-contained Docker Compose stack with a Vue 3 (SPA) frontend and a FastAPI backend backed by SQLite.
-
-## Stack
-
-| Layer | Technology |
-|-------|-----------|
-| Frontend | Vue 3 + TypeScript + Vite |
-| Backend | FastAPI (Python 3.11+) |
-| Database | SQLite (via circuitforge-core) |
-| Auth (cloud) | CF session cookie → Directus JWT |
-| Licensing | Heimdall (RS256 JWT, offline-capable) |
-| LLM inference | Pluggable — Ollama, vLLM, OpenAI-compatible |
-| Barcode lookup | Open Food Facts / UPC Database API |
-| OCR | LLM vision model (configurable) |
-
-## Data flow
-
-```mermaid
-graph LR
-    User -->|browser| Vue3[Vue 3 SPA]
-    Vue3 -->|/api/*| FastAPI
-    FastAPI -->|SQL| SQLite[(SQLite DB)]
-    FastAPI -->|HTTP| LLM[LLM Backend]
-    FastAPI -->|HTTP| Barcode[Barcode DB API]
-    FastAPI -->|JWT| Heimdall[Heimdall License]
-```
-
-## Docker Compose services
-
-```yaml
-services:
-  api:
-    # FastAPI backend — network_mode: host in dev
-    # Exposed at port 8512
-  web:
-    # Vue 3 SPA served by nginx
-    # Exposed at port 8511
-```
-
-In development, the API uses host networking so nginx can reach it at `172.17.0.1:8512` (Docker bridge gateway).
-
-## Database
-
-SQLite at `./data/kiwi.db`. The schema is managed by numbered migration files in `app/db/migrations/`. Migrations run automatically on startup — the startup script applies any new `*.sql` files in order.
-
-Key tables:
-
-| Table | Purpose |
-|-------|---------|
-| `products` | Product catalog (shared, barcode-keyed) |
-| `pantry_items` | User's pantry (quantity, expiry, notes) |
-| `recipes` | Recipe corpus |
-| `saved_recipes` | User-bookmarked recipes |
-| `collections` | Named recipe collections (Paid) |
-| `receipts` | Receipt uploads and OCR results |
-| `user_preferences` | User settings (dietary, LLM config) |
-
-## Cloud mode
-
-In cloud mode (managed instance at `menagerie.circuitforge.tech/kiwi`), each user gets their own SQLite database isolated under `/devl/kiwi-cloud-data/<user_id>/kiwi.db`. The cloud compose stack adds:
-
-- `CLOUD_MODE=true` environment variable
-- Directus JWT validation for session resolution
-- Heimdall tier check on AI feature endpoints
-
-The same codebase runs in both local and cloud modes — the cloud session middleware is a thin wrapper around the local auth logic.
-
-## LLM integration
-
-Kiwi uses `circuitforge-core`'s LLM router, which abstracts over Ollama, vLLM, and OpenAI-compatible APIs. The router is configured via environment variables at startup. All LLM calls are asynchronous and non-blocking — if the backend is unavailable, Kiwi falls back to the highest deterministic level (L2) and returns results without waiting.
-
-## Privacy
-
-- No PII is logged in production
-- Pantry data stays on your machine in self-hosted mode
-- Cloud mode: data stored per-user on Heimdall server, not shared with third parties, not used for training
-- LLM calls include pantry context in the prompt — if using a cloud API, that context leaves your machine
-- Using a local LLM backend (Ollama, vLLM) keeps all data on-device

docs/reference/recipe-engine.md

@@ -1,75 +0,0 @@
-# Recipe Engine
-
-Kiwi uses a four-level recipe suggestion system. Each level adds more intelligence and better results, but requires more resources. Levels 1–2 are fully deterministic and work without any LLM. Levels 3–4 require an LLM backend.
-
-## Level overview
-
-| Level | Name | LLM required | Description |
-|-------|------|-------------|-------------|
-| L1 | Pantry match | No | Rank existing corpus by ingredient overlap |
-| L2 | Substitution | No | Suggest swaps for missing ingredients |
-| L3 | Style templates | Yes | Generate recipe variations from style templates |
-| L4 | Full generation | Yes | Generate new recipes from scratch |
-
-## L1 — Pantry match
-
-The simplest level. Kiwi scores every recipe in the corpus by how many of its ingredients you already have:
-
-```
-score = (matched ingredients) / (total ingredients)
-```
-
-Recipes are sorted by this score descending. If leftover mode is active, the score is further weighted by expiry proximity.
-
-This works entirely offline with no LLM — just set arithmetic on your current pantry.
-
-## L2 — Substitution
-
-L2 extends L1 by suggesting substitutions for missing ingredients. When a recipe scores well but you're missing one or two items, Kiwi checks a substitution table to see if something in your pantry could stand in:
-
-- Buttermilk → plain yogurt + lemon juice
-- Heavy cream → evaporated milk
-- Fresh herbs → dried herbs (adjusted quantity)
-
-Substitutions are sourced from a curated table — no LLM involved. L2 raises the effective match score for recipes where a reasonable substitute exists.
-
-## L3 — Style templates
-
-L3 uses the LLM to generate recipe variations from a style template. Rather than generating fully free-form text, it fills in a structured template:
-
-```
-[protein] + [vegetable] + [starch] + [sauce/flavor profile]
-```
-
-The template is populated from your pantry contents and the style tags you've set (e.g., "quick", "Italian"). The LLM fills in the techniques, proportions, and instructions.
-
-Style templates produce consistent, practical results with less hallucination risk than fully open-ended generation.
-
-## L4 — Full generation
-
-L4 gives the LLM full creative freedom. Kiwi passes:
-
-- Your full pantry inventory
-- Your dietary preferences
-- Any expiring items (if leftover mode is active)
-- Your saved recipe history and style tags
-
-The LLM generates a new recipe optimized for your situation. Results are more creative than L1–L3 but require a capable model (7B+ recommended) and take longer to generate.
-
-## Escalation
-
-When you click **Suggest**, Kiwi tries each level in order and returns results as soon as a level produces usable output:
-
-1. L1 and L2 run immediately (no LLM)
-2. If no good matches exist (all scores < 30%), Kiwi escalates to L3
-3. If L3 produces no results (LLM unavailable or error), Kiwi falls back to best L1 result
-4. L4 is only triggered explicitly by the user ("Generate something new")
-
-## Tier gates
-
-| Level | Free | Paid | BYOK (any tier) |
-|-------|------|------|-----------------|
-| L1 — Pantry match | ✓ | ✓ | ✓ |
-| L2 — Substitution | ✓ | ✓ | ✓ |
-| L3 — Style templates | — | ✓ | ✓ |
-| L4 — Full generation | — | ✓ | ✓ |

docs/reference/tier-system.md

@@ -1,53 +0,0 @@
-# Tier System
-
-Kiwi uses CircuitForge's standard four-tier model. The free tier covers the full pantry tracking workflow. AI features are gated behind Paid or BYOK.
-
-## Feature matrix
-
-| Feature | Free | Paid | Premium |
-|---------|------|------|---------|
-| **Inventory** | | | |
-| Inventory CRUD | ✓ | ✓ | ✓ |
-| Barcode scan | ✓ | ✓ | ✓ |
-| Receipt upload | ✓ | ✓ | ✓ |
-| Expiry alerts | ✓ | ✓ | ✓ |
-| CSV export | ✓ | ✓ | ✓ |
-| **Recipes** | | | |
-| Recipe browser | ✓ | ✓ | ✓ |
-| Pantry match (L1) | ✓ | ✓ | ✓ |
-| Substitution (L2) | ✓ | ✓ | ✓ |
-| Style templates (L3) | BYOK | ✓ | ✓ |
-| Full generation (L4) | BYOK | ✓ | ✓ |
-| Leftover mode | 5/day | Unlimited | Unlimited |
-| **Saved recipes** | | | |
-| Save + notes + star rating | ✓ | ✓ | ✓ |
-| Style tags (manual) | ✓ | ✓ | ✓ |
-| LLM style auto-classifier | — | BYOK | ✓ |
-| Named collections | — | ✓ | ✓ |
-| Meal planning | — | ✓ | ✓ |
-| **OCR** | | | |
-| Receipt OCR | BYOK | ✓ | ✓ |
-| **Account** | | | |
-| Multi-household | — | — | ✓ |
-
-**BYOK** = Bring Your Own LLM backend. Configure a local or cloud inference endpoint and these features activate at any tier. See [LLM Setup](../getting-started/llm-setup.md).
-
-## Pricing
-
-| Tier | Monthly | Lifetime |
-|------|---------|----------|
-| Free | $0 | — |
-| Paid | $8/mo | $129 |
-| Premium | $16/mo | $249 |
-
-Lifetime licenses are available at [circuitforge.tech](https://circuitforge.tech).
-
-## Self-hosting
-
-Self-hosted Kiwi is free under the MIT license (inventory/pipeline) and BSL 1.1 (AI features, free for personal non-commercial use). You run it on your own hardware with your own LLM backend. No subscription required.
-
-The cloud-managed instance at `menagerie.circuitforge.tech/kiwi` runs the same codebase and requires a CircuitForge account.
-
-## Free key
-
-Claim a free Paid-tier key (30 days) at [circuitforge.tech](https://circuitforge.tech/free-key). No credit card required.

docs/user-guide/barcode.md

@@ -1,39 +0,0 @@
-# Barcode Scanning
-
-Kiwi's barcode scanner uses your device camera to look up products instantly. It works for UPC-A, UPC-E, EAN-13, EAN-8, and QR codes on packaged foods.
-
-## How to scan
-
-1. Open the **Inventory** tab
-2. Click the **Scan barcode** button (camera icon)
-3. Hold the barcode in the camera frame
-4. Kiwi decodes it and looks up the product
-
-## What happens after a scan
-
-**Product found in database:**
-Kiwi fills in the product name, category, and any nutritional metadata from the open barcode database. You confirm the quantity and expiry date, then save.
-
-**Product not found:**
-You'll see a manual entry form with the raw barcode pre-filled. Add a name and the product is saved to your personal pantry (not contributed to the shared database).
-
-## Supported formats
-
-| Format | Common use |
-|--------|-----------|
-| UPC-A (12 digit) | US grocery products |
-| EAN-13 (13 digit) | International grocery products |
-| UPC-E (compressed) | Small packaging |
-| EAN-8 | Small packaging |
-| QR Code | Some specialty products |
-
-## Tips for reliable scanning
-
-- **Good lighting**: scanning works best in well-lit conditions
-- **Steady hand**: hold the camera still for 1–2 seconds
-- **Fill the frame**: bring the barcode close enough to fill most of the camera view
-- **Flat surface**: wrinkled or curved barcodes are harder to decode
-
-## Manual barcode entry
-
-If camera scanning isn't available (browser permissions denied, no camera, etc.), you can type the barcode number directly into the **Barcode** field on the manual add form.

docs/user-guide/inventory.md

@@ -1,62 +0,0 @@
-# Inventory
-
-![Kiwi pantry view](../screenshots/01-pantry.png)
-
-The inventory is your pantry. Every item you add gives Kiwi the data it needs to show pantry match percentages, flag expiry, and rank recipe suggestions.
-
-## Adding items
-
-### By barcode
-
-Tap the barcode scanner icon. Point your camera at the barcode on the product. Kiwi checks the open barcode database and fills in the product name and category.
-
-If the product isn't in the database, you'll see a manual entry form pre-filled with whatever was decoded from the barcode — just add a name and save.
-
-### By receipt
-
-Upload a receipt photo in the **Receipts** tab. After the receipt is processed, approved items are added to your pantry in bulk. See [Receipt OCR](receipt-ocr.md) for details.
-
-### Manually
-
-Click **Add item** and fill in:
-
-| Field | Required | Notes |
-|-------|----------|-------|
-| Name | Yes | What is it? |
-| Quantity | Yes | Number + unit (e.g., "2 cans", "500 g") |
-| Expiry date | No | Used for expiry alerts and leftover mode |
-| Category | No | Helps with dietary filtering |
-| Notes | No | Storage instructions, opened date, etc. |
-
-## Editing and deleting
-
-Click any item in the list to edit its quantity, expiry date, or notes. Items can be deleted individually or in bulk via the selection checkbox.
-
-## Expiry alerts
-
-Kiwi flags items approaching expiry with a color indicator:
-
-- **Red**: expires within 2 days
-- **Orange**: expires within 7 days
-- **Yellow**: expires within 14 days
-
-The **Leftover mode** uses this same expiry window to prioritize nearly-expired items in recipe rankings.
-
-## Inventory stats
-
-The stats panel (top of the Inventory page) shows:
-
-- Total items in pantry
-- Items expiring this week
-- Breakdown by category
-- Items added this month
-
-## CSV export
-
-Click **Export** to download your full pantry as a CSV file. The export includes name, quantity, category, expiry date, and notes for every item.
-
-## Bulk operations
-
-- Select multiple items with the checkbox column
-- **Delete selected** — remove items in bulk
-- **Mark as used** — remove items you've cooked with (coming in Phase 3)

docs/user-guide/leftover-mode.md

@@ -1,39 +0,0 @@
-# Leftover Mode
-
-![Kiwi recipe results with pantry match](../screenshots/03-recipe-results.png)
-
-Leftover mode re-ranks recipe suggestions to surface dishes that use your nearly-expired items first. It's the fastest way to answer "what should I cook before this goes bad?"
-
-## Activating leftover mode
-
-Click the **clock icon** or the **Leftover mode** toggle in the recipe browser. The recipe list immediately re-sorts to prioritize recipes that use items expiring within the next 7 days.
-
-## How it works
-
-When leftover mode is active, Kiwi weights the pantry match score toward items closer to their expiry date. A recipe that uses your 3-day-old spinach and day-old mushrooms ranks higher than a recipe that only uses shelf-stable pantry staples — even if the pantry match percentage is similar.
-
-Items without an expiry date set are not weighted for leftover mode purposes. Setting expiry dates when you add items makes leftover mode much more useful.
-
-## Rate limits
-
-| Tier | Leftover mode requests |
-|------|----------------------|
-| Free | 5 per day |
-| Paid | Unlimited |
-| Premium | Unlimited |
-
-A "request" is each time you activate leftover mode or click **Refresh**. The re-sort count resets at midnight.
-
-## What counts as "nearly expired"
-
-The leftover mode window uses the same thresholds as the expiry indicators:
-
-- **Expiring within 2 days** — highest priority
-- **Expiring within 7 days** — elevated priority
-- **Expiring within 14 days** — mildly elevated priority
-
-Items past their expiry date are still included (Kiwi doesn't remove them automatically) but displayed with a red indicator. Use your judgment — some items are fine past date, others aren't.
-
-## Combining with filters
-
-Leftover mode stacks with the dietary and cuisine filters. You can activate leftover mode and filter by "Vegetarian" or "Under 30 minutes" to narrow down to recipes that both use expiring items and match your constraints.

docs/user-guide/receipt-ocr.md

@@ -1,57 +0,0 @@
-# Receipt OCR
-
-![Kiwi receipt upload](../screenshots/04-receipts.png)
-
-Receipt OCR automatically extracts grocery line items from a photo of your receipt and adds them to your pantry after you approve. It's available on the Paid tier and BYOK-unlockable on Free.
-
-## Upload a receipt
-
-1. Click **Receipts** in the sidebar
-2. Click **Upload receipt**
-3. Take a photo or select an image from your device
-
-Supported formats: JPEG, PNG, HEIC, WebP. Maximum file size: 10 MB.
-
-## How OCR processing works
-
-When a receipt is uploaded:
-
-1. **OCR runs** — the LLM reads the receipt image and identifies line items, quantities, and prices
-2. **Review screen** — you see each extracted item with its detected quantity
-3. **Approve or edit** — correct any mistakes, remove items you don't want tracked
-4. **Confirm** — approved items are added to your pantry in bulk
-
-The whole flow is designed around human approval — Kiwi never silently adds items to your pantry. You always see what's being imported and can adjust before confirming.
-
-## Reviewing extracted items
-
-Each extracted line item shows:
-
-- **Product name** — as extracted from the receipt
-- **Quantity** — detected from the receipt text (e.g., "2 × Canned Tomatoes")
-- **Confidence** — how certain the OCR is about this item
-- **Edit** — correct the name or quantity inline
-- **Remove** — exclude this item from the import
-
-Low-confidence items are flagged with a yellow indicator. Review those carefully — store abbreviations and handwriting can trip up the extractor.
-
-## Free tier behavior
-
-On the Free tier without a BYOK backend configured:
-
-- Receipts are stored and displayed
-- OCR does **not** run automatically
-- You can enter items from the receipt manually using the item list view
-
-To enable automatic OCR on Free tier, configure a [BYOK LLM backend](../getting-started/llm-setup.md).
-
-## Tips for better results
-
-- **Flatten the receipt**: lay it on a flat surface rather than crumpling
-- **Include the full receipt**: get all four edges in frame
-- **Good lighting**: avoid glare on thermal paper
-- **Fresh receipts**: faded thermal receipts (older than a few months) are harder to read
-
-## Re-running OCR
-
-If OCR produced poor results, you can trigger a re-run from the receipt detail view. Each re-run uses a fresh extraction — previous results are discarded.

docs/user-guide/recipes.md

@@ -1,50 +0,0 @@
-# Recipe Browser
-
-![Kiwi recipe finder](../screenshots/02-recipes.png)
-
-The recipe browser lets you explore the full recipe corpus filtered by cuisine, meal type, dietary preference, and main ingredient. Your **pantry match percentage** is shown on every recipe card so you can see at a glance what you can cook tonight.
-
-## Browsing by domain
-
-The recipe corpus is organized into three domains:
-
-| Domain | Examples |
-|--------|---------|
-| **Cuisine** | Italian, Mexican, Japanese, Indian, Mediterranean, West African, ... |
-| **Meal type** | Breakfast, Lunch, Dinner, Snack, Dessert, Drink |
-| **Dietary** | Vegetarian, Vegan, Gluten-free, Dairy-free, Low-carb, Nut-free |
-
-Click a domain tile to see its categories. Click a category to browse the recipes inside it.
-
-## Pantry match percentage
-
-Every recipe card shows what percentage of the ingredient list you already have in your pantry. This updates as your inventory changes.
-
-- **100%**: you have everything — cook it now
-- **70–99%**: almost there, minor shopping needed
-- **< 50%**: you'd need to buy most of the ingredients
-
-## Filtering
-
-Use the filter bar to narrow results:
-
-- **Dietary** — show only recipes matching your dietary preferences
-- **Min pantry match** — hide recipes below a match threshold
-- **Time** — prep + cook time total
-- **Sort** — by pantry match (default), alphabetical, or rating (for saved recipes)
-
-## Recipe detail
-
-Click any recipe card to open the full recipe:
-
-- Ingredient list with **in pantry / not in pantry** indicators
-- Step-by-step instructions
-- Substitution suggestions for missing ingredients
-- Nutritional summary
-- **Bookmark** button to save with notes and rating
-
-## Getting suggestions
-
-The recipe browser shows the **full corpus** sorted by pantry match. For AI-powered suggestions tailored to what's expiring, use [Leftover Mode](leftover-mode.md) or the **Suggest** button (Paid / BYOK).
-
-See [Recipe Engine](../reference/recipe-engine.md) for how the four suggestion levels work.

docs/user-guide/saved-recipes.md

@@ -1,53 +0,0 @@
-# Saved Recipes
-
-Save any recipe from the browser to your personal collection. Add notes, a star rating, and style tags to build a library of recipes you love.
-
-## Saving a recipe
-
-Click the **bookmark icon** on any recipe card or the **Save** button in the recipe detail view. The recipe is immediately saved to your **Saved** tab.
-
-## Notes and ratings
-
-On each saved recipe you can add:
-
-- **Notes** — your modifications, family feedback, what you'd change next time
-- **Star rating** — 0 to 5 stars; used to sort your collection
-- **Style tags** — free-text labels like "quick", "comforting", "weeknight", "meal prep"
-
-Click the pencil icon on a saved recipe to edit these fields.
-
-## Style tags
-
-Style tags are free-text — type anything that helps you find the recipe later. Common tags used by Kiwi users:
-
-`quick` · `weeknight` · `comforting` · `meal prep` · `kid-friendly` · `hands-off` · `summer` · `one-pot`
-
-**Paid tier and above:** the LLM style auto-classifier can suggest tags based on the recipe's ingredients and instructions. Click **Auto-tag** on any saved recipe to get suggestions you can accept or dismiss.
-
-## Collections (Paid)
-
-On the Paid tier, you can organize saved recipes into named collections:
-
-1. Click **New collection** in the Saved tab
-2. Give it a name (e.g., "Weeknight dinners", "Holiday baking")
-3. Add recipes to the collection from the saved recipe list or directly when saving
-
-Collections are listed in the sidebar of the Saved tab. A recipe can belong to multiple collections.
-
-## Sorting and filtering saved recipes
-
-Sort by:
-- **Date saved** (newest first, default)
-- **Star rating** (highest first)
-- **Pantry match** (how many ingredients you currently have)
-- **Alphabetical**
-
-Filter by:
-- **Collection** (Paid)
-- **Style tag**
-- **Star rating** (e.g., show only 4+ star recipes)
-- **Dietary**
-
-## Removing a recipe
-
-Click the bookmark icon again (or the **Remove** button in the detail view) to unsave a recipe. Your notes and rating are lost when you unsave — there's no archive.

docs/user-guide/settings.md

@@ -1,63 +0,0 @@
-# Settings
-
-The Settings page lets you configure your LLM backend, dietary preferences, notification behavior, and account details.
-
-## LLM backend
-
-Shows the currently configured inference backend and its connection status. A green indicator means Kiwi can reach the backend and AI features are active. A red indicator means the backend is unreachable — check the URL and whether the server is running.
-
-To change or add a backend, edit your `.env` file and restart:
-
-```bash
-LLM_BACKEND=ollama
-LLM_BASE_URL=http://host.docker.internal:11434
-LLM_MODEL=llama3.1
-```
-
-See [LLM Backend Setup](../getting-started/llm-setup.md) for full configuration options.
-
-## Dietary preferences
-
-Set your default dietary filters here. These are applied automatically when you browse recipes and get suggestions:
-
-- Vegetarian
-- Vegan
-- Gluten-free
-- Dairy-free
-- Nut-free
-- Low-carb
-- Halal
-- Kosher
-
-Dietary preferences are stored locally and not shared with any server.
-
-## Expiry alert thresholds
-
-Configure when Kiwi starts flagging items:
-
-| Indicator | Default |
-|-----------|---------|
-| Red (urgent) | 2 days |
-| Orange (soon) | 7 days |
-| Yellow (upcoming) | 14 days |
-
-## Notification settings
-
-Kiwi can send browser notifications when items are about to expire. Enable this in Settings by clicking **Allow notifications**. Your browser will ask for permission.
-
-Notifications are sent once per day for items entering the red (2-day) window.
-
-## Account and tier
-
-Shows your current tier (Free / Paid / Premium) and account email (cloud mode only). Includes a link to manage your subscription.
-
-## Affiliate links
-
-When browsing recipes that call for specialty ingredients, Kiwi may show eBay links to find them at a discount. You can:
-
-- **Disable affiliate links entirely** — turn off all affiliate link insertion
-- **Use your own affiliate ID** — if you have an eBay Partner Network (EPN) ID, enter it here and your ID will be used instead of CircuitForge's (Premium tier)
-
-## Export
-
-Click **Export pantry** to download your full inventory as a CSV file. The export includes all items, quantities, categories, expiry dates, and notes.

frontend/index.html

@@ -2,13 +2,8 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
-    <link rel="icon" type="image/png" sizes="192x192" href="/icons/icon-192.png" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
-    <link rel="apple-touch-icon" href="/icons/icon-192.png" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
-    <meta name="theme-color" content="#e8a820" />
-    <meta name="apple-mobile-web-app-capable" content="yes" />
-    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
-    <meta name="apple-mobile-web-app-title" content="Kiwi" />
     <title>Kiwi — Pantry Tracker</title>
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
@@ -28,9 +23,6 @@
         .app-body { display: flex; flex-direction: column; flex: 1; }
       }
     </style>
-    <!-- Plausible analytics: cookie-free, GDPR-compliant, self-hosted.
-         Skips localhost/127.0.0.1. Reports to hostname + circuitforge.tech rollup. -->
-    <script>(function(){if(/localhost|127\.0\.0\.1/.test(location.hostname))return;var s=document.createElement('script');s.defer=true;s.dataset.domain=location.hostname+',circuitforge.tech';s.dataset.api='https://analytics.circuitforge.tech/api/event';s.src='https://analytics.circuitforge.tech/js/script.js';document.head.appendChild(s);})();</script>
   </head>
   <body>
     <div id="app"></div>

frontend/package.json

@@ -20,7 +20,6 @@
     "@vue/tsconfig": "^0.8.1",
     "typescript": "~5.9.3",
     "vite": "^7.1.7",
-    "vite-plugin-pwa": "^1.2.0",
     "vue-tsc": "^3.1.0"
   }
 }

frontend/src/App.vue

@@ -58,15 +58,6 @@
           <span class="sidebar-label">Meal Plan</span>
         </button>
 
-        <button :class="['sidebar-item', { active: currentTab === 'shopping' }]" @click="switchTab('shopping')" aria-label="Shopping List">
-          <svg class="nav-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
-            <path d="M6 2L3 6v14a2 2 0 002 2h14a2 2 0 002-2V6l-3-4z"/>
-            <line x1="3" y1="6" x2="21" y2="6"/>
-            <path d="M16 10a4 4 0 01-8 0"/>
-          </svg>
-          <span class="sidebar-label">Shopping</span>
-        </button>
-
         <button :class="['sidebar-item', { active: currentTab === 'settings' }]" @click="switchTab('settings')">
           <svg class="nav-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round">
             <circle cx="12" cy="12" r="3"/>
@@ -88,24 +79,21 @@
 
       <main class="app-main">
         <div class="container">
-          <div v-if="mountedTabs.has('inventory')" v-show="currentTab === 'inventory'" class="tab-content fade-in">
+          <div v-show="currentTab === 'inventory'" class="tab-content fade-in">
             <InventoryList />
           </div>
-          <div v-if="mountedTabs.has('receipts')" v-show="currentTab === 'receipts'" class="tab-content fade-in">
+          <div v-show="currentTab === 'receipts'" class="tab-content fade-in">
             <ReceiptsView />
           </div>
           <div v-show="currentTab === 'recipes'" class="tab-content fade-in">
             <RecipesView />
           </div>
-          <div v-if="mountedTabs.has('settings')" v-show="currentTab === 'settings'" class="tab-content fade-in">
+          <div v-show="currentTab === 'settings'" class="tab-content fade-in">
             <SettingsView />
           </div>
-          <div v-if="mountedTabs.has('mealplan')" v-show="currentTab === 'mealplan'" class="tab-content">
+          <div v-show="currentTab === 'mealplan'" class="tab-content">
             <MealPlanView />
           </div>
-          <div v-if="mountedTabs.has('shopping')" v-show="currentTab === 'shopping'" class="tab-content fade-in">
-            <ShoppingView />
-          </div>
         </div>
       </main>
     </div>
@@ -156,14 +144,6 @@
         </svg>
         <span class="nav-label">Meal Plan</span>
       </button>
-      <button :class="['nav-item', { active: currentTab === 'shopping' }]" @click="switchTab('shopping')" aria-label="Shopping List">
-        <svg class="nav-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
-          <path d="M6 2L3 6v14a2 2 0 002 2h14a2 2 0 002-2V6l-3-4z"/>
-          <line x1="3" y1="6" x2="21" y2="6"/>
-          <path d="M16 10a4 4 0 01-8 0"/>
-        </svg>
-        <span class="nav-label">Shopping</span>
-      </button>
     </nav>
 
     <!-- Feedback FAB — hidden when FORGEJO_API_TOKEN not configured -->
@@ -204,26 +184,21 @@
 </template>
 
 <script setup lang="ts">
-import { ref, reactive, onMounted } from 'vue'
+import { ref, onMounted } from 'vue'
 import InventoryList from './components/InventoryList.vue'
 import ReceiptsView from './components/ReceiptsView.vue'
 import RecipesView from './components/RecipesView.vue'
 import SettingsView from './components/SettingsView.vue'
 import MealPlanView from './components/MealPlanView.vue'
-import ShoppingView from './components/ShoppingView.vue'
 import FeedbackButton from './components/FeedbackButton.vue'
 import { useInventoryStore } from './stores/inventory'
 import { useEasterEggs } from './composables/useEasterEggs'
-import { householdAPI, bootstrapSession } from './services/api'
+import { householdAPI } from './services/api'
 
-type Tab = 'inventory' | 'receipts' | 'recipes' | 'settings' | 'mealplan' | 'shopping'
+type Tab = 'inventory' | 'receipts' | 'recipes' | 'settings' | 'mealplan'
 
 const currentTab = ref<Tab>('recipes')
 const sidebarCollapsed = ref(false)
-// Lazy-mount: tabs mount on first visit and stay mounted (KeepAlive-like behaviour).
-// Only 'recipes' is in the initial set so non-active tabs don't mount simultaneously
-// on page load — eliminates concurrent onMounted calls across all tab components.
-const mountedTabs = reactive(new Set<Tab>(['recipes']))
 const inventoryStore = useInventoryStore()
 const { kiwiVisible, kiwiDirection } = useEasterEggs()
 
@@ -243,7 +218,6 @@ function onWordmarkClick() {
 }
 
 async function switchTab(tab: Tab) {
-  mountedTabs.add(tab)
   currentTab.value = tab
   if (tab === 'recipes' && inventoryStore.items.length === 0) {
     await inventoryStore.fetchItems()
@@ -251,10 +225,6 @@ async function switchTab(tab: Tab) {
 }
 
 onMounted(async () => {
-  // Session bootstrap — logs auth= + tier= server-side for log-based analytics.
-  // Fire-and-forget: failure doesn't affect UX.
-  bootstrapSession()
-
   // Pre-fetch inventory so Recipes tab has data on first load
   if (inventoryStore.items.length === 0) {
     await inventoryStore.fetchItems()

frontend/src/components/ActionDialog.vue

@@ -1,275 +0,0 @@
-<template>
-  <Transition name="modal">
-    <div v-if="show" class="modal-overlay" @click="handleCancel">
-      <div class="modal-container" @click.stop>
-        <div class="modal-header">
-          <h3>{{ title }}</h3>
-        </div>
-
-        <div class="modal-body">
-          <p>{{ message }}</p>
-
-          <!-- Partial quantity input -->
-          <div v-if="inputType === 'quantity'" class="action-input-row">
-            <label class="action-input-label">{{ inputLabel }}</label>
-            <div class="qty-input-group">
-              <input
-                v-model.number="inputNumber"
-                type="number"
-                :min="0.01"
-                :max="inputMax"
-                step="0.5"
-                class="action-number-input"
-                :aria-label="inputLabel"
-              />
-              <span class="qty-unit">{{ inputUnit }}</span>
-            </div>
-            <button class="btn-use-all" @click="inputNumber = inputMax">
-              Use all ({{ inputMax }} {{ inputUnit }})
-            </button>
-          </div>
-
-          <!-- Reason select -->
-          <div v-if="inputType === 'select'" class="action-input-row">
-            <label class="action-input-label">{{ inputLabel }}</label>
-            <select v-model="inputSelect" class="action-select" :aria-label="inputLabel">
-              <option value="">— skip —</option>
-              <option v-for="opt in inputOptions" :key="opt" :value="opt">{{ opt }}</option>
-            </select>
-          </div>
-        </div>
-
-        <div class="modal-footer">
-          <button class="btn btn-secondary" @click="handleCancel">Cancel</button>
-          <button :class="['btn', `btn-${type}`]" @click="handleConfirm">
-            {{ confirmText }}
-          </button>
-        </div>
-      </div>
-    </div>
-  </Transition>
-</template>
-
-<script setup lang="ts">
-import { ref, watch } from 'vue'
-
-interface Props {
-  show: boolean
-  title?: string
-  message: string
-  confirmText?: string
-  type?: 'primary' | 'danger' | 'warning' | 'secondary'
-  inputType?: 'quantity' | 'select' | null
-  inputLabel?: string
-  inputMax?: number
-  inputUnit?: string
-  inputOptions?: string[]
-}
-
-const props = withDefaults(defineProps<Props>(), {
-  title: 'Confirm',
-  confirmText: 'Confirm',
-  type: 'primary',
-  inputType: null,
-  inputLabel: '',
-  inputMax: 1,
-  inputUnit: '',
-  inputOptions: () => [],
-})
-
-const emit = defineEmits<{
-  confirm: [value: number | string | undefined]
-  cancel: []
-}>()
-
-const inputNumber = ref<number>(props.inputMax)
-const inputSelect = ref<string>('')
-
-watch(() => props.inputMax, (v) => { inputNumber.value = v })
-watch(() => props.show, (v) => {
-  if (v) {
-    inputNumber.value = props.inputMax
-    inputSelect.value = ''
-  }
-})
-
-function handleConfirm() {
-  if (props.inputType === 'quantity') {
-    const qty = Math.min(Math.max(0.01, inputNumber.value || props.inputMax), props.inputMax)
-    emit('confirm', qty)
-  } else if (props.inputType === 'select') {
-    emit('confirm', inputSelect.value || undefined)
-  } else {
-    emit('confirm', undefined)
-  }
-}
-
-function handleCancel() {
-  emit('cancel')
-}
-</script>
-
-<style scoped>
-.modal-overlay {
-  position: fixed;
-  inset: 0;
-  background: rgba(0, 0, 0, 0.5);
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  z-index: 9999;
-  padding: var(--spacing-lg);
-}
-
-.modal-container {
-  background: var(--color-bg-elevated);
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius-xl);
-  box-shadow: var(--shadow-xl);
-  max-width: 480px;
-  width: 100%;
-  overflow: hidden;
-}
-
-.modal-header {
-  padding: var(--spacing-lg);
-  border-bottom: 1px solid var(--color-border);
-}
-
-.modal-header h3 {
-  margin: 0;
-  color: var(--color-text-primary);
-  font-size: var(--font-size-lg);
-  font-weight: 600;
-}
-
-.modal-body {
-  padding: var(--spacing-lg);
-  display: flex;
-  flex-direction: column;
-  gap: var(--spacing-md);
-}
-
-.modal-body p {
-  margin: 0;
-  color: var(--color-text-primary);
-  font-size: var(--font-size-base);
-  line-height: 1.5;
-}
-
-.action-input-row {
-  display: flex;
-  flex-direction: column;
-  gap: var(--spacing-xs);
-}
-
-.action-input-label {
-  font-size: var(--font-size-sm);
-  color: var(--color-text-secondary);
-  font-weight: 500;
-}
-
-.qty-input-group {
-  display: flex;
-  align-items: center;
-  gap: var(--spacing-sm);
-}
-
-.action-number-input {
-  width: 90px;
-  padding: var(--spacing-xs) var(--spacing-sm);
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius-md);
-  background: var(--color-bg-primary);
-  color: var(--color-text-primary);
-  font-size: var(--font-size-base);
-}
-
-.qty-unit {
-  font-size: var(--font-size-sm);
-  color: var(--color-text-secondary);
-}
-
-.btn-use-all {
-  align-self: flex-start;
-  background: none;
-  border: none;
-  color: var(--color-primary);
-  font-size: var(--font-size-sm);
-  cursor: pointer;
-  padding: 0;
-  text-decoration: underline;
-}
-
-.action-select {
-  padding: var(--spacing-xs) var(--spacing-sm);
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius-md);
-  background: var(--color-bg-primary);
-  color: var(--color-text-primary);
-  font-size: var(--font-size-base);
-  width: 100%;
-}
-
-.modal-footer {
-  padding: var(--spacing-lg);
-  border-top: 1px solid var(--color-border);
-  display: flex;
-  justify-content: flex-end;
-  gap: var(--spacing-md);
-}
-
-.btn {
-  padding: var(--spacing-sm) var(--spacing-lg);
-  border: none;
-  border-radius: var(--radius-md);
-  font-size: var(--font-size-base);
-  font-weight: 500;
-  cursor: pointer;
-  transition: all 0.2s ease;
-}
-
-.btn-secondary {
-  background: var(--color-bg-secondary);
-  color: var(--color-text-primary);
-  border: 1px solid var(--color-border);
-}
-
-.btn-secondary:hover { background: var(--color-bg-primary); }
-
-.btn-primary {
-  background: var(--gradient-primary);
-  color: white;
-}
-
-.btn-primary:hover {
-  opacity: 0.9;
-  transform: translateY(-1px);
-  box-shadow: var(--shadow-md);
-}
-
-.btn-danger {
-  background: var(--color-error);
-  color: white;
-}
-
-.btn-danger:hover {
-  background: var(--color-error-dark);
-  transform: translateY(-1px);
-}
-
-.btn-warning {
-  background: var(--color-warning);
-  color: white;
-}
-
-/* Animations */
-.modal-enter-active,
-.modal-leave-active { transition: opacity 0.3s ease; }
-.modal-enter-active .modal-container,
-.modal-leave-active .modal-container { transition: transform 0.3s ease; }
-.modal-enter-from,
-.modal-leave-to { opacity: 0; }
-.modal-enter-from .modal-container,
-.modal-leave-to .modal-container { transform: scale(0.9) translateY(-20px); }
-</style>