feat(qml): task #12 业务桥层 — 5 个 QObject 暴露给 QML

bridges/
  auth.py        AuthBridge       login/logout + currentUser/loggedIn (PoC 模式接受任意非空)
  imagegen.py    ImageGenBridge   submitTask + 信号转发 (TaskQueueManager → QML)
  history.py     HistoryBridge    暴露 HistoryListModel + refresh/getItem/deleteItem
  taskqueue.py   TaskQueueBridge  自带 _TaskListModel (QAbstractListModel + roleNames)
  jewelry.py     JewelryBridge    词库增删 + previewPrompt
  _icons.py      build_placeholder_icon (旧 ImageGeneratorWindow.create_placeholder_icon
                 是实例方法，桥层独立一份)

main_qml.py 改造：
  - 顶部加载 config.json + 实例化 core 业务 (HistoryManager / JewelryLibraryManager /
    TaskQueueManager) + 启 audit_logger（有 db_config 时）
  - 5 个桥通过 setContextProperty 注入：appState / auth / imageGen / history /
    taskQueue / jewelry
  - imageGen.taskCompleted → history.addNew(timestamp) 串起新生成图自动入历史
  - AppState 保留作 currentTab 等 UI 状态（task #13 后 loggedIn 字段删，QML 改用 auth.loggedIn）

冒烟测试：
  - 5 桥全 import OK，依赖注入构造 OK
  - PoC 模式 login('test','x') 通过 / login('','') 拒绝
  - history.refresh() 加载 2 条历史成功
  - jewelry.previewPrompt({...}) 正确组装中文 prompt
  - QML PoC 启动，登录页 + 主窗口（QML_AUTO_LOGIN=1）渲染完整无视觉回归

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

+"""QML 桥层。每个 Bridge 是一个 QObject，通过 setContextProperty 注入 QML。
+
+桥层职责：
+- 把 core/* 的 Python 业务通过 Property/Signal/Slot 暴露给 QML
+- 数据类型转换（Path → str / bytes 走文件而非传值 / 中文字段名透传）
+- 不写业务逻辑：所有真业务在 core/* + task_queue.py + audit_logger.py
+
+依赖注入：业务 Manager 在 main_qml.py 实例化一次，作为参数传给桥构造函数。
+"""

+"""桥层共享的占位图标生成。
+
+旧 ImageGeneratorWindow.create_placeholder_icon 是 QWidget 实例方法（依赖 self），
+桥层独立用一份不依赖 widget 实例的版本。
+"""
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QFont, QIcon, QPainter, QPixmap
+
+
+def build_placeholder_icon(text: str, size: int = 120) -> QIcon:
+    """绘制一张 size×size 的浅灰底中央文字占位图，用于历史项缩略图缺失时回退。"""
+    pixmap = QPixmap(size, size)
+    pixmap.fill(Qt.lightGray)
+
+    painter = QPainter(pixmap)
+    painter.setPen(Qt.black)
+    painter.setFont(QFont("Arial", 10))
+    painter.drawText(pixmap.rect(), Qt.AlignCenter, text)
+    painter.end()
+
+    return QIcon(pixmap)

