refactor!: uv 管理环境 + 彻底删除技术债（Flask 与 requests 全部移除）

## uv 环境管理
- pyproject.toml 声明 dependencies + [dependency-groups].dev，uv.lock 精确锁定
- 删除 requirements.txt / requirements-fastapi.txt / requirements-dev.txt
- .python-version = 3.12；Dockerfile 改用 uv sync --frozen（可复现构建）
- 新增 jinja2（首页渲染）

## 删除 Flask 技术债
- 从 main.py 用 ast 精确剥离 56 个 Flask 节点（路由/中间件/错误处理/启动），
  框架无关的服务层落为 services/runtime.py（MusicAPIService、下载/打包 worker、
  任务监控、缓存清扫），零 Flask 依赖
- 删除 main.py（4527 行）与 auth_routes.py（1050 行）
- auth_system.py 移除会话/请求上下文层（login_session/current_user/login_required/
  admin_required/_client_ip 等），保留数据与业务层
- 新增 core/net.py（IP 解析）、web/auth_state.py（登录锁定/2FA 票据/发码限流）
- FastAPI 侧改直接依赖 services.runtime，不再 import main
- web/app.py 去掉 Flask fallback；入口默认根路径模式（API_PREFIX 可选）

## 删除 requests 技术债
- 新增 core/sync_http.py：requests 风格的同步门面（底层 aiohttp 连接池，
  流式读取经有界队列背压），含 Session/headers/(connect,read) 元组超时兼容
- core/utils、auth_system、podcast_api、music_downloader、services 全部切换
- 实测真实下载 5.2MB 音频完整成功

## 质量门禁归零
- ruff：0 错误（B904 全部修复，不再忽略）
- pyright：0 错误（类型收窄修复）
- pytest：140/140（含 golden 契约回归、root 模式 66 项路径覆盖）
- 真实 uvicorn 启动：/health、/、/static、受保护端鉴权全部正确

新增 tests/golden/responses.json：删除 Flask 前捕获的 32 例响应快照，
FastAPI 逐字段复现——删除巨石后行为回归仍有硬证据。

web/app.py

@@ -4,13 +4,8 @@
 设计（strangler 迁移）：
 - 已迁移的路由挂在 `/api/v1` 前缀下，与遗留 Flask 的同名路由（根路径）并存，
   便于逐端点比对响应契约（.zcode/refactor/parity.py）。
-- `serve_flask_fallback=True` 时，把未迁移的遗留 Flask 应用整体挂到根路径兜底，
-  实现「新端点走 FastAPI、其余走 Flask」的单进程双框架运行；迁移完成后删掉该开关。
-
-注意（默认关闭的原因）：Flask fallback 会在 FastAPI 进程内 import main，
-进而初始化 MusicAPIService / 打开 SQLite —— 与生产既有的 waitress 进程是
-两套独立进程语义。生产切换前需按计划把状态与任务模型统一（见迁移计划阶段 C），
-当前仅用于开发期联调。
+迁移已完成：Flask 巨石（main.py/auth_routes.py）已删除，本应用即唯一服务端。
+`api_prefix` 为空即直接服务前端使用的根路径；非空则挂在给定前缀下（用于契约比对）。
 """
 
 from contextlib import asynccontextmanager
@@ -64,13 +59,12 @@ def _init_audio_secret() -> None:
         pass
 
 
-def create_app(serve_flask_fallback: bool = False, api_prefix: str = '/api/v1') -> FastAPI:
+def create_app(api_prefix: str = '') -> FastAPI:
     """创建 FastAPI 应用。
 