+"""AuthBridge — 登录认证 + 当前用户。
+
+替代旧 LoginDialog。QML LoginScreen 调 auth.login(user, pwd)，桥内部走
+DatabaseManager.authenticate（同步 MySQL，5s timeout）+ audit_logger.log_login。
+
+PoC 模式（db_config = None）：接受任意非空用户名密码，便于无 db 环境调 UI。
+"""
+import logging
+import platform
+import socket
+from typing import Optional
+
+from PySide6.QtCore import Property, QObject, Signal, Slot
+
+from core.database import DatabaseManager
+
+
+class AuthBridge(QObject):
+    loggedInChanged = Signal()
+    currentUserChanged = Signal()
+    loginFailed = Signal(str)  # error_message
+
+    def __init__(self, db_config: Optional[dict] = None, audit_logger=None, parent=None):
+        super().__init__(parent)
+        self._logger = logging.getLogger(__name__)
+        self._db_config = db_config
+        self._db = DatabaseManager(db_config) if db_config else None
+        self._audit = audit_logger
+        self._logged_in = False
+        self._current_user = ""
+
+    @Property(bool, notify=loggedInChanged)
+    def loggedIn(self) -> bool:
+        return self._logged_in
+
+    @Property(str, notify=currentUserChanged)
+    def currentUser(self) -> str:
+        return self._current_user
+
+    @Slot(str, str, result=bool)
+    def login(self, username: str, password: str) -> bool:
+        username = (username or "").strip()
+        if not username or not password:
+            self.loginFailed.emit("用户名和密码不能为空")
+            return False
+
+        # PoC 模式：无 db_config 时接受任意非空
+        if self._db is None:
+            self._on_login_success(username)
+            return True
+
+        ok, msg = self._db.authenticate(username, password)
+        if not ok:
+            self._logger.warning(f"登录失败: {username} - {msg}")
+            self.loginFailed.emit(msg)
+            return False
+
+        self._on_login_success(username)
+        return True
+
+    @Slot()
+    def logout(self) -> None:
+        self._logged_in = False
+        self._current_user = ""
+        self.loggedInChanged.emit()
+        self.currentUserChanged.emit()
+
+    @Slot(result=str)
+    def deviceName(self) -> str:
+        """供 audit 日志和 ImageGenBridge 使用"""
+        try:
+            return socket.gethostname() or platform.node() or "unknown"
+        except Exception:
+            return "unknown"
+
+    # ---- 内部 -----------------------------------------------------------
+
+    def _on_login_success(self, username: str) -> None:
+        self._current_user = username
+        self._logged_in = True
+        self.currentUserChanged.emit()
+        self.loggedInChanged.emit()
+        self._logger.info(f"登录成功: {username}")
+
+        if self._audit is not None:
+            try:
+                self._audit.log_login(
+                    user_name=username,
+                    local_ip=self._get_local_ip(),
+                    public_ip=None,  # public ip 走慢路径，task #13 再加
+                    device_name=self.deviceName(),
+                )
+            except Exception as e:
+                self._logger.warning(f"audit log_login 失败（不影响登录）: {e}")
+
+    @staticmethod
+    def _get_local_ip() -> Optional[str]:
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+                s.settimeout(0.5)
+                s.connect(("8.8.8.8", 80))
+                return s.getsockname()[0]
+        except Exception:
+            return None

+"""HistoryBridge — 历史记录 tab 的列表 + 详情桥。
+
+桥层暴露 HistoryListModel 给 QML ListView 直接用（已经是 QAbstractListModel）。
+QML 通过 history.refresh() 主动刷新；新生成图片完成时由 ImageGenBridge 串起来调
+itemAdded（task #16 wiring 时再补）。
+
+详情查看走 getItem(timestamp) → dict，避免 QML 直接持有 HistoryItem dataclass。
+"""
+import logging
+from typing import Any, Dict
+
+from PySide6.QtCore import Property, QObject, Signal, Slot
+
+from core.history import HistoryListModel
+from ._icons import build_placeholder_icon
+
+
+class HistoryBridge(QObject):
+    countChanged = Signal()
+    itemAdded = Signal(str)    # timestamp
+    itemRemoved = Signal(str)  # timestamp
+
+    def __init__(self, history_manager, parent=None):
+        super().__init__(parent)
+        self._logger = logging.getLogger(__name__)
+        self._history = history_manager
+        self._model = HistoryListModel(
+            history_manager=history_manager,
+            build_placeholder_icon=build_placeholder_icon,
+            logger=self._logger,
+            parent=self,
+        )
+
+    # ---- Properties -----------------------------------------------------
+
+    @Property(QObject, constant=True)
+    def model(self) -> HistoryListModel:
+        """暴露给 QML ListView 的 model（QAbstractListModel）。"""
+        return self._model
+
+    @Property(int, notify=countChanged)
+    def count(self) -> int:
+        return self._model.rowCount()
+
+    # ---- Slots ----------------------------------------------------------
+
+    @Slot()
+    def refresh(self) -> None:
+        """从磁盘重读 index.json，整体 reset model。"""
+        items = self._history.load_history_index()
+        self._model.reset_timestamps([item.timestamp for item in items])
+        self.countChanged.emit()
+        self._logger.info(f"history refresh: {len(items)} 条")
+
+    @Slot(str)
+    def deleteItem(self, timestamp: str) -> None:
+        ok = self._history.delete_history_item(timestamp)
+        if ok:
+            self._model.remove_timestamp(timestamp)
+            self.itemRemoved.emit(timestamp)
+            self.countChanged.emit()
+
+    @Slot(str)
+    def addNew(self, timestamp: str) -> None:
+        """新生成完成时由 ImageGenBridge / 主线程调用，把新 timestamp 插到顶部。"""
+        self._model.prepend_timestamp(timestamp)
+        self.itemAdded.emit(timestamp)
+        self.countChanged.emit()
+
+    @Slot(str, result="QVariant")
+    def getItem(self, timestamp: str) -> Dict[str, Any]:
+        """返回单条历史的 QML 友好 dict（路径 → str / Path 不暴露）。"""
+        item = self._history.load_history_item_fast(timestamp)
+        if item is None:
+            return {}
+        return {
+            "timestamp": item.timestamp,
+            "prompt": item.prompt,
+            "generatedImagePath": str(item.generated_image_path),
+            "referenceImagePaths": [str(p) for p in item.reference_image_paths],
+            "aspectRatio": item.aspect_ratio,
+            "imageSize": item.image_size,
+            "model": item.model,
+            "createdAt": item.created_at.strftime("%Y-%m-%d %H:%M:%S"),
+        }

+"""ImageGenBridge — 图片生成 tab 的输入输出桥。
+
+QML 调 imageGen.submitTask(prompt, refs, aspect, size, mode) → 桥层把 mode 中文
+名翻译成 Gemini 模型 ID，调 TaskQueueManager.submit_task。任务完成后桥层
+监听 TaskQueueManager.task_completed 信号，把 image_bytes 落 HistoryManager.save_generation，
+然后把 result_path 通过 taskCompleted 信号转出（QML 只拿到文件路径，不传 bytes）。
+"""
+import logging
+from typing import Optional
+
+from PySide6.QtCore import Property, QObject, Signal, Slot
+
+from core.generation import MODEL_BY_MODE, MODEL_PRO
+
+
+class ImageGenBridge(QObject):
+    apiKeyChanged = Signal()
+    busyChanged = Signal()
+
+    taskSubmitted = Signal(str)                    # task_id
+    taskCompleted = Signal(str, str, str, str)     # task_id, result_path, prompt, model
+    taskFailed = Signal(str, str)                  # task_id, error_message
+    taskProgress = Signal(str, float, str)         # task_id, progress, status_text
+
+    def __init__(self, task_queue_manager, history_manager, auth_bridge,
+                 api_key: str = "", parent=None):
+        super().__init__(parent)
+        self._logger = logging.getLogger(__name__)
+        self._tqm = task_queue_manager
+        self._history = history_manager
+        self._auth = auth_bridge
+        self._api_key = api_key
+
+        # 转发 TaskQueueManager 信号 → 桥层 QML 友好信号
+        self._tqm.task_added.connect(self._on_task_added)
+        self._tqm.task_progress.connect(self._on_progress)
+        self._tqm.task_completed.connect(self._on_completed)
+        self._tqm.task_failed.connect(self._on_failed)
+
+    # ---- Properties -----------------------------------------------------
+
+    @Property(str, notify=apiKeyChanged)
+    def apiKey(self) -> str:
+        return self._api_key
+
+    @Property(bool, notify=busyChanged)
+    def busy(self) -> bool:
+        return self._tqm.get_running_count() > 0
+
+    # ---- Slots ----------------------------------------------------------
+
+    @Slot(str)
+    def setApiKey(self, key: str) -> None:
+        if key != self._api_key:
+            self._api_key = key
+            self.apiKeyChanged.emit()
+
+    @Slot(str, list, str, str, str, result=str)
+    def submitTask(self, prompt: str, reference_images: list,
+                   aspect_ratio: str, image_size: str, mode: str) -> str:
+        """提交一条生成任务，返回 task_id。失败抛 RuntimeError。
+
+        Args:
+            prompt: 中文提示词
+            reference_images: 参考图本地路径 list[str]
+            aspect_ratio: '1:1' / '2:3' / ...
+            image_size: '1K' / '2K' / '4K'
+            mode: '极速模式' 或 '慢速模式'
+        """
+        from task_queue import TaskType  # 局部 import 避免桥层冷启动加载 Qt UI
+
+        model = MODEL_BY_MODE.get(mode, MODEL_PRO)
+        task_id = self._tqm.submit_task(
+            task_type=TaskType.IMAGE_GENERATION,
+            prompt=prompt,
+            api_key=self._api_key,
+            reference_images=list(reference_images or []),
+            aspect_ratio=aspect_ratio,
+            image_size=image_size,
+            model=model,
+            user_name=self._auth.currentUser if self._auth else "",
+            device_name=self._auth.deviceName() if self._auth else "",
+        )
+        self._logger.info(f"提交生成任务: {task_id[:8]} - mode={mode}")
+        return task_id
+
+    @Slot(str)
+    def cancelTask(self, task_id: str) -> None:
+        self._tqm.cancel_task(task_id)
+        self.busyChanged.emit()
+
+    # ---- 内部信号转发 ----------------------------------------------------
+
+    def _on_task_added(self, task) -> None:
+        self.taskSubmitted.emit(task.id)
+        self.busyChanged.emit()
+
+    def _on_progress(self, task_id: str, progress: float, status_text: str) -> None:
+        self.taskProgress.emit(task_id, progress, status_text)
+
+    def _on_completed(self, task_id: str, image_bytes: bytes, prompt: str,
+                      reference_images: list, aspect_ratio: str,
+                      image_size: str, model: str) -> None:
+        # 落历史记录（QML 只看路径）
+        try:
+            timestamp = self._history.save_generation(
+                image_bytes=image_bytes,
+                prompt=prompt,
+                reference_images=reference_images,
+                aspect_ratio=aspect_ratio,
+                image_size=image_size,
+                model=model,
+            )
+            result_path = str(self._history.base_path / timestamp / "generated.png")
+        except Exception as e:
+            self._logger.error(f"保存历史失败 {task_id[:8]}: {e}", exc_info=True)
+            self.taskFailed.emit(task_id, f"图片生成成功但保存历史失败: {e}")
+            self.busyChanged.emit()
+            return
+
+        self.taskCompleted.emit(task_id, result_path, prompt, model)
+        self.busyChanged.emit()
+
+    def _on_failed(self, task_id: str, error: str) -> None:
+        self.taskFailed.emit(task_id, error)
+        self.busyChanged.emit()