-    api_prefix：已迁移路由的挂载前缀。
-      - '/api/v1'（默认）：与 Flask 根路径并存，便于逐端点契约比对（迁移期）
-      - ''（切换完成）：FastAPI 直接服务前端使用的根路径，不再需要 Flask 兜底
-    serve_flask_fallback：把 Flask 应用挂到根路径兜底（仅 api_prefix 非空时可用）。
+    api_prefix：路由挂载前缀。
+      - ''（默认）：直接服务前端使用的根路径（生产形态）
+      - '/api/v1'：挂在子前缀下（契约比对脚本 .zcode/refactor/parity.py 用）
     """
     _init_audio_secret()
 
@@ -112,16 +106,4 @@ def create_app(serve_flask_fallback: bool = False, api_prefix: str = '/api/v1')
 
     install_error_handlers(app)
 
-    if serve_flask_fallback and api_prefix:
-        _mount_flask_fallback(app)
-
     return app
-
-
-def _mount_flask_fallback(app: FastAPI) -> None:
-    """把遗留 Flask WSGI 应用挂到根路径，兜底未迁移的路由。"""
-    from starlette.middleware.wsgi import WSGIMiddleware
-
-    import main as legacy_flask
-
-    app.mount('/', WSGIMiddleware(legacy_flask.app))

web/auth_state.py

@@ -0,0 +1,172 @@
+# -*- coding: utf-8 -*-
+"""认证的内存态与校验辅助（原 auth_routes 的模块级状态，框架无关）。
+
+包含：登录失败锁定、管理员 2FA 票据、发码 IP 限流、用户名/保留名校验。
+这些状态**进程内共享**——登录/注册/2FA 各端点都读写同一份，避免「换个端点绕过锁定」。
+"""
+import secrets
+import time
+
+import auth_system as auth
+
+# ---- 登录失败锁定（按用户名维度，10 分钟窗口内 >=5 次临时锁定）----
+_LOGIN_FAILS: dict = {}
+_LOGIN_FAIL_SWEEP_TS = 0.0
+# 本锁定周期已落过审计日志的用户名（解锁或成功登录即重置）
+_LOGIN_FAIL_LOGGED: set = set()
+
+# ---- 管理员两步验证票据（内存态）----
+_ADMIN_2FA: dict = {}
+_ADMIN2FA_LAST_SEND: dict = {}
+
+
+_LOGIN_FAIL_LIMIT = 5
+
+
+_LOGIN_FAIL_WINDOW = 600
+
+
+_LOGIN_FAIL_SWEEP_TS = 0.0
+
+
+_ADMIN_2FA_TTL = 300            # 票据 5 分钟有效
+
+
+_ADMIN_2FA_MAX_ATTEMPTS = 5     # 邮箱比对 + 验证码合计尝试上限
+
+
+_ADMIN_2FA_MAX_TICKETS = 200    # 全局活票上限（防内存膨胀，挤掉最旧）
+
+
+_ADMIN2FA_SEND_GAP = 20         # 同账号两次发码最小间隔（秒）——第 87 条初版 60s 会卡住合法的背靠背重登（含矩阵双设备全流程），20s 已足以阻断紧密轰炸循环
+
+
+def _admin2fa_purge() -> None:
+    now = time.time()
+    for t in [t for t, v in _ADMIN_2FA.items() if now - v['ts'] > _ADMIN_2FA_TTL]:
+        _ADMIN_2FA.pop(t, None)
+
+
+def _admin2fa_mask(email: str) -> str:
+    """邮箱掩码（审计日志与前端提示用）：3*****@qq.com 样式"""
+    try:
+        local, dom = str(email).split('@', 1)
+        return (local[0] if local else '*') + '*****@' + dom
+    except Exception:
+        return '*****'
+
+
+def _admin2fa_issue(user) -> str:
+    _admin2fa_purge()
+    # 第 87 条：每管理员仅 1 张活票——新票签发即销毁同账号旧票
+    for t in [t for t, v in list(_ADMIN_2FA.items()) if v['username'] == user['username']]:
+        _ADMIN_2FA.pop(t, None)
+    if len(_ADMIN_2FA) >= _ADMIN_2FA_MAX_TICKETS:
+        items = list(_ADMIN_2FA.items())   # 快照后再 min，防并发 pop 使迭代失效
+        if items:
+            oldest = min(items, key=lambda kv: kv[1]['ts'])[0]
+            _ADMIN_2FA.pop(oldest, None)
+    ticket = secrets.token_urlsafe(16)
+    _ADMIN_2FA[ticket] = {'user_id': user['id'], 'username': user['username'],
+                          'email': user['email'], 'ts': int(time.time()), 'attempts': 0}
+    return ticket
+
+
+def _admin2fa_take(ticket: str):
+    """取活票（不销毁）：无票/过期返回 (None, None)；命中返回 (ticket, 数据)。"""
+    _admin2fa_purge()
+    v = _ADMIN_2FA.get(ticket or '')
+    if not v:
+        return None, None
+    return ticket, v
+
+
+def _login_fail_check(username: str) -> bool:
+    """返回 True 表示允许尝试登录；锁定窗口内返回 False"""
+    global _LOGIN_FAIL_SWEEP_TS
+    now = time.time()
+    fails = [t for t in _LOGIN_FAILS.get(username, []) if now - t < _LOGIN_FAIL_WINDOW]
+    _LOGIN_FAILS[username] = fails
+    if len(fails) < _LOGIN_FAIL_LIMIT:
+        _LOGIN_FAIL_LOGGED.discard(username)
+    if len(_LOGIN_FAILS) > 10000 and now - _LOGIN_FAIL_SWEEP_TS > 60:   # 容量上限（用户名为键，防无界增长）
+        _LOGIN_FAIL_SWEEP_TS = now
+        stale_users = [u for u, ts in _LOGIN_FAILS.items()
+                       if not ts or now - max(ts) > _LOGIN_FAIL_WINDOW]
+        for u in stale_users[:5000]:
+            _LOGIN_FAILS.pop(u, None)
+        if len(_LOGIN_FAILS) > 20000:
+            for u in list(_LOGIN_FAILS.keys())[:len(_LOGIN_FAILS) // 2]:
+                _LOGIN_FAILS.pop(u, None)
+    return len(fails) < _LOGIN_FAIL_LIMIT
+
+
+def _login_fail_record(username: str) -> None:
+    _LOGIN_FAILS.setdefault(username, []).append(time.time())
+
+
+def _login_fail_clear(username: str) -> None:
+    _LOGIN_FAILS.pop(username, None)
+    _LOGIN_FAIL_LOGGED.discard(username)
+
+
+def _login_fail_locked_log_once(username: str) -> bool:
+    """R5-4：锁定周期内的重复被封尝试只落一条 fail 日志，防多 IP 刷审计表；
+    解锁（窗口过期或成功登录）后进入新周期，才允许再记一条。"""
+    if username in _LOGIN_FAIL_LOGGED:
+        return False
+    _LOGIN_FAIL_LOGGED.add(username)
+    return True
+
+
+def _safe_register_credits() -> int:
+    """注册赠送次数（settings.register_credits，默认 3）。
+    R5 防呆：损坏回退默认；<0 一律按 0——设为 -1 会经 create_user 造出"不限次"新号。"""
+    try:
+        credits = int(auth.get_setting('register_credits', str(auth.DEFAULT_REGISTER_CREDITS)) or 0)
+    except (TypeError, ValueError):
+        return auth.DEFAULT_REGISTER_CREDITS
+    return max(0, credits)
+
+
+_SEND_CODE_IP = {}
+
+
+_SEND_CODE_IP_LIMIT = 10
+
+
+_SEND_CODE_IP_WINDOW = 3600
+
+
+def _send_code_ip_check(ip: str) -> bool:
+    """返回 True 表示允许发送；超限返回 False（S4：表超限时顺手清理过期项，防无界增长）"""
+    now = time.time()
+    if len(_SEND_CODE_IP) > 10000:
+        stale = [k for k, (c, w) in _SEND_CODE_IP.items() if now - w > _SEND_CODE_IP_WINDOW]
+        for k in stale:
+            _SEND_CODE_IP.pop(k, None)
+    cnt, win = _SEND_CODE_IP.get(ip, (0, now))
+    if now - win > _SEND_CODE_IP_WINDOW:
+        cnt, win = 0, now
+    if cnt >= _SEND_CODE_IP_LIMIT:
+        return False
+    _SEND_CODE_IP[ip] = (cnt + 1, win)
+    return True
+
+
+_RESERVED_USERNAMES = {'admin', 'administrator', 'qfbsh', 'root', 'system', 'moderator', '管理员', '客服'}
+
+
+def re_username_ok(username: str) -> bool:
+    import re as _re
+    # P3-10：禁纯下划线/下划线开头结尾（"____"、"___admin" 有钓鱼观感风险）
+    # R5-P3：白名单收紧为中文/字母/数字/下划线——`\w` 会放行西里尔等同形字符
+    #（"аdmin" 冒充钓鱼）；保留字（admin/qfbsh 等）一并拒绝，防冒充管理入口
+    return bool(_re.fullmatch(r'[A-Za-z0-9_\u4e00-\u9fa5]{3,20}', username)) and \
+        not _re.match(r'^_+$', username) and not username.startswith('_') and not username.endswith('_') \
+        and username.lower() not in _RESERVED_USERNAMES
+
+
+def secrets_rand() -> int:
+    import secrets as _s
+    return _s.randbelow(900000) + 100000

web/main.py

@@ -22,15 +22,11 @@ from web.app import create_app
 HOST = os.environ.get('HOST', '0.0.0.0')
 PORT = int(os.environ.get('PORT', '5000'))
 
-# 运行模式（默认保持迁移期形态，切换为显式操作）：
-#   WEB_MODE=dual（默认）已迁移路由挂 /api/v1 + Flask 兜底其余路由（前端仍走根路径→Flask）
-#   WEB_MODE=fastapi     已迁移路由直接挂根路径，完全由 FastAPI 服务（不再需要 Flask）
-WEB_MODE = os.environ.get('WEB_MODE', 'dual').strip().lower()
+# Flask 巨石已删除：本应用即唯一服务端，直接服务前端使用的根路径。
+# API_PREFIX 非空时挂在子前缀下（契约比对脚本使用）。
+API_PREFIX = os.environ.get('API_PREFIX', '').strip()
 
-if WEB_MODE == 'fastapi':
-    app = create_app(serve_flask_fallback=False, api_prefix='')
-else:
-    app = create_app(serve_flask_fallback=True, api_prefix='/api/v1')
+app = create_app(api_prefix=API_PREFIX)
 
 if __name__ == '__main__':
     uvicorn.run(

web/ratelimit.py

@@ -19,18 +19,22 @@ _EXEMPT_PATHS = {'/api/queue', '/api/batch_progress', '/api/task/heartbeat'}
 
 
 def client_ip(request: Request) -> str:
-    """客户端 IP：仅当直连方是回环（可信反代）时采信 XFF/Real-IP，与 Flask 同策略。"""
-    import auth_system
+    """客户端 IP：仅当直连方是回环（可信反代）时采信 XFF/Real-IP。
+
+    规则与 Flask 时代完全一致（core.net 与原实现同源）：XFF 最右段优先，
+    最右段为回环时回落 X-Real-IP，全部无效回落直连地址。
+    """
+    from core.net import is_loopback_ip, trusted_proxy_ip
     remote = request.client.host if request.client else '-'
-    if remote and remote != '-' and auth_system._is_loopback_ip(remote):
+    if remote and remote != '-' and is_loopback_ip(remote):
         xff = request.headers.get('x-forwarded-for')
         if xff:
-            ip = auth_system._trusted_proxy_ip(xff)
-            if ip and not auth_system._is_loopback_ip(ip):
+            ip = trusted_proxy_ip(xff)
+            if ip and not is_loopback_ip(ip):
                 return ip
         xreal = request.headers.get('x-real-ip')
         if xreal:
-            ip = auth_system._trusted_proxy_ip(xreal)
+            ip = trusted_proxy_ip(xreal)
             if ip:
                 return ip
     return remote or '-'

web/routers/auth.py

@@ -8,7 +8,7 @@
 - POST /api/v1/auth/login     ↔ Flask /auth/login（密码校验 + 失败锁定 + 管理员 2FA 转票据）
 
 设计：
-- 登录失败锁定与管理员 2FA 票据表**复用 auth_routes 的模块级状态**，两栈共享同一份
+- 登录失败锁定与管理员 2FA 票据表**复用 web.auth_state 的模块级状态**，两栈共享同一份
   计数/票据，避免「换个框架打就绕过锁定」。
 - 密码校验（PBKDF2，10 万次迭代，CPU 密集）与库操作经 asyncio.to_thread 执行，
   不阻塞事件循环。
@@ -104,7 +104,7 @@ async def ann_seen(user: Annotated[SiteUser | None, Depends(current_user)]):
 @router.post('/auth/login')
 async def login(request: Request):
     """登录：密码校验（含邮箱登录）、失败锁定、管理员两步验证转票据。"""
-    from auth_routes import (
+    from web.auth_state import (
         _admin2fa_issue,
         _admin2fa_mask,
         _login_fail_check,
@@ -201,7 +201,7 @@ async def admin_login_email(request: Request):
     """管理员 2FA Step2：比对绑定邮箱 → 发送 admin2fa 验证码。"""
     import hmac as _hmac
 
-    from auth_routes import (
+    from web.auth_state import (
         _ADMIN2FA_LAST_SEND,
         _ADMIN2FA_SEND_GAP,
         _ADMIN_2FA,
@@ -245,7 +245,7 @@ async def admin_login_email(request: Request):
 @router.post('/auth/admin_login/verify')
 async def admin_login_verify(request: Request):
     """管理员 2FA Step3：验证码原子消费 → 建立管理员会话。"""
-    from auth_routes import (
+    from web.auth_state import (
         _ADMIN_2FA,
         _ADMIN_2FA_MAX_ATTEMPTS,
         _admin2fa_take,

web/routers/download.py

@@ -115,8 +115,8 @@ async def download(user: Annotated[SiteUser | None, Depends(current_user)], requ
             lyric_format = 'lrc'
         need_zip = str(data.get('zip', 'false')).lower() in ('1', 'true', 'yes')
 
-        import main as legacy
-        downloader = legacy.api_service.downloader
+        import services.runtime as services
+        downloader = services.api_service.downloader
 
         if return_format == 'json':
             try:
@@ -127,7 +127,7 @@ async def download(user: Annotated[SiteUser | None, Depends(current_user)], requ
                 await billing.refund_open('rejected')
                 return error('获取失败：歌曲不存在或暂无版权', 404)
             base = await asyncio.to_thread(
-                legacy._build_download_base, filename_format,
+                services._build_download_base, filename_format,
                 {'name': info.name, 'artist_string': info.artists})
             filename = f'{base}.{info.file_type}'
             try:
@@ -165,7 +165,7 @@ async def download(user: Annotated[SiteUser | None, Depends(current_user)], requ
 
         # file 模式：注册后台任务
         device_id = str(data.get('device_id') or '').strip()[:64]
-        await asyncio.to_thread(legacy._touch_device, device_id)
+        await asyncio.to_thread(services._touch_device, device_id)
         task = _single_task(data, music_id, quality, filename_format, write_meta,
                             meta_fields, lyric_format, need_zip, cookies, ip, device_id)
         reg_err = await register_download_task(billing, task, str(data.get('task_id') or '').strip())
@@ -173,7 +173,7 @@ async def download(user: Annotated[SiteUser | None, Depends(current_user)], requ
             await billing.refund_open('rejected')
             return error(reg_err, 429)
         task_id = task['task_id']
-        start_err = await start_task(task_id, legacy._single_download_worker, (task_id,))
+        start_err = await start_task(task_id, services._single_download_worker, (task_id,))
         if start_err:
             return error(start_err, 500)
         return success({'task_id': task_id, 'status': 'queued'}, '下载任务已提交')
@@ -248,8 +248,8 @@ async def download_batch_zip(user: Annotated[SiteUser | None, Depends(current_us
 
         cookies = _cookies()
         device_id = str(data.get('device_id') or '').strip()[:64]
-        import main as legacy
-        await asyncio.to_thread(legacy._touch_device, device_id)
+        import services.runtime as services
+        await asyncio.to_thread(services._touch_device, device_id)
         task = {
             'type': 'batch',
             'total': len(ids), 'done': 0, 'failed': 0,
@@ -269,7 +269,7 @@ async def download_batch_zip(user: Annotated[SiteUser | None, Depends(current_us
             await billing.refund_open('rejected')
             return error(reg_err, 429)
         task_id = task['task_id']
-        start_err = await start_task(task_id, legacy._batch_zip_worker, (task_id,))
+        start_err = await start_task(task_id, services._batch_zip_worker, (task_id,))
         if start_err:
             return error(start_err, 500)
         return success({'task_id': task_id, 'status': 'queued', 'total': len(ids)},
@@ -330,8 +330,8 @@ async def podcast_download(user: Annotated[SiteUser | None, Depends(current_user
             cookies = _cookies()
 
         device_id = str(data.get('device_id') or '').strip()[:64]
-        import main as legacy
-        await asyncio.to_thread(legacy._touch_device, device_id)
+        import services.runtime as services
+        await asyncio.to_thread(services._touch_device, device_id)
         task = {
             'type': 'single',
             'total': 1, 'done': 0, 'failed': 0,
@@ -346,7 +346,7 @@ async def podcast_download(user: Annotated[SiteUser | None, Depends(current_user
             await billing.refund_open('rejected')
             return error(reg_err, 429)
         task_id = task['task_id']
-        start_err = await start_task(task_id, legacy._podcast_download_worker, (task_id,))
+        start_err = await start_task(task_id, services._podcast_download_worker, (task_id,))
         if start_err:
             return error(start_err, 500)
         return success({'task_id': task_id, 'status': 'queued'}, '播客单集下载任务已提交')
@@ -402,8 +402,8 @@ async def podcast_batch_zip(user: Annotated[SiteUser | None, Depends(current_use
 
         billed = _podcast_billing_count(data)
         device_id = str(data.get('device_id') or '').strip()[:64]
-        import main as legacy
-        await asyncio.to_thread(legacy._touch_device, device_id)
+        import services.runtime as services
+        await asyncio.to_thread(services._touch_device, device_id)
         task = {
             'type': 'batch',
             'total': 0, 'done': 0, 'failed': 0,
@@ -425,7 +425,7 @@ async def podcast_batch_zip(user: Annotated[SiteUser | None, Depends(current_use
             await billing.refund_open('rejected')
             return error(reg_err, 429)
         task_id = task['task_id']
-        start_err = await start_task(task_id, legacy._podcast_zip_worker, (task_id,))
+        start_err = await start_task(task_id, services._podcast_zip_worker, (task_id,))
         if start_err:
             return error(start_err, 500)
         return success({'task_id': task_id, 'status': 'queued'}, '播客打包任务已提交')

web/routers/register.py

@@ -11,7 +11,7 @@
 说明：
 - 同步的 auth_system 调用（SQLite 事务、邮件 SMTP、PBKDF2）经 asyncio.to_thread 执行，
   不阻塞事件循环；行为与 Flask 完全一致。
-- 发码 IP 限流复用 auth_routes 的模块级状态 `_SEND_CODE_IP`（跨栈共享计数）。
+- 发码 IP 限流复用 web.auth_state 的模块级状态 `_SEND_CODE_IP`。
 - 失败锁定/验证码消费等安全口径逐字保留。
 """
 import asyncio