+"""JewelryBridge — 款式设计 tab 桥层。
+
+QML 需要的能力：
+- 拿全部 9 个类别名（categories）
+- 按类别拿候选词（getOptions）
+- 增删词条 + 重置类别 / 全部
+- 用户填完表后预览中文 prompt
+
+后端：core.jewelry.JewelryLibraryManager + PromptAssembler。
+"""
+import logging
+from typing import Any, Dict, List
+
+from PySide6.QtCore import Property, QObject, Signal, Slot
+
+from core.jewelry import PromptAssembler
+
+
+class JewelryBridge(QObject):
+    libraryChanged = Signal(str)  # category
+
+    def __init__(self, library_manager, parent=None):
+        super().__init__(parent)
+        self._logger = logging.getLogger(__name__)
+        self._lib = library_manager
+
+    @Property("QVariantList", constant=True)
+    def categories(self) -> List[str]:
+        """9 个类别的中文名（顺序固定，与 QML 表单一致）。"""
+        return list(self._lib.library.keys())
+
+    @Slot(str, result="QVariantList")
+    def getOptions(self, category: str) -> List[str]:
+        return list(self._lib.library.get(category, []))
+
+    @Slot(str, str)
+    def addItem(self, category: str, value: str) -> None:
+        self._lib.add_item(category, value)
+        self.libraryChanged.emit(category)
+
+    @Slot(str, str)
+    def removeItem(self, category: str, value: str) -> None:
+        self._lib.remove_item(category, value)
+        self.libraryChanged.emit(category)
+
+    @Slot(str)
+    def resetCategory(self, category: str) -> None:
+        self._lib.reset_category(category)
+        self.libraryChanged.emit(category)
+
+    @Slot()
+    def resetAll(self) -> None:
+        self._lib.reset_all()
+        for c in self._lib.library.keys():
+            self.libraryChanged.emit(c)
+
+    @Slot("QVariantMap", result=str)
+    def previewPrompt(self, form_data: Dict[str, Any]) -> str:
+        """form_data: { "主石形状": "圆形", "金属": "18K黄金", ... } —— 空字段允许。"""
+        return PromptAssembler.assemble({k: str(v or "") for k, v in form_data.items()})

+"""TaskQueueBridge — 任务队列 sidebar 桥层。
+
+QML sidebar ListView 直接用 taskQueue.model（QAbstractListModel），
+桥层监听 TaskQueueManager 单例信号，按 task_id 增量更新 model。
+
+只持有最近 N 条（与 TaskQueueManager 自身的 _max_history_size 一致），
+更老的任务会随 TaskQueueManager._cleanup_old_tasks 自然消失。
+"""
+import logging
+from datetime import datetime
+from typing import Dict, List
+
+from PySide6.QtCore import (
+    Property, QAbstractListModel, QModelIndex, QObject, Qt, Signal, Slot,
+)
+
+
+class _TaskListModel(QAbstractListModel):
+    """暴露给 QML ListView 的任务列表模型。
+
+    Roles：taskId / prompt / status / progress / statusText / elapsed
+    """
+    TaskIdRole = Qt.UserRole + 1
+    PromptRole = Qt.UserRole + 2
+    StatusRole = Qt.UserRole + 3
+    ProgressRole = Qt.UserRole + 4
+    StatusTextRole = Qt.UserRole + 5
+    ElapsedRole = Qt.UserRole + 6
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._ids: List[str] = []
+        self._rows: Dict[str, dict] = {}
+
+    def rowCount(self, parent=QModelIndex()) -> int:
+        if parent.isValid():
+            return 0
+        return len(self._ids)
+
+    def roleNames(self):
+        return {
+            _TaskListModel.TaskIdRole: b"taskId",
+            _TaskListModel.PromptRole: b"prompt",
+            _TaskListModel.StatusRole: b"status",
+            _TaskListModel.ProgressRole: b"progress",
+            _TaskListModel.StatusTextRole: b"statusText",
+            _TaskListModel.ElapsedRole: b"elapsed",
+        }
+
+    def data(self, index: QModelIndex, role: int = Qt.DisplayRole):
+        if not index.isValid():
+            return None
+        row = index.row()
+        if row < 0 or row >= len(self._ids):
+            return None
+        record = self._rows.get(self._ids[row], {})
+        if role == _TaskListModel.TaskIdRole:
+            return record.get("task_id", "")
+        if role == _TaskListModel.PromptRole:
+            return record.get("prompt", "")
+        if role == _TaskListModel.StatusRole:
+            return record.get("status", "")
+        if role == _TaskListModel.ProgressRole:
+            return float(record.get("progress", 0.0))
+        if role == _TaskListModel.StatusTextRole:
+            return record.get("status_text", "")
+        if role == _TaskListModel.ElapsedRole:
+            return record.get("elapsed", "")
+        return None
+
+    # ---- 增量操作（桥层调用）---------------------------------------------
+
+    def upsert(self, task_id: str, **fields) -> None:
+        if task_id in self._rows:
+            self._rows[task_id].update(fields)
+            row = self._ids.index(task_id)
+            top = self.index(row, 0)
+            self.dataChanged.emit(top, top)
+        else:
+            self.beginInsertRows(QModelIndex(), 0, 0)
+            self._ids.insert(0, task_id)
+            self._rows[task_id] = {"task_id": task_id, **fields}
+            self.endInsertRows()
+
+
+class TaskQueueBridge(QObject):
+    pendingCountChanged = Signal()
+    runningCountChanged = Signal()
+
+    def __init__(self, task_queue_manager, parent=None):
+        super().__init__(parent)
+        self._logger = logging.getLogger(__name__)
+        self._tqm = task_queue_manager
+        self._model = _TaskListModel(self)
+
+        self._tqm.task_added.connect(self._on_task_added)
+        self._tqm.task_started.connect(self._on_task_started)
+        self._tqm.task_completed.connect(self._on_task_completed)
+        self._tqm.task_failed.connect(self._on_task_failed)
+        self._tqm.task_progress.connect(self._on_progress)
+
+    # ---- Properties -----------------------------------------------------
+
+    @Property(QObject, constant=True)
+    def model(self):
+        return self._model
+
+    @Property(int, notify=pendingCountChanged)
+    def pendingCount(self) -> int:
+        return self._tqm.get_pending_count()
+
+    @Property(int, notify=runningCountChanged)
+    def runningCount(self) -> int:
+        return self._tqm.get_running_count()
+
+    # ---- Slots ----------------------------------------------------------
+
+    @Slot(str)
+    def cancelTask(self, task_id: str) -> None:
+        self._tqm.cancel_task(task_id)
+        self.pendingCountChanged.emit()
+        self.runningCountChanged.emit()
+
+    # ---- 信号转 model 增量 -----------------------------------------------
+
+    def _on_task_added(self, task) -> None:
+        self._model.upsert(
+            task.id,
+            prompt=task.prompt,
+            status="pending",
+            progress=0.0,
+            status_text="等待中",
+            elapsed="",
+        )
+        self.pendingCountChanged.emit()
+
+    def _on_task_started(self, task_id: str) -> None:
+        self._model.upsert(task_id, status="running", status_text="生成中…")
+        self.pendingCountChanged.emit()
+        self.runningCountChanged.emit()
+
+    def _on_progress(self, task_id: str, progress: float, status_text: str) -> None:
+        self._model.upsert(task_id, progress=progress, status_text=status_text)
+
+    def _on_task_completed(self, task_id, *_args) -> None:
+        elapsed = self._format_elapsed(task_id)
+        self._model.upsert(task_id, status="completed", progress=1.0,
+                           status_text="已完成", elapsed=elapsed)
+        self.runningCountChanged.emit()
+
+    def _on_task_failed(self, task_id: str, error: str) -> None:
+        elapsed = self._format_elapsed(task_id)
+        self._model.upsert(task_id, status="failed", status_text=error or "失败",
+                           elapsed=elapsed)
+        self.pendingCountChanged.emit()
+        self.runningCountChanged.emit()
+
+    def _format_elapsed(self, task_id: str) -> str:
+        task = self._tqm.get_task(task_id)
+        if task and task.started_at and task.completed_at:
+            secs = (task.completed_at - task.started_at).total_seconds()
+            return f"{secs:.1f}s"
+        return ""