@@ -64,7 +64,7 @@ async def _safe_register_credits() -> int:
 @router.post('/auth/send_code')
 async def send_code(request: Request):
     """发送邮箱验证码（注册/找回用途隔离）。"""
-    from auth_routes import _send_code_ip_check
+    from web.auth_state import _send_code_ip_check
     ip = ratelimit.client_ip(request)
     if not _send_code_ip_check(ip):
         return error('验证码请求过于频繁，请稍后再试')
@@ -141,7 +141,7 @@ async def forgot_password(request: Request):
 @router.post('/auth/register')
 async def register(request: Request):
     """注册：验证码校验 → 用户名/邮箱查重 → 防刷双闸 → 建号赠送 → 建立会话。"""
-    from auth_routes import re_username_ok
+    from web.auth_state import re_username_ok
 
     data = await _request_data(request)
     username = str(data.get('username') or '').strip()

web/routers/tasks.py

@@ -58,14 +58,14 @@ def _owned_by(task: dict[str, Any], user: SiteUser) -> bool:
 
 def _semaphores():
     """批量打包/下载信号量（Flask 侧对象，懒取以共享同一计数）。"""
-    import main as legacy
-    return legacy.BATCH_ZIP_SEM, legacy.api_service.downloader._download_semaphore
+    import services.runtime as services
+    return services.BATCH_ZIP_SEM, services.api_service.downloader._download_semaphore
 
 
 @router.api_route('/api/topen', methods=['GET', 'POST'])
 async def topen(request: Request):
     """接口请求统计（实时）——锁内快照，避免 total 与明细不一致。"""
-    import main as legacy
+    import services.runtime as services
     with STATS_LOCK:
         snapshot = {p: dict(v) for p, v in REQUEST_STATS.items()}
     endpoints = []
@@ -73,7 +73,7 @@ async def topen(request: Request):
     for path, info in snapshot.items():
         endpoints.append({
             'path': path,
-            'name': legacy.ENDPOINT_NAMES.get(path, path),
+            'name': services.ENDPOINT_NAMES.get(path, path),
             'count': info['count'],
             'percent': round(info['count'] / total * 100, 1) if total else 0,
             'last': info['last'],

web/tasks_registry.py

@@ -72,8 +72,8 @@ async def register_download_task(billing: Billing, task: dict[str, Any],
 
 
 async def start_task(task_id: str, worker: Callable, args: tuple = ()) -> str | None:
-    """启动 worker 线程（复用 main._start_task_thread 的实现，失败收敛终态并退费）。"""
+    """启动 worker 线程（复用 services 的 _start_task_thread，失败收敛终态并退费）。"""
     import asyncio
 
-    import main as legacy
-    return await asyncio.to_thread(legacy._start_task_thread, task_id, worker, args)
+    import services.runtime as services
+    return await asyncio.to_thread(services._start_task_thread, task_id, worker, args)