-"""QML PoC 入口 — 验证 QtQuick + Apple 风格自定义视觉。
+"""QML 主入口 — 装载业务桥层 + Apple 风格 QtQuick UI。
 
 
-只做 UI 演示：
-- 登录页 (LoginScreen.qml)
-- 主窗口 (MainWindow.qml) 含 3 tab + 任务队列 sidebar
-- 图片生成 tab 的核心 UI 元素
+启动序列：
+1. 加载 config.json（API key / db_config / 历史最大数）
+2. 实例化 core 业务（HistoryManager / JewelryLibraryManager / TaskQueueManager）
+3. 实例化 audit_logger（落盘 + 后台 worker，task #18 全量启用）
+4. 实例化 5 个桥（auth / imageGen / history / taskQueue / jewelry）+ AppState
+5. 把它们注入 QQmlApplicationEngine context
+6. load Main.qml
 
 
-不接业务后端（不真的生成图片 / 调 db），让用户先看视觉。
 跑：.venv/Scripts/pythonw.exe qml_poc/main_qml.py
 跑：.venv/Scripts/pythonw.exe qml_poc/main_qml.py
 """
 """
+import logging
+import os
 import sys
 import sys
 from pathlib import Path
 from pathlib import Path
 
 
-from PySide6.QtCore import QObject, QUrl, Property, Signal, Slot
+from PySide6.QtCore import Property, QObject, QUrl, Signal, Slot
 from PySide6.QtGui import QGuiApplication
 from PySide6.QtGui import QGuiApplication
 from PySide6.QtQml import QQmlApplicationEngine
 from PySide6.QtQml import QQmlApplicationEngine
 from PySide6.QtQuickControls2 import QQuickStyle
 from PySide6.QtQuickControls2 import QQuickStyle
 
 
+# 确保 import 路径包含项目根（qml_poc/ 跑 main_qml.py 时也能 import core/bridges）
+ROOT = Path(__file__).resolve().parent.parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from audit_logger import AuditLogger  # noqa: E402
+from bridges.auth import AuthBridge  # noqa: E402
+from bridges.history import HistoryBridge  # noqa: E402
+from bridges.imagegen import ImageGenBridge  # noqa: E402
+from bridges.jewelry import JewelryBridge  # noqa: E402
+from bridges.taskqueue import TaskQueueBridge  # noqa: E402
+from config_util import get_config_dir, get_config_path, load_config_safe  # noqa: E402
+from core.history import HistoryManager  # noqa: E402
+from core.jewelry import JewelryLibraryManager  # noqa: E402
+from core.paths import get_app_data_path  # noqa: E402
+from task_queue import TaskQueueManager  # noqa: E402
+
+logger = logging.getLogger(__name__)
+
 
 
 class AppState(QObject):
 class AppState(QObject):
-    """暴露给 QML 的全局状态。最小骨架，业务后续再接。"""
+    """全局轻量状态。登录态委托给 AuthBridge，本类只管当前 tab 索引等纯 UI 状态。
+
+    PoC 调试：QML_AUTO_LOGIN=1 时跳过登录直接进主窗口；task #13 后 QML 改用
+    auth.loggedIn 替代 appState.loggedIn，本类的 loggedIn 字段也会被删掉。
+    """
     loggedInChanged = Signal()
     loggedInChanged = Signal()
     currentTabChanged = Signal()
     currentTabChanged = Signal()
 
 
-    def __init__(self):
+    def __init__(self, auth_bridge: AuthBridge):
         super().__init__()
         super().__init__()
-        # PoC 调试：QML_AUTO_LOGIN=1 时直接登录态，免每次重启进程都发回车登录
-        import os
-        self._logged_in = os.environ.get("QML_AUTO_LOGIN", "") == "1"
+        self._auth = auth_bridge
+        # 兼容现有 QML：env QML_AUTO_LOGIN=1 时强制 loggedIn=True
+        self._poc_force_login = os.environ.get("QML_AUTO_LOGIN", "") == "1"
         self._current_tab = 0
         self._current_tab = 0
+        self._auth.loggedInChanged.connect(self.loggedInChanged.emit)
 
 
     @Property(bool, notify=loggedInChanged)
     @Property(bool, notify=loggedInChanged)
-    def loggedIn(self):
-        return self._logged_in
+    def loggedIn(self) -> bool:
+        return self._poc_force_login or self._auth.loggedIn
 
 
     @Property(int, notify=currentTabChanged)
     @Property(int, notify=currentTabChanged)
-    def currentTab(self):
+    def currentTab(self) -> int:
         return self._current_tab
         return self._current_tab
 
 
     @Slot(str, str, result=bool)
     @Slot(str, str, result=bool)
     def login(self, username: str, password: str) -> bool:
     def login(self, username: str, password: str) -> bool:
-        # PoC：随便接受，业务不接
-        if not username or not password:
-            return False
-        self._logged_in = True
-        self.loggedInChanged.emit()
-        return True
+        """兼容旧 QML PoC：转发到 AuthBridge。task #13 后 QML 直接调 auth.login。"""
+        return self._auth.login(username, password)
 
 
     @Slot()
     @Slot()
-    def logout(self):
-        self._logged_in = False
-        self.loggedInChanged.emit()
+    def logout(self) -> None:
+        self._auth.logout()
 
 
     @Slot(int)
     @Slot(int)
-    def setTab(self, idx: int):
+    def setTab(self, idx: int) -> None:
         self._current_tab = idx
         self._current_tab = idx
         self.currentTabChanged.emit()
         self.currentTabChanged.emit()
 
 
 
 
+def _setup_logging():
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    )
+
+
 def main():
 def main():
-    QQuickStyle.setStyle("Basic")  # 纯净底，不引入 Material/Win11 的视觉污染
+    _setup_logging()
+    QQuickStyle.setStyle("Basic")
+
     app = QGuiApplication(sys.argv)
     app = QGuiApplication(sys.argv)
     app.setApplicationName("珠宝壹佰图像生成器")
     app.setApplicationName("珠宝壹佰图像生成器")
     app.setOrganizationName("ZB100")
     app.setOrganizationName("ZB100")
 
 
-    state = AppState()
+    # ---- 配置 + 业务核心 ------------------------------------------------
+    config_path = get_config_path()
+    config, err = load_config_safe(config_path)
+    if err:
+        logger.warning(f"config 加载警告: {err}")
+
+    api_key = config.get("api_key", "") or ""
+    db_config = config.get("db_config")  # None 时桥层走 PoC 模式
+    config_dir = get_config_dir()
+
+    history_manager = HistoryManager()
+    jewelry_manager = JewelryLibraryManager(config_dir)
+    task_queue_manager = TaskQueueManager()  # 单例
+
+    audit_logger = None
+    if db_config:
+        try:
+            app_data = get_app_data_path()
+            audit_logger = AuditLogger(
+                db_config=db_config,
+                queue_path=app_data / "audit_queue.ndjson",
+                logs_dir=app_data / "logs",
+            )
+            audit_logger.start()
+        except Exception as e:
+            logger.warning(f"audit_logger 启动失败（不影响 UI）: {e}")
+            audit_logger = None
+
+    # ---- 桥层 ----------------------------------------------------------
+    auth_bridge = AuthBridge(db_config=db_config, audit_logger=audit_logger)
+    image_gen_bridge = ImageGenBridge(
+        task_queue_manager=task_queue_manager,
+        history_manager=history_manager,
+        auth_bridge=auth_bridge,
+        api_key=api_key,
+    )
+    history_bridge = HistoryBridge(history_manager=history_manager)
+    task_queue_bridge = TaskQueueBridge(task_queue_manager=task_queue_manager)
+    jewelry_bridge = JewelryBridge(library_manager=jewelry_manager)
+    app_state = AppState(auth_bridge=auth_bridge)
+
+    # 新生成完图后让 history 列表加新行（绕过手动 refresh）
+    image_gen_bridge.taskCompleted.connect(
+        lambda task_id, result_path, prompt, model:
+        history_bridge.addNew(Path(result_path).parent.name)
+    )
+
+    # 启动期预填一次历史
+    history_bridge.refresh()
+
+    # ---- QML 装载 ------------------------------------------------------
     engine = QQmlApplicationEngine()
     engine = QQmlApplicationEngine()
-    engine.rootContext().setContextProperty("appState", state)
+    ctx = engine.rootContext()
+    ctx.setContextProperty("appState", app_state)
+    ctx.setContextProperty("auth", auth_bridge)
+    ctx.setContextProperty("imageGen", image_gen_bridge)
+    ctx.setContextProperty("history", history_bridge)
+    ctx.setContextProperty("taskQueue", task_queue_bridge)
+    ctx.setContextProperty("jewelry", jewelry_bridge)
 
 
     qml_dir = Path(__file__).parent / "qml"
     qml_dir = Path(__file__).parent / "qml"
     engine.addImportPath(str(qml_dir))
     engine.addImportPath(str(qml_dir))
@@ -75,7 +163,16 @@ def main():
         print("QML load failed", file=sys.stderr)
         print("QML load failed", file=sys.stderr)
         sys.exit(1)
         sys.exit(1)
 
 
-    sys.exit(app.exec())
+    rc = app.exec()
+
+    # 退出前 flush audit 日志
+    if audit_logger:
+        try:
+            audit_logger.shutdown(timeout=5.0)
+        except Exception:
+            pass
+
+    sys.exit(rc)
 
 
 
 
 if __name__ == "__main__":
 if __name__ == "__main__":