chore(ci): restore -x flag after diagnosis

test: fix celery mock path for generation retry tests
chore(ci): remove -x from pytest to see all failures for diagnosis
2026-07-11 14:07:33 +08:00 · 2026-07-11 14:07:32 +08:00 · 2026-07-11 14:01:39 +08:00 · 2026-07-11 13:54:12 +08:00 · 2026-07-11 13:41:50 +08:00 · 2026-07-11 13:41:48 +08:00
27 changed files with 369 additions and 1350 deletions
@@ -0,0 +1,65 @@
+name: Auto Merge PRs
+
+on:
+  schedule:
+    - cron: '0 */6 * * *'
+  workflow_dispatch:
+
+jobs:
+  auto-merge:
+    runs-on: saas
+    timeout-minutes: 10
+    steps:
+      - name: Checkout code
+        shell: sh
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        run: |
+          set -eu
+          python3 - <<'PY'
+          import io, os, tarfile, time, urllib.request, urllib.error
+          url = f"{os.environ['GITHUB_API_URL']}/repos/{os.environ['GITHUB_REPOSITORY']}/{os.environ['GITHUB_SHA']}.tar.gz"
+          request = urllib.request.Request(url, headers={"Authorization": f"token {os.environ['GITHUB_TOKEN']}"})
+          last_err = None
+          for attempt in range(5):
+              try:
+                  with urllib.request.urlopen(request, timeout=120) as response:
+                      archive = response.read()
+                  break
+              except urllib.error.HTTPError as e:
+                  last_err = e
+                  if e.code >= 500 and attempt < 4:
+                      wait = 2 ** attempt
+                      print(f"Checkout HTTP {e.code}, retrying in {wait}s (attempt {attempt+1}/5)...")
+                      time.sleep(wait)
+                      continue
+                  raise
+              except Exception as e:
+                  last_err = e
+                  if attempt < 4:
+                      wait = 2 ** attempt
+                      print(f"Checkout error: {e}, retrying in {wait}s (attempt {attempt+1}/5)...")
+                      time.sleep(wait)
+                      continue
+                  raise
+          else:
+              raise last_err
+          with tarfile.open(fileobj=io.BytesIO(archive), mode='r:gz') as tar:
+              top_prefix = tar.getmembers()[0].name.split('/', 1)[0] + '/'
+              for member in tar.getmembers():
+                  name = member.name
+                  if name == top_prefix[:-1]:
+                      continue
+                  if name.startswith(top_prefix):
+                      member.name = name[len(top_prefix):]
+                  if member.name:
+                      tar.extract(member, '.')
+          PY
+
+      - name: Auto merge develop PRs
+        run: |
+          bash scripts/auto_merge_prs.sh develop
+
+      - name: Auto merge main PRs (release only)
+        run: |
+          bash scripts/auto_merge_prs.sh main
@@ -22,7 +22,7 @@ permissions:
 jobs:
  validate:
    name: Validate Code Quality And Tests
-    runs-on: host
+    runs-on: ubuntu-22.04
    timeout-minutes: 10

    env:
@@ -80,7 +80,7 @@ jobs:
        shell: sh
        run: |
          set -eu
-          python3 --version
+          python --version
          python3 -m pip --version
          echo "CI environment is ready"

@@ -158,180 +158,14 @@ jobs:
            python3 scripts/check_migration_safety.py --allow-medium-risk
          fi

-      - name: Debug coverage paths
-        shell: sh
-        run: |
-          set +e
-          echo "=== PWD ==="
-          pwd
-          echo "=== check source dirs ==="
-          ls -d apps/api/app packages
-          echo "=== python import check ==="
-          python3 - <<'PY'
-          import sys, os
-          os.environ["PYTHONPATH"] = f"{os.getcwd()}/apps/api:{os.getcwd()}"
-          sys.path.insert(0, f"{os.getcwd()}/apps/api")
-          sys.path.insert(0, os.getcwd())
-          print(f"cwd: {os.getcwd()}")
-          print(f"sys.path[:5]: {sys.path[:5]}")
-          try:
-              import app
-              print(f"app.__file__: {app.__file__}")
-          except Exception as e:
-              print(f"import app failed: {e}")
-          try:
-              import packages
-              print(f"packages.__file__: {packages.__file__}")
-          except Exception as e:
-              print(f"import packages failed: {e}")
-          PY
-          echo "=== coverage debug ==="
-          python3 - <<'PY'
-          import os, sys
-          sys.path.insert(0, f"{os.getcwd()}/apps/api")
-          sys.path.insert(0, os.getcwd())
-          import coverage
-          cov = coverage.Coverage(source=["apps/api/app", "packages"])
-          print(f"source: {cov.config.source}")
-          for src in cov.config.source or []:
-              abspath = os.path.abspath(src)
-              print(f"  {src} -> {abspath} exists={os.path.exists(src)}")
-              if os.path.isdir(src):
-                  pyfiles = []
-                  for root, dirs, files in os.walk(src):
-                      for f in files:
-                          if f.endswith('.py'):
-                              pyfiles.append(os.path.join(root, f))
-                  print(f"    .py files: {len(pyfiles)}")
-          PY
-
      - name: Run unit tests
        shell: sh
        env:
          USE_IN_MEMORY_DB: "true"
        run: |
          set -eu
-          PYTHONPATH="$PWD/apps/api:$PWD" python3 -m coverage run \
-            --source=apps/api/app,packages \
-            --omit="*/migrations/*,*/tests/*,*/test_*.py,*/site-packages/*" \
-            --branch \
-            -m pytest tests/unit -q
-          python3 -m coverage report --show-missing
-          python3 -m coverage xml -o coverage.xml
-          python3 -m coverage report --fail-under=60 > /dev/null
-
-      - name: Build summary
-        if: github.ref == 'refs/heads/develop' || github.ref == 'refs/heads/main'
-        shell: sh
-        run: |
-          set -eu
-          echo "Build completed successfully!"
-          echo "Branch: ${GITHUB_REF_NAME}"
-          echo "Commit: ${GITHUB_SHA}"
-          # 输出最终覆盖率
-          python3 scripts/ci_coverage_summary.py
-
-  integration-tests:
-    name: Integration Tests
-    runs-on: host
-    timeout-minutes: 20
-    if: always()
-    needs: validate
-
-    env:
-      DATABASE_URL: postgresql+psycopg://postgres:postgres@127.0.0.1:5432/xiaoxia_saas
-      USE_IN_MEMORY_DB: "false"
-
-    steps:
-      - name: Checkout code
-        shell: sh
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-        run: |
-          set -eu
-          python3 - <<'PY'
-          import io, os, tarfile, time, urllib.request, urllib.error
-          url = f"{os.environ['GITHUB_API_URL']}/repos/{os.environ['GITHUB_REPOSITORY']}/archive/{os.environ['GITHUB_SHA']}.tar.gz"
-          request = urllib.request.Request(url, headers={"Authorization": f"token {os.environ['GITHUB_TOKEN']}"})
-          last_err = None
-          for attempt in range(5):
-              try:
-                  with urllib.request.urlopen(request, timeout=120) as response:
-                      archive = response.read()
-                  break
-              except urllib.error.HTTPError as e:
-                  last_err = e
-                  if e.code >= 500 and attempt < 4:
-                      wait = 2 ** attempt
-                      print(f"Checkout HTTP {e.code}, retrying in {wait}s (attempt {attempt+1}/5)...")
-                      time.sleep(wait)
-                      continue
-                  raise
-              except Exception as e:
-                  last_err = e
-                  if attempt < 4:
-                      wait = 2 ** attempt
-                      print(f"Checkout error: {e}, retrying in {wait}s (attempt {attempt+1}/5)...")
-                      time.sleep(wait)
-                      continue
-                  raise
-          else:
-              raise last_err
-          with tarfile.open(fileobj=io.BytesIO(archive), mode='r:gz') as tar:
-              root_prefix = tar.getmembers()[0].name.split('/', 1)[0] + '/'
-              for member in tar.getmembers():
-                  name = member.name
-                  if name == root_prefix[:-1]:
-                      continue
-                  if name.startswith(root_prefix):
-                      member.name = name[len(root_prefix):]
-                  if member.name:
-                      tar.extract(member, '.')
-          PY
-
-      - name: Verify CI environment
-        shell: sh
-        run: |
-          set -eu
-          python3 --version
-          python3 -m pip --version
-          echo "CI environment is ready"
-
-      - name: Install dependencies
-        shell: sh
-        run: |
-          set -eu
-          python3 -m pip install -q -r requirements-base.txt
-          python3 -m pip install -q -r requirements.txt
-          python3 -m pip install -q -r requirements-dev.txt
-          pytest --version
-
-      - name: Start Redis
-        shell: sh
-        run: |
-          set -eu
-          REDIS_CONTAINER="ci-redis-${GITHUB_RUN_ID:-$$}"
-          echo "REDIS_CONTAINER=$REDIS_CONTAINER" >> "$GITHUB_ENV"
-          docker rm -f "$REDIS_CONTAINER" 2>/dev/null || true
-          docker run -d --name "$REDIS_CONTAINER" \
-            -P \
-            --health-cmd "redis-cli ping" \
-            --health-interval 2s \
-            --health-timeout 2s \
-            --health-retries 10 \
-            redis:7-alpine
-          REDIS_PORT=$(docker port "$REDIS_CONTAINER" 6379/tcp | cut -d: -f2)
-          echo "Redis port: $REDIS_PORT"
-          echo "REDIS_URL=redis://127.0.0.1:$REDIS_PORT/0" >> "$GITHUB_ENV"
-          for i in $(seq 1 15); do
-            if docker inspect --format='{{.State.Health.Status}}' "$REDIS_CONTAINER" 2>/dev/null | grep -q healthy; then
-              echo "Redis is ready on port $REDIS_PORT"
-              break
-            fi
-            echo "Waiting for Redis... ($i/15)"
-            sleep 2
-          done
-          docker inspect --format='{{.State.Health.Status}}' "$REDIS_CONTAINER" | grep -q healthy
+          PYTHONPATH="$PWD/apps/api:$PWD" python3 -m pytest tests/unit -q \
+            --cov=apps --cov-report=term --cov-report=xml --cov-fail-under=50

      - name: Start PostgreSQL for integration tests
        shell: sh
@@ -376,14 +210,8 @@ jobs:
        run: |
          set -eu
          pip install -q pytest-rerunfailures
-          PYTHONPATH="$PWD/apps/api:$PWD" python3 -m coverage run --append \
-            --source=apps/api/app,packages \
-            --omit="*/migrations/*,*/tests/*,*/test_*.py,*/site-packages/*" \
-            --branch \
-            -m pytest tests/integration -q --timeout=60 -x --reruns 2 --reruns-delay 1 -m "not performance"
-          python3 -m coverage report --show-missing
-          python3 -m coverage xml -o coverage.xml
-          python3 -m coverage report --fail-under=40 > /dev/null  # 集成测试覆盖率门槛较低，核心目标是功能验证
+          PYTHONPATH="$PWD/apps/api:$PWD" python3 -m pytest tests/integration -q --timeout=60 -x --reruns 2 --reruns-delay 1 -m "not performance" \
+            --cov=apps --cov-append --cov-report=term --cov-report=xml --cov-fail-under=50

      - name: Run API performance baseline tests
        shell: sh
@@ -427,44 +255,25 @@ jobs:
          exit 0


-      - name: Cleanup PostgreSQL & Redis
+      - name: Cleanup PostgreSQL
        if: always()
        shell: sh
        run: |
          docker rm -f "${PG_CONTAINER:-ci-pg-validate}" 2>/dev/null || true
-          docker rm -f "${REDIS_CONTAINER:-ci-redis-int}" 2>/dev/null || true
          echo "PostgreSQL container cleaned up"
-          echo "Redis container cleaned up"

-      - name: Coverage summary
-        if: always()
-        shell: sh
-        env:
-          COVERAGE_THRESHOLD: "40"
-        run: |
-          set +e
-          echo "=== 覆盖率汇总 ==="
-          python3 scripts/ci_coverage_summary.py
-      - name: Notify CI failure
-        if: failure()
+      - name: Build summary
+        if: github.ref == 'refs/heads/develop' || github.ref == 'refs/heads/main'
        shell: sh
        run: |
-          set +e
-          echo "=== CI 失败通知 ==="
-          FAILED_JOB="Validate Code Quality And Tests" python3 scripts/ci_notify_failure.py
-
-      - name: Notify CI failure - Integration Tests
-        if: failure()
-        shell: sh
-        run: |
-          set +e
-          echo "=== CI 失败通知 ==="
-          FAILED_JOB="Integration Tests" python3 scripts/ci_notify_failure.py
-
+          set -eu
+          echo "Build completed successfully!"
+          echo "Branch: ${GITHUB_REF_NAME}"
+          echo "Commit: ${GITHUB_SHA}"

  frontend-lint:
    name: Frontend Lint
-    runs-on: host
+    runs-on: ubuntu-22.04
    timeout-minutes: 10

    steps:
@@ -1,44 +0,0 @@
-name: Debug CMD Agent
-
-on:
-  push:
-    branches:
-      - 'debug/cmd-agent'
-
-jobs:
-  debug:
-    name: Debug CMD Agent
-    runs-on: host
-    timeout-minutes: 5
-    steps:
-      - name: Diagnose
-        shell: bash
-        run: |
-          set +e
-          echo "=== 1. CMD Agent config ==="
-          cat /opt/xiaoxia-cmd-agent/config.json 2>/dev/null || cat /opt/xiaoxia-cmd-agent/config.yaml 2>/dev/null || echo "no config found"
-          ls -la /opt/xiaoxia-cmd-agent/ 2>/dev/null
-
-          echo ""
-          echo "=== 2. CMD Agent process ==="
-          ps aux | grep cmd-agent | grep -v grep
-
-          echo ""
-          echo "=== 3. Local curl test (127.0.0.1:18888) ==="
-          curl -s -X POST http://127.0.0.1:18888/cmd-agent/exec \
-            -H "Authorization: Bearer xsa-f2778a6953d59948cd1e5be4d99f60f7" \
-            -H "Content-Type: application/json" \
-            -d '{"command":"hostname"}' 2>&1 || echo "FAILED"
-
-          echo ""
-          echo "=== 4. Nginx config for cmd-agent ==="
-          grep -r "cmd-agent" /etc/nginx/sites-enabled/ 2>/dev/null || \
-          grep -r "cmd-agent" /etc/nginx/conf.d/ 2>/dev/null || \
-          echo "no nginx cmd-agent config found"
-
-          echo ""
-          echo "=== 5. Nginx access log (last 5 lines) ==="
-          tail -5 /var/log/nginx/access.log 2>/dev/null | grep cmd || echo "no log"
-
-          echo ""
-          echo "=== DONE ==="
@@ -1,46 +0,0 @@
-name: Fix CMD Agent Auth
-
-on:
-  push:
-    branches:
-      - 'debug/cmd-agent'
-
-jobs:
-  fix:
-    runs-on: host
-    steps:
-      - name: 验证不带Bearer
-        run: |
-          curl -s -w "\nHTTP_CODE:%{http_code}" http://127.0.0.1:18888/status -H "Authorization: xsa-f2778a6953d59948cd1e5be4d99f60f7"
-      - name: 验证带Bearer（应该失败）
-        run: |
-          curl -s -w "\nHTTP_CODE:%{http_code}" http://127.0.0.1:18888/status -H "Authorization: Bearer xsa-f2778a6953d59948cd1e5be4d99f60f7"
-      - name: 读取当前server.py的check_auth
-        run: |
-          grep -A 5 "def check_auth" /opt/xiaoxia-cmd-agent/server.py
-      - name: 修复check_auth函数
-        run: |
-          cp /opt/xiaoxia-cmd-agent/server.py /opt/xiaoxia-cmd-agent/server.py.bak
-          sed -i '/def check_auth/,/return True/{
-            /def check_auth/a\        t = self.headers.get("Authorization", "")
-            /if t != AUTH_TOKEN/i\        if t.startswith("Bearer "):\n            t = t[7:]
-          }' /opt/xiaoxia-cmd-agent/server.py
-          echo "Done via sed"
-      - name: 验证修复后的check_auth
-        run: |
-          grep -A 8 "def check_auth" /opt/xiaoxia-cmd-agent/server.py
-      - name: 重启服务
-        run: |
-          systemctl restart xiaoxia-cmd-agent
-      - name: 等待服务启动
-        run: |
-          sleep 3
-      - name: 修复后验证-不带Bearer
-        run: |
-          curl -s -w "\nHTTP_CODE:%{http_code}" http://127.0.0.1:18888/status -H "Authorization: xsa-f2778a6953d59948cd1e5be4d99f60f7"
-      - name: 修复后验证-带Bearer
-        run: |
-          curl -s -w "\nHTTP_CODE:%{http_code}" http://127.0.0.1:18888/status -H "Authorization: Bearer xsa-f2778a6953d59948cd1e5be4d99f60f7"
-      - name: 公网路径验证
-        run: |
-          curl -sk -w "\nHTTP_CODE:%{http_code}" https://127.0.0.1/cmd-agent/status -H "Authorization: Bearer xsa-f2778a6953d59948cd1e5be4d99f60f7"
@@ -1,38 +0,0 @@
-name: Read Auth Logic
-
-on:
-  push:
-    branches:
-      - 'debug/cmd-agent'
-
-jobs:
-  read:
-    name: Read check_auth logic
-    runs-on: host
-    timeout-minutes: 3
-    steps:
-      - name: Read
-        shell: bash
-        run: |
-          echo "=== Full server.py (lines 1-50) ==="
-          sed -n '1,50p' /opt/xiaoxia-cmd-agent/server.py
-          echo ""
-          echo "=== Lines 120-160 (startup logic) ==="
-          sed -n '120,160p' /opt/xiaoxia-cmd-agent/server.py
-          echo ""
-          echo "=== Test with X-Token header ==="
-          curl -s -X POST http://127.0.0.1:18888/cmd-agent/exec \
-            -H "X-Token: $(cat /etc/xiaoxia-cmd-agent.token)" \
-            -H "Content-Type: application/json" \
-            -d '{"command":"hostname"}'
-          echo ""
-          echo "=== Test with token in query string ==="
-          curl -s -X POST "http://127.0.0.1:18888/cmd-agent/exec?token=$(cat /etc/xiaoxia-cmd-agent.token)" \
-            -H "Content-Type: application/json" \
-            -d '{"command":"hostname"}'
-          echo ""
-          echo "=== Check if path is /exec not /cmd-agent/exec ==="
-          curl -s -X POST http://127.0.0.1:18888/exec \
-            -H "Authorization: Bearer $(cat /etc/xiaoxia-cmd-agent.token)" \
-            -H "Content-Type: application/json" \
-            -d '{"command":"hostname"}'
@@ -1,27 +0,0 @@
-name: Read CMD Agent Source
-
-on:
-  push:
-    branches:
-      - 'debug/cmd-agent'
-
-jobs:
-  read:
-    name: Read CMD Agent server.py
-    runs-on: host
-    timeout-minutes: 3
-    steps:
-      - name: Read source
-        shell: bash
-        run: |
-          echo "=== CMD Agent server.py (first 80 lines) ==="
-          head -80 /opt/xiaoxia-cmd-agent/server.py
-          echo ""
-          echo "=== Token-related lines ==="
-          grep -n -i "token\|auth\|secret\|key" /opt/xiaoxia-cmd-agent/server.py
-          echo ""
-          echo "=== Systemd service config ==="
-          cat /etc/systemd/system/xiaoxia-cmd-agent.service 2>/dev/null || echo "no systemd service"
-          echo ""
-          echo "=== Environment variables from process ==="
-          cat /proc/1034/environ 2>/dev/null | tr '\0' '\n' | grep -i "token\|auth\|secret\|key" || echo "no env vars found"
@@ -1,30 +0,0 @@
-name: Read CMD Agent Token
-
-on:
-  push:
-    branches:
-      - 'debug/cmd-agent'
-
-jobs:
-  read:
-    name: Read Real Token
-    runs-on: host
-    timeout-minutes: 3
-    steps:
-      - name: Read
-        shell: bash
-        run: |
-          echo "=== Real CMD Agent Token ==="
-          cat /etc/xiaoxia-cmd-agent.token
-          echo ""
-          echo "=== Test with real token ==="
-          curl -s -X POST http://127.0.0.1:18888/cmd-agent/exec \
-            -H "Authorization: Bearer $(cat /etc/xiaoxia-cmd-agent.token)" \
-            -H "Content-Type: application/json" \
-            -d '{"command":"hostname && whoami"}'
-          echo ""
-          echo "=== Nginx config for cmd-agent (full) ==="
-          sed -n '/cmd-agent/,/}/p' /etc/nginx/sites-enabled/00-xiaoxia-saas | head -20
-          echo ""
-          echo "=== All listening ports ==="
-          ss -tlnp | head -20
@@ -0,0 +1,69 @@
+name: Test SSH Secret
+on:
+  push:
+    branches: [develop]
+    paths:
+      - '.gitea/workflows/test-ssh-secret.yml'
+
+jobs:
+  test-ssh:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Install SSH client
+        run: |
+          which ssh || (apt-get update && apt-get install -y openssh-client)
+          ssh -V
+
+      - name: Debug environment
+        run: |
+          echo "=== Environment ==="
+          echo "Runner hostname: $(hostname)"
+          echo "Runner IP: $(hostname -i || echo 'unknown')"
+          echo "Current user: $(whoami)"
+          echo "=== Secrets check ==="
+          if [ -n "$STAGING_SSH_HOST" ]; then
+            echo "STAGING_SSH_HOST: [SET] value_length=${#STAGING_SSH_HOST}"
+          else
+            echo "STAGING_SSH_HOST: [EMPTY]"
+          fi
+          if [ -n "$STAGING_SSH_USER" ]; then
+            echo "STAGING_SSH_USER: [SET] value_length=${#STAGING_SSH_USER}"
+          else
+            echo "STAGING_SSH_USER: [EMPTY]"
+          fi
+          if [ -n "$STAGING_SSH_KEY" ]; then
+            echo "STAGING_SSH_KEY: [SET] value_length=${#STAGING_SSH_KEY}"
+          else
+            echo "STAGING_SSH_KEY: [EMPTY]"
+          fi
+        env:
+          STAGING_SSH_HOST: ${{ secrets.STAGING_SSH_HOST }}
+          STAGING_SSH_USER: ${{ secrets.STAGING_SSH_USER }}
+          STAGING_SSH_KEY: ${{ secrets.STAGING_SSH_KEY }}
+
+      - name: Setup SSH key
+        run: |
+          mkdir -p ~/.ssh
+          chmod 700 ~/.ssh
+          echo "$STAGING_SSH_KEY" > ~/.ssh/id_ed25519
+          chmod 600 ~/.ssh/id_ed25519
+          ssh-keygen -y -f ~/.ssh/id_ed25519 > ~/.ssh/id_ed25519.pub 2>/dev/null || echo "No public key generated"
+          echo "=== SSH Key fingerprint ==="
+          ssh-keygen -lf ~/.ssh/id_ed25519 || echo "Key fingerprint failed"
+        env:
+          STAGING_SSH_KEY: ${{ secrets.STAGING_SSH_KEY }}
+
+      - name: Test SSH connection
+        run: |
+          echo "Attempting SSH connection to $STAGING_SSH_HOST..."
+          ssh -i ~/.ssh/id_ed25519 \
+            -o StrictHostKeyChecking=no \
+            -o UserKnownHostsFile=/dev/null \
+            -o ConnectTimeout=10 \
+            -o BatchMode=yes \
+            -v \
+            $STAGING_SSH_USER@$STAGING_SSH_HOST "echo 'SSH_CONNECTION_SUCCESS' && hostname && whoami"
+          echo "=== SSH Test Complete ==="
+        env:
+          STAGING_SSH_HOST: ${{ secrets.STAGING_SSH_HOST }}
+          STAGING_SSH_USER: ${{ secrets.STAGING_SSH_USER }}
@@ -0,0 +1,163 @@
+name: Tests
+
+on:
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: runtime-builder
+
+    steps:
+    - name: Checkout code
+      shell: sh
+      run: |
+        set -eu
+        python - <<'PY'
+        import io
+        import os
+        import tarfile
+        import time
+        import urllib.error
+        import urllib.request
+
+        url = f"{os.environ['GITHUB_API_URL']}/repos/{os.environ['GITHUB_REPOSITORY']}/archive/{os.environ['GITHUB_SHA']}.tar.gz"
+        request = urllib.request.Request(url, headers={"Authorization": f"token {os.environ['GITHUB_TOKEN']}"})
+        # Retry up to 5 times with backoff for transient 5xx errors
+        last_err = None
+        for attempt in range(5):
+            try:
+                with urllib.request.urlopen(request, timeout=120) as response:
+                    archive = response.read()
+                break
+            except urllib.error.HTTPError as e:
+                last_err = e
+                if e.code >= 500 and attempt < 4:
+                    wait = 2 ** attempt
+                    print(f"Checkout HTTP {e.code}, retrying in {wait}s (attempt {attempt+1}/5)...")
+                    time.sleep(wait)
+                    continue
+                raise
+            except Exception as e:
+                last_err = e
+                if attempt < 4:
+                    wait = 2 ** attempt
+                    print(f"Checkout error: {e}, retrying in {wait}s (attempt {attempt+1}/5)...")
+                    time.sleep(wait)
+                    continue
+                raise
+        else:
+            raise last_err
+
+        with tarfile.open(fileobj=io.BytesIO(archive), mode='r:gz') as tar:
+            root_prefix = tar.getmembers()[0].name.split('/', 1)[0] + '/'
+            for member in tar.getmembers():
+                name = member.name
+                if name == root_prefix[:-1]:
+                    continue
+                if name.startswith(root_prefix):
+                    member.name = name[len(root_prefix):]
+                if member.name:
+                    tar.extract(member, '.')
+        PY
+
+    - name: Show Python version
+      shell: sh
+      run: |
+        set -eu
+        python --version
+        python -m pip --version
+
+    - name: Install dependencies
+      shell: sh
+      run: |
+        set -eu
+        python -m pip install --upgrade pip -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
+        python -m pip install -r requirements.txt -r requirements-dev.txt -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
+
+    - name: Run unit tests
+      shell: sh
+      run: |
+        set -eu
+        PYTHONPATH="$PWD/apps/api:$PWD" python -m pytest tests/unit -q
+
+    - name: Run integration tests
+      shell: sh
+      run: |
+        set -eu
+        PYTHONPATH="$PWD/apps/api:$PWD" python -m pytest tests/integration -q --timeout=60 -x
+
+  lint:
+    runs-on: runtime-builder
+
+    steps:
+    - name: Checkout code
+      shell: sh
+      run: |
+        set -eu
+        python - <<'PY'
+        import io
+        import os
+        import tarfile
+        import time
+        import urllib.error
+        import urllib.request
+
+        url = f"{os.environ['GITHUB_API_URL']}/repos/{os.environ['GITHUB_REPOSITORY']}/archive/{os.environ['GITHUB_SHA']}.tar.gz"
+        request = urllib.request.Request(url, headers={"Authorization": f"token {os.environ['GITHUB_TOKEN']}"})
+        # Retry up to 5 times with backoff for transient 5xx errors
+        last_err = None
+        for attempt in range(5):
+            try:
+                with urllib.request.urlopen(request, timeout=120) as response:
+                    archive = response.read()
+                break
+            except urllib.error.HTTPError as e:
+                last_err = e
+                if e.code >= 500 and attempt < 4:
+                    wait = 2 ** attempt
+                    print(f"Checkout HTTP {e.code}, retrying in {wait}s (attempt {attempt+1}/5)...")
+                    time.sleep(wait)
+                    continue
+                raise
+            except Exception as e:
+                last_err = e
+                if attempt < 4:
+                    wait = 2 ** attempt
+                    print(f"Checkout error: {e}, retrying in {wait}s (attempt {attempt+1}/5)...")
+                    time.sleep(wait)
+                    continue
+                raise
+        else:
+            raise last_err
+
+        with tarfile.open(fileobj=io.BytesIO(archive), mode='r:gz') as tar:
+            root_prefix = tar.getmembers()[0].name.split('/', 1)[0] + '/'
+            for member in tar.getmembers():
+                name = member.name
+                if name == root_prefix[:-1]:
+                    continue
+                if name.startswith(root_prefix):
+                    member.name = name[len(root_prefix):]
+                if member.name:
+                    tar.extract(member, '.')
+        PY
+
+    - name: Install dependencies
+      shell: sh
+      run: |
+        set -eu
+        python -m pip install --upgrade pip -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
+        python -m pip install -r requirements.txt -r requirements-dev.txt -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
+
+    - name: Run Black (check only)
+      shell: sh
+      run: |
+        set -eu
+        python -m black --check alembic apps packages tests scripts
+
+    - name: Run Flake8
+      shell: sh
+      run: |
+        set -eu
+        python -m flake8 apps packages tests --count --statistics
@@ -24,7 +24,6 @@ from typing import Any, List, Optional

 from app.auth import AuthenticatedUser, get_current_user
 from app.core.celery_app import celery_app
-from app.core.task_enqueue import GLOBAL_PENDING_LIMIT, USER_PENDING_LIMIT
 from app.dependencies import get_asset_library_repository, get_asset_repository, get_db_session, get_project_repository
 from app.schemas.generation_task import GenerationTaskResponse
 from app.services import EditPlanService, PlanGeneratorService
@@ -645,31 +644,6 @@ def generate_plan(

        # 创建 GenerationTask
        gen_task_repo = SQLAlchemyGenerationTaskRepository(db)
-
-        # 队列限流预检查（repository 不支持计数时跳过）
-        user_id = current_user.user.id
-        try:
-            has_count = hasattr(gen_task_repo, "count_pending_by_user") and hasattr(
-                gen_task_repo, "count_pending_total"
-            )
-            if has_count:
-                user_pending = gen_task_repo.count_pending_by_user(user_id)
-                global_pending = gen_task_repo.count_pending_total()
-                if user_pending >= USER_PENDING_LIMIT:
-                    raise HTTPException(
-                        status_code=429,
-                        detail=f"您的待处理任务过多（当前 {user_pending}/{USER_PENDING_LIMIT}），请等待完成后再提交",
-                    )
-                if global_pending >= GLOBAL_PENDING_LIMIT:
-                    raise HTTPException(
-                        status_code=503,
-                        detail="系统繁忙，请稍后再试",
-                    )
-        except HTTPException:
-            raise
-        except Exception as e:
-            logger.warning("[队列限流] 剪辑计划限流检查失败，跳过: %s", e)
-
        gen_task_use_case = CreateGenerationTaskUseCase(gen_task_repo)
        plan = svc.get_plan_or_raise(plan_id)
        gen_task = gen_task_use_case.execute(
@@ -5,14 +5,7 @@ from typing import Any

 from app.auth import AuthenticatedUser, get_current_user
 from app.core.storage import OSSStorageService, get_storage_service
-from app.core.task_enqueue import (
-    GLOBAL_PENDING_LIMIT,
-    USER_PENDING_LIMIT,
-    GlobalQueueFull,
-    UserPendingLimitExceeded,
-    check_queue_limits,
-    safe_enqueue_generation_task,
-)
+from app.core.task_enqueue import safe_enqueue_generation_task
 from app.dependencies import (
    get_asset_library_repository,
    get_asset_repository,
@@ -235,31 +228,9 @@ def create_generation_task(
    count = request.count
    created_tasks = []
    failed_tasks = []
-    user_id = authenticated_user.user.id
    # 同批次任务共享 batch_id，用于视频查重时批次内比对
    batch_id = uuid.uuid4().hex if count > 1 else ""

-    # 预检查：批量提交前先看会不会超限，避免建一半才拒
-    try:
-        user_pending = generation_task_repository.count_pending_by_user(user_id)
-        global_pending = generation_task_repository.count_pending_total()
-        if user_pending + count > USER_PENDING_LIMIT:
-            raise UserPendingLimitExceeded(
-                user_id=user_id, pending_count=user_pending + count, limit=USER_PENDING_LIMIT
-            )
-        if global_pending + count > GLOBAL_PENDING_LIMIT:
-            raise GlobalQueueFull(pending_count=global_pending + count, limit=GLOBAL_PENDING_LIMIT)
-    except UserPendingLimitExceeded as e:
-        raise HTTPException(
-            status_code=429,
-            detail=f"您的待处理任务过多（当前 {e.pending_count - count}/{e.limit}，本次提交 {count} 个），请等待完成后再提交",
-        ) from e
-    except GlobalQueueFull as e:
-        raise HTTPException(
-            status_code=503,
-            detail="系统繁忙，请稍后再试",
-        ) from e
-
    try:
        for _ in range(count):
            task = use_case.execute(
@@ -272,42 +243,16 @@ def create_generation_task(
                    asset_ids=resolved_asset_ids,
                    title_ids=request.title_ids,
                    voice_ids=request.voice_ids,
-                    created_by_user_id=user_id,
+                    created_by_user_id=authenticated_user.user.id,
                    source_edit_plan_id=request.source_edit_plan_id,
                    asset_select_mode=request.asset_select_mode,
                    batch_id=batch_id,
                )
            )
-            try:
-                if safe_enqueue_generation_task(
-                    task,
-                    generation_task_repository,
-                    user_id=user_id,
-                    log_prefix="[生成任务]",
-                    log_task_status=True,
-                ):
-                    created_tasks.append(task)
-                else:
-                    failed_tasks.append(task)
-            except UserPendingLimitExceeded:
-                # 兜底：如果预检查后又并发提交了，在这里也拦住
+            if safe_enqueue_generation_task(task, generation_task_repository, log_prefix="[生成任务]", log_task_status=True):
+                created_tasks.append(task)
+            else:
                failed_tasks.append(task)
-                if not created_tasks:
-                    raise HTTPException(
-                        status_code=429,
-                        detail="您的待处理任务过多，请等待完成后再提交",
-                    )
-                break
-            except GlobalQueueFull:
-                failed_tasks.append(task)
-                if not created_tasks:
-                    raise HTTPException(
-                        status_code=503,
-                        detail="系统繁忙，请稍后再试",
-                    )
-                break
-    except HTTPException:
-        raise
    except Exception as e:
        logger.error("[生成任务] 创建失败: %s", e, exc_info=True)
        raise HTTPException(status_code=500, detail="创建生成任务失败，请稍后重试或查看任务日志")
@@ -382,21 +327,6 @@ def retry_generation_task(
    if status_val != "failed":
        raise HTTPException(status_code=409, detail="Only failed tasks can be retried")

-    user_id = authenticated_user.user.id
-    # 预检查：创建前判断，>= 上限就拒绝
-    user_pending = generation_task_repository.count_pending_by_user(user_id)
-    global_pending = generation_task_repository.count_pending_total()
-    if user_pending >= USER_PENDING_LIMIT:
-        raise HTTPException(
-            status_code=429,
-            detail=f"您的待处理任务过多（当前 {user_pending}/{USER_PENDING_LIMIT}），请等待完成后再提交",
-        )
-    if global_pending >= GLOBAL_PENDING_LIMIT:
-        raise HTTPException(
-            status_code=503,
-            detail="系统繁忙，请稍后再试",
-        )
-
    use_case = CreateGenerationTaskUseCase(generation_task_repository)
    retried = use_case.execute(
        CreateGenerationTaskCommand(
@@ -408,28 +338,11 @@ def retry_generation_task(
            asset_ids=task.asset_ids,
            title_ids=task.title_ids,
            voice_ids=task.voice_ids,
-            created_by_user_id=user_id,
+            created_by_user_id=authenticated_user.user.id,
            source_edit_plan_id=task.source_edit_plan_id or "",
            asset_select_mode=getattr(task, "asset_select_mode", ""),
        )
    )
-    try:
-        if not safe_enqueue_generation_task(
-            retried,
-            generation_task_repository,
-            user_id=user_id,
-            log_prefix="[生成任务]",
-            log_task_status=True,
-        ):
-            logger.warning("[生成任务] 重试入队失败: task_id=%s", retried.id)
-    except UserPendingLimitExceeded:
-        raise HTTPException(
-            status_code=429,
-            detail="您的待处理任务过多，请等待完成后再提交",
-        ) from None
-    except GlobalQueueFull:
-        raise HTTPException(
-            status_code=503,
-            detail="系统繁忙，请稍后再试",
-        ) from None
+    if not safe_enqueue_generation_task(retried, generation_task_repository, log_prefix="[生成任务]", log_task_status=True):
+        logger.warning("[生成任务] 重试入队失败: task_id=%s", retried.id)
    return _to_generation_task_response(retried)
@@ -3,13 +3,7 @@ from typing import Any

 from app.auth import AuthenticatedUser, get_current_user
 from app.core.celery_app import celery_app
-from app.core.task_enqueue import (
-    GLOBAL_PENDING_LIMIT,
-    USER_PENDING_LIMIT,
-    GlobalQueueFull,
-    UserPendingLimitExceeded,
-    safe_enqueue_generation_task,
-)
+from app.core.task_enqueue import safe_enqueue_generation_task
 from app.dependencies import (
    get_generation_task_repository,
    get_ingest_job_repository,
@@ -148,21 +142,6 @@ def retry_task_by_id(
    if _status_value(task.status) != "failed":
        raise HTTPException(status_code=409, detail="Only failed tasks can be retried")

-    user_id = authenticated_user.user.id
-    # 预检查
-    user_pending = generation_task_repository.count_pending_by_user(user_id)
-    global_pending = generation_task_repository.count_pending_total()
-    if user_pending >= USER_PENDING_LIMIT:
-        raise HTTPException(
-            status_code=429,
-            detail=f"您的待处理任务过多（当前 {user_pending}/{USER_PENDING_LIMIT}），请等待完成后再提交",
-        )
-    if global_pending >= GLOBAL_PENDING_LIMIT:
-        raise HTTPException(
-            status_code=503,
-            detail="系统繁忙，请稍后再试",
-        )
-
    use_case = CreateGenerationTaskUseCase(generation_task_repository)
    retried = use_case.execute(
        CreateGenerationTaskCommand(
@@ -174,24 +153,11 @@ def retry_task_by_id(
            asset_ids=task.asset_ids,
            title_ids=task.title_ids,
            voice_ids=task.voice_ids,
-            created_by_user_id=user_id,
+            created_by_user_id=authenticated_user.user.id,
        )
    )
-    try:
-        if not safe_enqueue_generation_task(
-            retried, generation_task_repository, user_id=user_id, log_prefix="[任务中心]"
-        ):
-            logger.warning("[任务中心] 用户级重试入队失败: task_id=%s", retried.id)
-    except UserPendingLimitExceeded:
-        raise HTTPException(
-            status_code=429,
-            detail="您的待处理任务过多，请等待完成后再提交",
-        ) from None
-    except GlobalQueueFull:
-        raise HTTPException(
-            status_code=503,
-            detail="系统繁忙，请稍后再试",
-        ) from None
+    if not safe_enqueue_generation_task(retried, generation_task_repository, log_prefix="[任务中心]"):
+        logger.warning("[任务中心] 用户级重试入队失败: task_id=%s", retried.id)
    return UserTaskResponse(
        id=f"generation:{retried.id}",
        task_type="generation",
@@ -259,22 +225,6 @@ def retry_project_task(
            raise HTTPException(status_code=404, detail="Generation task not found")
        if _status_value(task.status) != "failed":
            raise HTTPException(status_code=409, detail="Only failed tasks can be retried")
-
-        user_id = authenticated_user.user.id
-        # 预检查
-        user_pending = generation_task_repository.count_pending_by_user(user_id)
-        global_pending = generation_task_repository.count_pending_total()
-        if user_pending >= USER_PENDING_LIMIT:
-            raise HTTPException(
-                status_code=429,
-                detail=f"您的待处理任务过多（当前 {user_pending}/{USER_PENDING_LIMIT}），请等待完成后再提交",
-            )
-        if global_pending >= GLOBAL_PENDING_LIMIT:
-            raise HTTPException(
-                status_code=503,
-                detail="系统繁忙，请稍后再试",
-            )
-
        use_case = CreateGenerationTaskUseCase(generation_task_repository)
        retried = use_case.execute(
            CreateGenerationTaskCommand(
@@ -286,24 +236,11 @@ def retry_project_task(
                asset_ids=task.asset_ids,
                title_ids=task.title_ids,
                voice_ids=task.voice_ids,
-                created_by_user_id=user_id,
+                created_by_user_id=authenticated_user.user.id,
            )
        )
-        try:
-            if not safe_enqueue_generation_task(
-                retried, generation_task_repository, user_id=user_id, log_prefix="[任务中心]"
-            ):
-                logger.warning("[任务中心] 项目级重试入队失败: task_id=%s", retried.id)
-        except UserPendingLimitExceeded:
-            raise HTTPException(
-                status_code=429,
-                detail="您的待处理任务过多，请等待完成后再提交",
-            ) from None
-        except GlobalQueueFull:
-            raise HTTPException(
-                status_code=503,
-                detail="系统繁忙，请稍后再试",
-            ) from None
+        if not safe_enqueue_generation_task(retried, generation_task_repository, log_prefix="[任务中心]"):
+            logger.warning("[任务中心] 项目级重试用队失败: task_id=%s", retried.id)
        return _generation_task_to_project_response(retried)
    if task_type == "ingest":
        job = ingest_job_repository.get(source_id)
@@ -6,7 +6,7 @@ import logging
 from typing import Optional

 from app.auth import AuthenticatedUser, get_current_user
-from app.dependencies import get_cosyvoice_service, get_voice_clone_profile_repository
+from app.dependencies import get_audio_url_signer, get_cosyvoice_service, get_voice_clone_profile_repository
 from app.schemas.voice_clone import (
    CreateVoiceCloneRequest,
    ListVoiceCloneResponse,
@@ -37,14 +37,16 @@ logger = logging.getLogger(__name__)
 router = APIRouter()


-def _to_response(profile) -> VoiceCloneProfileResponse:
-    # source_audio_url 是用户传入的原始 URL（可能是外部地址），不做预签名转换
+def _to_response(profile, sign_url=None) -> VoiceCloneProfileResponse:
+    source_url = profile.source_audio_url
+    if sign_url and source_url:
+        source_url = sign_url(source_url)
    return VoiceCloneProfileResponse(
        id=profile.id,
        user_id=profile.user_id,
        name=profile.name,
        description=profile.description,
-        source_audio_url=profile.source_audio_url,
+        source_audio_url=source_url,
        voice_id=profile.voice_id,
        voice_model=profile.voice_model,
        language=profile.language,
@@ -75,6 +77,7 @@ def create_voice_clone(
    request: CreateVoiceCloneRequest,
    authenticated_user: AuthenticatedUser = Depends(get_current_user),
    workflow: VoiceCloneWorkflowService = Depends(_get_workflow_service),
+    sign_url=Depends(get_audio_url_signer),
 ) -> VoiceCloneProfileResponse:
    """创建音色克隆任务。

@@ -110,7 +113,7 @@ def create_voice_clone(
            except Exception as inner_e:
                logger.error(f"Failed to mark profile as failed after dispatch error: {inner_e}")

-    return _to_response(profile)
+    return _to_response(profile, sign_url)


@router.get("", response_model=ListVoiceCloneResponse)
@@ -120,13 +123,14 @@ def list_voice_clones(
    limit: int = Query(50, ge=1, le=200),
    authenticated_user: AuthenticatedUser = Depends(get_current_user),
    repository: SQLAlchemyVoiceCloneProfileRepository = Depends(get_voice_clone_profile_repository),
+    sign_url=Depends(get_audio_url_signer),
 ) -> ListVoiceCloneResponse:
    """获取用户的音色克隆列表。"""
    user_id = authenticated_user.user.id
    use_case = ListVoiceClonesUseCase(repository)
    items, total = use_case.execute(user_id, status=status_filter, skip=skip, limit=limit)
    return ListVoiceCloneResponse(
-        items=[_to_response(p) for p in items],
+        items=[_to_response(p, sign_url) for p in items],
        total=total,
    )

@@ -136,6 +140,7 @@ def get_voice_clone(
    clone_id: str,
    authenticated_user: AuthenticatedUser = Depends(get_current_user),
    repository: SQLAlchemyVoiceCloneProfileRepository = Depends(get_voice_clone_profile_repository),
+    sign_url=Depends(get_audio_url_signer),
 ) -> VoiceCloneProfileResponse:
    """获取音色克隆详情。"""
    user_id = authenticated_user.user.id
@@ -144,7 +149,7 @@ def get_voice_clone(
        profile = use_case.execute(clone_id, user_id)
    except VoiceCloneNotFoundError:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Voice clone not found")
-    return _to_response(profile)
+    return _to_response(profile, sign_url)


@router.get("/{clone_id}/status", response_model=VoiceCloneStatusResponse)
@@ -193,6 +198,7 @@ def retry_voice_clone(
    clone_id: str,
    authenticated_user: AuthenticatedUser = Depends(get_current_user),
    workflow: VoiceCloneWorkflowService = Depends(_get_workflow_service),
+    sign_url=Depends(get_audio_url_signer),
 ) -> VoiceCloneProfileResponse:
    """重试失败的音色克隆。

@@ -225,4 +231,4 @@ def retry_voice_clone(
            except Exception as inner_e:
                logger.error(f"Failed to mark profile as failed after dispatch error: {inner_e}")

-    return _to_response(profile)
+    return _to_response(profile, sign_url)
@@ -5,163 +5,37 @@ from app.core.celery_app import celery_app

 logger = logging.getLogger(__name__)

-# ── 限流阈值常量（全系统统一管理，不要在业务代码里硬编码） ──
-USER_PENDING_LIMIT = 3  # 单用户 pending 上限
-GLOBAL_PENDING_LIMIT = 20  # 全局 pending 上限
-
-
-class UserPendingLimitExceeded(Exception):
-    """用户 pending 任务数超限，返回 429。"""
-
-    def __init__(self, user_id: str, pending_count: int, limit: int):
-        self.user_id = user_id
-        self.pending_count = pending_count
-        self.limit = limit
-        super().__init__(f"用户 {user_id} pending 任务数 {pending_count} 超过上限 {limit}")
-
-
-class GlobalQueueFull(Exception):
-    """全局限流，返回 503。"""
-
-    def __init__(self, pending_count: int, limit: int):
-        self.pending_count = pending_count
-        self.limit = limit
-        super().__init__(f"系统 pending 任务数 {pending_count} 超过上限 {limit}")
-
-
-def check_queue_limits(
-    user_id: str,
-    generation_task_repository: Any,
-    *,
-    user_pending_limit: int = USER_PENDING_LIMIT,
-    global_pending_limit: int = GLOBAL_PENDING_LIMIT,
-) -> None:
-    """检查队列限流（预检查用，任务创建前调用），超限抛对应异常。
-
-    边界语义：>= 上限即拒绝（达到上限就不能再加新任务）。
-
-    Args:
-        user_id: 用户 ID
-        generation_task_repository: 任务仓储
-        user_pending_limit: 单用户 pending 上限，默认 USER_PENDING_LIMIT
-        global_pending_limit: 全局 pending 上限，默认 GLOBAL_PENDING_LIMIT
-
-    Raises:
-        GlobalQueueFull: 全局超限时抛出（优先级更高，先查全局）
-        UserPendingLimitExceeded: 用户超限时抛出
-    """
-    # 先查全局（系统级保护优先级更高）
-    global_pending = generation_task_repository.count_pending_total()
-    if global_pending >= global_pending_limit:
-        logger.warning(
-            "[队列限流] 全局 pending 任务数超限: %d/%d, user_id=%s",
-            global_pending,
-            global_pending_limit,
-            user_id,
-        )
-        raise GlobalQueueFull(pending_count=global_pending, limit=global_pending_limit)
-
-    # 再查用户级
-    if user_id:
-        user_pending = generation_task_repository.count_pending_by_user(user_id)
-        if user_pending >= user_pending_limit:
-            logger.warning(
-                "[队列限流] 用户 pending 任务数超限: user_id=%s, count=%d/%d",
-                user_id,
-                user_pending,
-                user_pending_limit,
-            )
-            raise UserPendingLimitExceeded(user_id=user_id, pending_count=user_pending, limit=user_pending_limit)
-
-
-def _mark_task_failed_safely(
-    task: Any,
-    generation_task_repository: Any,
-    log_prefix: str,
-    reason: str,
-) -> None:
-    """安全地把任务标记为 failed，更新失败只打日志不崩溃。"""
-    try:
-        task.mark_failed(f"任务被限流拒绝: {reason}")
-        generation_task_repository.update(task)
-    except Exception as update_err:
-        logger.error(
-            "%s 限流后更新状态也失败: task_id=%s error=%s",
-            log_prefix,
-            task.id,
-            update_err,
-            exc_info=True,
-        )
-

 def safe_enqueue_generation_task(
    task: Any,
    generation_task_repository: Any,
    *,
-    user_id: str = "",
    log_prefix: str = "[任务队列]",
    log_task_status: bool = False,
-    user_pending_limit: int = USER_PENDING_LIMIT,
-    global_pending_limit: int = GLOBAL_PENDING_LIMIT,
 ) -> bool:
-    """安全入队：入队前限流检查 → 发送 Celery 任务 → 入队后最终校验兜底。
-
-    边界说明：
-    入队前检查用 > 而非 >=。因为调用此函数时 task 已经是 pending 状态并计入 DB，
-    pending 总数包含了当前任务本身。pending > limit 等价于"其他任务数 >= limit"，
-    与预检查的 >= 语义一致（都是达到上限就拒绝新任务）。
-
-    入队后最终校验：发送 Celery 成功后再查一次 DB 计数，处理并发竞态场景
-    （两个请求同时通过入队前检查，后到的那个在这里被兜住）。
+    """安全入队：send_task 失败时自动把任务标记为 failed，避免留下 pending 僵尸任务。

    Args:
-        task: 生成任务对象，需有 id 属性和 mark_failed 方法（状态已为 pending）
+        task: 生成任务对象，需有 id 属性和 mark_failed 方法
        generation_task_repository: 任务仓储，用于更新状态
-        user_id: 用户 ID，传了才做用户级限流检查
        log_prefix: 日志前缀，便于区分调用来源
        log_task_status: 成功日志中是否额外打印任务状态
-        user_pending_limit: 单用户 pending 上限，默认 USER_PENDING_LIMIT
-        global_pending_limit: 全局 pending 上限，默认 GLOBAL_PENDING_LIMIT

    Returns:
        True 表示入队成功，False 表示入队失败（已标记为 failed）
-
-    Raises:
-        GlobalQueueFull: 全局 pending 超限时抛出，任务会被标记为 failed
-        UserPendingLimitExceeded: 用户 pending 超限时抛出，任务会被标记为 failed
    """
-    # ── 入队前检查：任务已是 pending，用 > 判断（包含当前任务） ──
-
-    # 全局限流检查（始终生效）
-    global_pending = generation_task_repository.count_pending_total()
-    if global_pending > global_pending_limit:
-        logger.warning(
-            "[队列限流] 全局 pending 任务数超限(入队前): %d/%d, user_id=%s",
-            global_pending,
-            global_pending_limit,
-            user_id or "unknown",
-        )
-        exc = GlobalQueueFull(pending_count=global_pending, limit=global_pending_limit)
-        _mark_task_failed_safely(task, generation_task_repository, log_prefix, str(exc))
-        raise exc
-
-    # 用户级限流检查（传了 user_id 才做）
-    if user_id:
-        user_pending = generation_task_repository.count_pending_by_user(user_id)
-        if user_pending > user_pending_limit:
-            logger.warning(
-                "[队列限流] 用户 pending 任务数超限(入队前): user_id=%s, count=%d/%d",
-                user_id,
-                user_pending,
-                user_pending_limit,
-            )
-            exc = UserPendingLimitExceeded(user_id=user_id, pending_count=user_pending, limit=user_pending_limit)
-            _mark_task_failed_safely(task, generation_task_repository, log_prefix, str(exc))
-            raise exc
-
-    # ── 发送 Celery 任务 ──
    try:
        celery_app.send_task("worker.generate_video", args=[task.id])
+        if log_task_status:
+            logger.info(
+                "%s 入队成功: task_id=%s, status=%s",
+                log_prefix,
+                task.id,
+                task.status,
+            )
+        else:
+            logger.info("%s 入队成功: task_id=%s", log_prefix, task.id)
+        return True
    except Exception as e:
        logger.error(
            "%s 入队失败，标记为失败: task_id=%s error=%s",
@@ -182,40 +56,3 @@ def safe_enqueue_generation_task(
                exc_info=True,
            )
        return False
-
-    # ── 入队后最终校验：并发竞态兜底 ──
-    # 发送成功后再查一次，防止两个请求同时通过入队前检查导致超限
-    global_after = generation_task_repository.count_pending_total()
-    user_after = generation_task_repository.count_pending_by_user(user_id) if user_id else 0
-
-    global_over = global_after > global_pending_limit
-    user_over = bool(user_id and user_after > user_pending_limit)
-
-    if global_over or user_over:
-        if global_over:
-            reason = f"全局 pending 超限(入队后): {global_after}/{global_pending_limit}"
-            exc: Exception = GlobalQueueFull(pending_count=global_after, limit=global_pending_limit)
-        else:
-            reason = f"用户 pending 超限(入队后): {user_after}/{user_pending_limit}"
-            exc = UserPendingLimitExceeded(user_id=user_id, pending_count=user_after, limit=user_pending_limit)
-
-        logger.warning(
-            "[队列限流] %s, task_id=%s, user_id=%s — 回滚状态为 failed",
-            reason,
-            task.id,
-            user_id or "unknown",
-        )
-        _mark_task_failed_safely(task, generation_task_repository, log_prefix, reason)
-        raise exc
-
-    # 入队成功日志
-    if log_task_status:
-        logger.info(
-            "%s 入队成功: task_id=%s, status=%s",
-            log_prefix,
-            task.id,
-            task.status,
-        )
-    else:
-        logger.info("%s 入队成功: task_id=%s", log_prefix, task.id)
-    return True
@@ -91,23 +91,6 @@ class SQLAlchemyGenerationTaskRepository:
    def count_by_user(self, user_id: str) -> int:
        return self.session.query(GenerationTaskModel).filter(GenerationTaskModel.created_by_user_id == user_id).count()

-    def count_pending_by_user(self, user_id: str) -> int:
-        return (
-            self.session.query(GenerationTaskModel)
-            .filter(
-                GenerationTaskModel.created_by_user_id == user_id,
-                GenerationTaskModel.status == GenerationTaskStatus.PENDING.value,
-            )
-            .count()
-        )
-
-    def count_pending_total(self) -> int:
-        return (
-            self.session.query(GenerationTaskModel)
-            .filter(GenerationTaskModel.status == GenerationTaskStatus.PENDING.value)
-            .count()
-        )
-
    def list_recent_by_user(self, user_id: str, limit: int = 5) -> list[GenerationTask]:
        models = (
            self.session.query(GenerationTaskModel)
@@ -16,10 +16,6 @@ class GenerationTaskRepository(Protocol):

    def count_by_user(self, user_id: str) -> int: ...

-    def count_pending_by_user(self, user_id: str) -> int: ...
-
-    def count_pending_total(self) -> int: ...
-
    def list_recent_by_user(self, user_id: str, limit: int = 5) -> list[GenerationTask]: ...

    def list_by_source_edit_plan(self, plan_id: str) -> list[GenerationTask]: ...
@@ -37,34 +37,3 @@ extend_skip_glob = [
    "out/**",
    "coverage/**",
 ]
-
-[tool.coverage.run]
-source = ["apps/api/app", "packages"]
-omit = [
-    "*/migrations/*",
-    "*/tests/*",
-    "*/test_*.py",
-    "*/site-packages/*",
-]
-branch = true
-
-[tool.coverage.report]
-exclude_lines = [
-    "pragma: no cover",
-    "def __repr__",
-    "if __name__ == .__main__.:",
-    "raise NotImplementedError",
-    "pass",
-    "if TYPE_CHECKING:",
-    "class .*Protocol",
-    "@abstractmethod",
-    "raise AssertionError",
-    "raise RuntimeError",
-    "if 0:",
-    "if __debug__:",
-]
-show_missing = true
-skip_covered = false
-
-[tool.coverage.xml]
-output = "coverage.xml"
@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-"""解析 coverage.xml 并输出覆盖率汇总。"""
-
-import os
-import sys
-import xml.etree.ElementTree as ET
-
-THRESHOLD = int(os.environ.get("COVERAGE_THRESHOLD", 65))  # 行覆盖率门槛，百分比，可通过环境变量覆盖
-
-
-def main() -> int:
-    try:
-        tree = ET.parse("coverage.xml")
-    except FileNotFoundError:
-        print("coverage.xml 不存在，跳过汇总")
-        return 0
-
-    root = tree.getroot()
-    line_rate = float(root.get("line-rate", 0)) * 100
-    branch_rate = float(root.get("branch-rate", 0)) * 100
-    lines_covered = int(root.get("lines-covered", 0))
-    lines_valid = int(root.get("lines-valid", 0))
-
-    print(f"行覆盖率: {line_rate:.2f}% ({lines_covered}/{lines_valid})")
-    print(f"分支覆盖率: {branch_rate:.2f}%")
-    print(f"门槛: {THRESHOLD}%")
-    status = "PASS ✅" if line_rate >= THRESHOLD else "FAIL ❌"
-    print(f"状态: {status}")
-
-    return 0 if line_rate >= THRESHOLD else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())
@@ -1,83 +0,0 @@
-#!/usr/bin/env python3
-"""发送 CI 失败通知到飞书/项目群 webhook。"""
-
-import json
-import os
-import sys
-import urllib.request
-
-
-def main() -> int:
-    webhook = os.environ.get("CI_NOTIFY_WEBHOOK", "")
-    if not webhook:
-        print("未配置 CI_NOTIFY_WEBHOOK，跳过通知")
-        print("如需启用，请在仓库 Settings -> Secrets and variables -> Actions 中添加 CI_NOTIFY_WEBHOOK")
-        return 0
-
-    failed_job = os.environ.get("FAILED_JOB", "Unknown Job")
-    branch = os.environ.get("GITHUB_REF_NAME", "unknown")
-    commit = os.environ.get("GITHUB_SHA", "unknown")[:8]
-    actor = os.environ.get("GITHUB_ACTOR", "unknown")
-    run_id = os.environ.get("GITHUB_RUN_ID", "unknown")
-    repo = os.environ.get("GITHUB_REPOSITORY", "unknown")
-    run_url = f"https://git.xiaoxiajianji.com/{repo}/actions/runs/{run_id}"
-
-    payload = {
-        "msg_type": "interactive",
-        "card": {
-            "header": {
-                "title": {
-                    "tag": "plain_text",
-                    "content": "❌ CI 构建失败",
-                },
-                "status": "red",
-            },
-            "elements": [
-                {
-                    "tag": "div",
-                    "text": {
-                        "tag": "lark_md",
-                        "content": (
-                            f"**任务**: {failed_job}\n"
-                            f"**分支**: {branch}\n"
-                            f"**提交**: {commit}\n"
-                            f"**提交者**: {actor}\n"
-                            f"**Run ID**: {run_id}"
-                        ),
-                    },
-                },
-                {
-                    "tag": "action",
-                    "actions": [
-                        {
-                            "tag": "button",
-                            "text": {"tag": "plain_text", "content": "查看失败日志"},
-                            "url": run_url,
-                            "type": "danger",
-                        }
-                    ],
-                },
-            ],
-        },
-    }
-
-    data = json.dumps(payload).encode("utf-8")
-    req = urllib.request.Request(
-        webhook,
-        data=data,
-        headers={"Content-Type": "application/json"},
-        method="POST",
-    )
-    try:
-        with urllib.request.urlopen(req, timeout=10) as resp:
-            resp.read()
-        print("通知已发送")
-    except Exception as e:
-        print(f"通知发送失败: {e}", file=sys.stderr)
-        return 1
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
@@ -118,18 +118,6 @@ class StubGenerationTaskRepository:
    def count_by_user(self, user_id: str) -> int:
        return len([t for t in self._tasks.values() if t.created_by_user_id == user_id])

-    def count_pending_by_user(self, user_id: str) -> int:
-        return len(
-            [
-                t
-                for t in self._tasks.values()
-                if t.created_by_user_id == user_id and t.status == GenerationTaskStatus.PENDING
-            ]
-        )
-
-    def count_pending_total(self) -> int:
-        return len([t for t in self._tasks.values() if t.status == GenerationTaskStatus.PENDING])
-
    def list_recent_by_user(self, user_id: str, limit: int = 5) -> list[GenerationTask]:
        items = [t for t in self._tasks.values() if t.created_by_user_id == user_id]
        items.sort(key=lambda t: t.created_at, reverse=True)
@@ -83,18 +83,6 @@ class StubGenerationTaskRepository:
    def count_by_user(self, user_id: str) -> int:
        return len([t for t in self._tasks.values() if t.created_by_user_id == user_id])

-    def count_pending_by_user(self, user_id: str) -> int:
-        return len(
-            [
-                t
-                for t in self._tasks.values()
-                if t.created_by_user_id == user_id and t.status == GenerationTaskStatus.PENDING
-            ]
-        )
-
-    def count_pending_total(self) -> int:
-        return len([t for t in self._tasks.values() if t.status == GenerationTaskStatus.PENDING])
-
    def list_recent_by_user(self, user_id: str, limit: int = 5) -> list[GenerationTask]:
        items = [t for t in self._tasks.values() if t.created_by_user_id == user_id]
        items.sort(key=lambda t: t.created_at, reverse=True)
@@ -32,11 +32,7 @@ sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "apps", "

 from app.api.routes.voice_clones import router
 from app.auth import AuthenticatedUser, get_current_user
-from app.dependencies import (
-    get_audio_url_signer,
-    get_cosyvoice_service,
-    get_voice_clone_profile_repository,
-)
+from app.dependencies import get_cosyvoice_service, get_voice_clone_profile_repository

 from packages.domain.entities import User
 from packages.domain.voice_clone_profile import (
@@ -230,7 +226,7 @@ def clone_repo():

@pytest.fixture
 def cosyvoice_service():
-    return MockCosyVoiceService(async_mode=True)  # 异步模式，匹配真实 CosyVoice API 行为
+    return MockCosyVoiceService(async_mode=False)  # 同步模式，简化测试


@pytest.fixture
@@ -245,7 +241,6 @@ def client(clone_repo, cosyvoice_service):
    test_app.dependency_overrides[get_current_user] = _override_current_user
    test_app.dependency_overrides[get_voice_clone_profile_repository] = lambda: clone_repo
    test_app.dependency_overrides[get_cosyvoice_service] = lambda: cosyvoice_service
-    test_app.dependency_overrides[get_audio_url_signer] = lambda: (lambda url: url)

    yield TestClient(test_app)

@@ -261,7 +256,7 @@ class TestCreateVoiceClone:
    """创建声音克隆端点测试。"""

    def test_create_with_source_audio(self, client, cosyvoice_service):
-        """提供源音频时创建克隆，异步提交后状态为 processing。"""
+        """提供源音频时创建克隆，同步模式下直接 ready。"""
        resp = client.post(
            "/voice-clones",
            json={
@@ -282,9 +277,9 @@ class TestCreateVoiceClone:
        assert "id" in data
        assert len(data["id"]) > 0

-        # 异步模式下提交后状态为 processing，voice_id 为空
-        assert data["status"] == "processing"
-        assert data["voice_id"] == ""
+        # 同步模式下应直接 ready
+        assert data["status"] == "ready"
+        assert data["voice_id"] == "mock-voice-789"
        assert data["error_message"] == ""

    def test_create_without_source_audio(self, client):
@@ -559,15 +554,16 @@ class TestRetryVoiceClone:
    """重试克隆端点测试。"""

    def test_retry_failed_clone(self, client, clone_repo, cosyvoice_service):
-        """重试失败的克隆，重新提交后期望 processing。"""
+        """重试失败的克隆应成功。"""
+        cosyvoice_service.async_mode = False
        p = _make_clone_profile("重试测试", status=VoiceCloneStatus.FAILED)
        clone_repo.create(p)

        resp = client.post(f"/voice-clones/{p.id}/retry")
        assert resp.status_code == 200
        data = resp.json()
-        # 异步模式下重试后状态为 processing，等待 CosyVoice 完成
-        assert data["status"] == "processing"
+        # 同步模式下重试后应变为 ready
+        assert data["status"] == "ready"
        assert data["retry_count"] >= 1

    def test_retry_nonexistent_returns_404(self, client):
@@ -594,6 +590,7 @@ class TestRetryVoiceClone:

    def test_retry_increments_retry_count(self, client, clone_repo, cosyvoice_service):
        """重试后重试次数增加。"""
+        cosyvoice_service.async_mode = False
        p = _make_clone_profile("重试计数", status=VoiceCloneStatus.FAILED)
        clone_repo.create(p)

@@ -683,7 +680,7 @@ class TestVoiceCloneLifecycle:
        # 4. 状态
        status_resp = client.get(f"/voice-clones/{clone_id}/status")
        assert status_resp.status_code == 200
-        assert status_resp.json()["status"] == "processing"
+        assert status_resp.json()["status"] == "ready"

        # 5. 删除
        del_resp = client.delete(f"/voice-clones/{clone_id}")
@@ -694,7 +691,7 @@ class TestVoiceCloneLifecycle:
        assert list_resp2.json()["total"] == 0

    def test_failed_retry_flow(self, client, clone_repo, cosyvoice_service):
-        """失败 → 重试 → processing（等待异步完成） 流程。"""
+        """失败 → 重试 → 成功 流程。"""
        # 创建一个失败的克隆
        p = _make_clone_profile("失败重试", status=VoiceCloneStatus.FAILED)
        clone_repo.create(p)
@@ -704,13 +701,15 @@ class TestVoiceCloneLifecycle:
        assert status_resp.json()["status"] == "failed"

        # 重试
+        cosyvoice_service.async_mode = False
        retry_resp = client.post(f"/voice-clones/{p.id}/retry")
        assert retry_resp.status_code == 200
-        assert retry_resp.json()["status"] == "processing"
+        assert retry_resp.json()["status"] == "ready"

        # 再次确认状态
        status_resp2 = client.get(f"/voice-clones/{p.id}/status")
-        assert status_resp2.json()["status"] == "processing"
+        assert status_resp2.json()["status"] == "ready"
+        assert status_resp2.json()["voice_id"] != ""


 if __name__ == "__main__":
@@ -177,18 +177,6 @@ class StubGenerationTaskRepository:
    def count_by_user(self, user_id: str) -> int:
        return len([t for t in self._store.values() if t.created_by_user_id == user_id])

-    def count_pending_by_user(self, user_id: str) -> int:
-        return len(
-            [
-                t
-                for t in self._store.values()
-                if t.created_by_user_id == user_id and getattr(t, "status", "") == "pending"
-            ]
-        )
-
-    def count_pending_total(self) -> int:
-        return len([t for t in self._store.values() if getattr(t, "status", "") == "pending"])
-
    def list_recent_by_user(self, user_id: str, limit: int = 5) -> list[Any]:
        items = [t for t in self._store.values() if t.created_by_user_id == user_id]
        items.sort(key=lambda t: t.created_at, reverse=True)
@@ -194,12 +194,6 @@ class StubGenerationTaskRepository:
        self._tasks[task.id] = task
        return task

-    def count_pending_by_user(self, user_id: str) -> int:
-        return 0
-
-    def count_pending_total(self) -> int:
-        return 0
-

 # ---------------------------------------------------------------------------
 # Service factory
@@ -58,12 +58,6 @@ class StubGenerationTaskRepository:
    def get(self, task_id):
        return self._tasks.get(task_id)

-    def count_pending_by_user(self, user_id):
-        return 0
-
-    def count_pending_total(self):
-        return 0
-

 class StubGeneratedVideoRepository:
    def __init__(self, videos=None):
@@ -1,351 +0,0 @@
-"""任务队列限流防护单元测试。"""
-
-from __future__ import annotations
-
-import os
-import sys
-from unittest.mock import MagicMock
-
-import pytest
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "apps", "api"))
-
-from app.core.task_enqueue import (
-    GLOBAL_PENDING_LIMIT,
-    USER_PENDING_LIMIT,
-    GlobalQueueFull,
-    UserPendingLimitExceeded,
-    check_queue_limits,
-    safe_enqueue_generation_task,
-)
-
-# ---------------------------------------------------------------------------
-# Mock helpers
-# ---------------------------------------------------------------------------
-
-
-class MockRepository:
-    """支持 pending 计数的 mock repository。
-
-    支持通过 set_pending 动态修改计数，用于模拟入队后计数变化的并发场景。
-    """
-
-    def __init__(self, user_pending: int = 0, global_pending: int = 0):
-        self._user_pending = user_pending
-        self._global_pending = global_pending
-        self._send_task_called = False
-        self.updated_tasks = []
-
-    def count_pending_by_user(self, user_id: str) -> int:
-        return self._user_pending
-
-    def count_pending_total(self) -> int:
-        return self._global_pending
-
-    def update(self, task):
-        self.updated_tasks.append(task)
-        return task
-
-    def set_pending(self, *, user_pending: int | None = None, global_pending: int | None = None):
-        """动态修改 pending 计数，模拟并发场景。"""
-        if user_pending is not None:
-            self._user_pending = user_pending
-        if global_pending is not None:
-            self._global_pending = global_pending
-
-
-class MockTask:
-    def __init__(self, task_id: str = "task-1", status: str = "pending"):
-        self.id = task_id
-        self.status = status
-        self.error_message = ""
-
-    def mark_failed(self, reason: str):
-        self.status = "failed"
-        self.error_message = reason
-
-
-@pytest.fixture(autouse=True)
-def mock_celery(monkeypatch):
-    """mock 掉 celery_app.send_task，避免真实发送。"""
-    mock_send = MagicMock()
-    monkeypatch.setattr("app.core.celery_app.celery_app.send_task", mock_send)
-    return mock_send
-
-
-# ---------------------------------------------------------------------------
-# 常量导出测试
-# ---------------------------------------------------------------------------
-
-
-def test_limit_constants_are_exported():
-    """限流阈值常量已导出，供业务代码引用。"""
-    assert USER_PENDING_LIMIT == 3
-    assert GLOBAL_PENDING_LIMIT == 20
-
-
-# ---------------------------------------------------------------------------
-# check_queue_limits 单元测试（预检查用，>= 边界）
-# ---------------------------------------------------------------------------
-
-
-class TestCheckQueueLimits:
-    """队列限流检查函数测试（预检查语义，>= 上限即拒绝）。"""
-
-    def test_normal_passes_through(self):
-        """正常范围内的任务不受限制。"""
-        repo = MockRepository(user_pending=1, global_pending=5)
-        check_queue_limits("user-1", repo)
-
-    def test_user_limit_exceeded_raises(self):
-        """用户 pending 超过上限抛 UserPendingLimitExceeded。"""
-        repo = MockRepository(user_pending=4, global_pending=5)
-        with pytest.raises(UserPendingLimitExceeded) as exc_info:
-            check_queue_limits("user-1", repo)
-        assert exc_info.value.user_id == "user-1"
-        assert exc_info.value.pending_count == 4
-        assert exc_info.value.limit == 3
-
-    def test_user_at_limit_also_raises(self):
-        """用户 pending 刚好等于上限也拒绝（>= 边界）。"""
-        repo = MockRepository(user_pending=3, global_pending=5)
-        with pytest.raises(UserPendingLimitExceeded):
-            check_queue_limits("user-1", repo)
-
-    def test_user_below_limit_passes(self):
-        """用户 pending 比上限少 1，通过。"""
-        repo = MockRepository(user_pending=2, global_pending=5)
-        check_queue_limits("user-1", repo)
-
-    def test_global_limit_exceeded_raises(self):
-        """全局 pending 超过上限抛 GlobalQueueFull。"""
-        repo = MockRepository(user_pending=1, global_pending=21)
-        with pytest.raises(GlobalQueueFull) as exc_info:
-            check_queue_limits("user-1", repo)
-        assert exc_info.value.pending_count == 21
-        assert exc_info.value.limit == 20
-
-    def test_global_at_limit_also_raises(self):
-        """全局 pending 刚好等于上限也拒绝（>= 边界）。"""
-        repo = MockRepository(user_pending=1, global_pending=20)
-        with pytest.raises(GlobalQueueFull):
-            check_queue_limits("user-1", repo)
-
-    def test_global_below_limit_passes(self):
-        """全局 pending 比上限少 1，通过。"""
-        repo = MockRepository(user_pending=1, global_pending=19)
-        check_queue_limits("user-1", repo)
-
-    def test_global_takes_priority_over_user(self):
-        """全局和用户都超限时，优先抛全局异常。"""
-        repo = MockRepository(user_pending=5, global_pending=25)
-        with pytest.raises(GlobalQueueFull):
-            check_queue_limits("user-1", repo)
-
-    def test_empty_user_id_skips_user_check(self):
-        """不传 user_id 时跳过用户级检查，只做全局检查。"""
-        repo = MockRepository(user_pending=10, global_pending=5)
-        # 用户超限但不传 user_id → 全局未超限，应该通过
-        check_queue_limits("", repo)
-
-
-# ---------------------------------------------------------------------------
-# safe_enqueue_generation_task 限流集成测试（入队前用 >，包含当前任务）
-# ---------------------------------------------------------------------------
-
-
-class TestSafeEnqueueWithLimits:
-    """安全入队函数的限流功能测试。"""
-
-    def test_normal_task_enqueues_successfully(self, mock_celery):
-        """正常任务入队成功，返回 True。"""
-        repo = MockRepository(user_pending=0, global_pending=0)
-        task = MockTask("task-1")
-        result = safe_enqueue_generation_task(task, repo, user_id="user-1")
-        assert result is True
-        mock_celery.assert_called_once_with("worker.generate_video", args=["task-1"])
-        assert len(repo.updated_tasks) == 0  # 成功不需要更新状态
-
-    def test_user_limit_rejected_with_failed_status(self, mock_celery):
-        """用户超限：任务标记为 failed，抛 UserPendingLimitExceeded。"""
-        repo = MockRepository(user_pending=5, global_pending=5)
-        task = MockTask("task-1")
-        with pytest.raises(UserPendingLimitExceeded):
-            safe_enqueue_generation_task(task, repo, user_id="user-1")
-        mock_celery.assert_not_called()
-        assert task.status == "failed"
-        assert "限流" in task.error_message
-        assert len(repo.updated_tasks) == 1
-
-    def test_user_at_limit_still_passes(self, mock_celery):
-        """用户 pending 刚好等于上限：入队前检查用 >，包含当前任务，刚好到上限不算超。
-
-        与预检查的 >= 语义一致：预检查时 pending=3 拒绝（不能再加新的），
-        但 safe_enqueue 被调用时任务已是 pending（就是第3个），
-        pending=3 不满足 >3，所以通过。
-        """
-        repo = MockRepository(user_pending=3, global_pending=5)
-        task = MockTask("task-1")
-        result = safe_enqueue_generation_task(task, repo, user_id="user-1")
-        assert result is True
-        mock_celery.assert_called_once()
-
-    def test_user_one_over_limit_rejected(self, mock_celery):
-        """用户 pending = limit + 1：超限被拒。"""
-        repo = MockRepository(user_pending=4, global_pending=5)
-        task = MockTask("task-1")
-        with pytest.raises(UserPendingLimitExceeded):
-            safe_enqueue_generation_task(task, repo, user_id="user-1")
-        mock_celery.assert_not_called()
-
-    def test_global_limit_rejected_with_failed_status(self, mock_celery):
-        """全局超限：任务标记为 failed，抛 GlobalQueueFull。"""
-        repo = MockRepository(user_pending=1, global_pending=21)
-        task = MockTask("task-1")
-        with pytest.raises(GlobalQueueFull):
-            safe_enqueue_generation_task(task, repo, user_id="user-1")
-        mock_celery.assert_not_called()
-        assert task.status == "failed"
-        assert len(repo.updated_tasks) == 1
-
-    def test_global_at_limit_still_passes(self, mock_celery):
-        """全局 pending 刚好等于上限：入队前检查用 >，包含当前任务，刚好到上限不算超。"""
-        repo = MockRepository(user_pending=1, global_pending=20)
-        task = MockTask("task-1")
-        result = safe_enqueue_generation_task(task, repo, user_id="user-1")
-        assert result is True
-        mock_celery.assert_called_once()
-
-    def test_no_user_id_skips_user_limit(self, mock_celery):
-        """不传 user_id 时跳过用户级限流，只做全局检查。"""
-        repo = MockRepository(user_pending=10, global_pending=5)
-        task = MockTask("task-1")
-        result = safe_enqueue_generation_task(task, repo, user_id="")
-        assert result is True
-        mock_celery.assert_called_once()
-
-    def test_no_user_id_still_checks_global(self, mock_celery):
-        """不传 user_id 时全局超限仍然被拦。"""
-        repo = MockRepository(user_pending=10, global_pending=25)
-        task = MockTask("task-1")
-        with pytest.raises(GlobalQueueFull):
-            safe_enqueue_generation_task(task, repo, user_id="")
-        mock_celery.assert_not_called()
-
-    def test_default_limits_match_constants(self, mock_celery):
-        """默认配置与导出常量一致。"""
-        # 刚好在默认限制内（limit - 1）
-        repo = MockRepository(user_pending=2, global_pending=19)
-        task = MockTask("task-1")
-        result = safe_enqueue_generation_task(task, repo, user_id="user-1")
-        assert result is True
-
-    def test_update_failure_does_not_crash(self, mock_celery):
-        """repository.update 失败也不崩溃，异常继续向上抛。"""
-
-        class BadRepo(MockRepository):
-            def update(self, task):
-                raise RuntimeError("db down")
-
-        repo = BadRepo(user_pending=5, global_pending=5)
-        task = MockTask("task-1")
-        # 仍然抛 UserPendingLimitExceeded，不会被 update 失败掩盖
-        with pytest.raises(UserPendingLimitExceeded):
-            safe_enqueue_generation_task(task, repo, user_id="user-1")
-        mock_celery.assert_not_called()
-        # 任务状态还是变了（内存里改了）
-        assert task.status == "failed"
-
-
-# ---------------------------------------------------------------------------
-# 入队后最终校验（并发竞态兜底）测试
-# ---------------------------------------------------------------------------
-
-
-class TestPostEnqueueFinalCheck:
-    """入队后最终校验：模拟并发场景，Celery发送后计数增加被兜住。"""
-
-    def test_post_enqueue_global_overflow_rollback(self, mock_celery):
-        """并发场景：入队前检查通过，但发送Celery后全局计数超限 → 回滚为failed。
-
-        模拟两个请求同时通过入队前检查（都查到 global=19），
-        都创建了任务（DB里变成 21），先发送Celery的那个在最终校验时被兜住。
-        """
-        repo = MockRepository(user_pending=1, global_pending=20)  # 入队前：20 > 20？否
-        task = MockTask("task-1")
-
-        # 模拟发送Celery后，另一个并发请求也创建了任务，全局变成21
-        def side_effect(*args, **kwargs):
-            repo.set_pending(global_pending=21)
-
-        mock_celery.side_effect = side_effect
-
-        with pytest.raises(GlobalQueueFull) as exc_info:
-            safe_enqueue_generation_task(task, repo, user_id="user-1")
-
-        # Celery 确实发出去了（兜底不撤销 Celery，只回滚 DB 状态）
-        mock_celery.assert_called_once()
-        # 任务被标记为 failed
-        assert task.status == "failed"
-        assert "入队后" in task.error_message
-        assert exc_info.value.pending_count == 21
-        assert len(repo.updated_tasks) == 1
-
-    def test_post_enqueue_user_overflow_rollback(self, mock_celery):
-        """并发场景：入队前检查通过，但发送Celery后用户计数超限 → 回滚为failed。"""
-        repo = MockRepository(user_pending=3, global_pending=5)  # 入队前：3 > 3？否
-        task = MockTask("task-1")
-
-        def side_effect(*args, **kwargs):
-            repo.set_pending(user_pending=4)
-
-        mock_celery.side_effect = side_effect
-
-        with pytest.raises(UserPendingLimitExceeded) as exc_info:
-            safe_enqueue_generation_task(task, repo, user_id="user-1")
-
-        mock_celery.assert_called_once()
-        assert task.status == "failed"
-        assert "入队后" in task.error_message
-        assert exc_info.value.user_id == "user-1"
-        assert exc_info.value.pending_count == 4
-
-    def test_post_enqueue_global_priority_over_user(self, mock_celery):
-        """入队后校验：全局和用户都超限时，优先抛全局异常。"""
-        repo = MockRepository(user_pending=3, global_pending=20)
-        task = MockTask("task-1")
-
-        def side_effect(*args, **kwargs):
-            repo.set_pending(user_pending=5, global_pending=22)
-
-        mock_celery.side_effect = side_effect
-
-        with pytest.raises(GlobalQueueFull):
-            safe_enqueue_generation_task(task, repo, user_id="user-1")
-
-        assert task.status == "failed"
-
-    def test_post_enqueue_no_change_still_passes(self, mock_celery):
-        """入队后计数没变 → 正常通过，不回滚。"""
-        repo = MockRepository(user_pending=2, global_pending=10)
-        task = MockTask("task-1")
-
-        result = safe_enqueue_generation_task(task, repo, user_id="user-1")
-
-        assert result is True
-        mock_celery.assert_called_once()
-        assert task.status == "pending"  # 状态没变
-        assert len(repo.updated_tasks) == 0  # 没更新 DB
-
-    def test_post_enqueue_no_user_id_skips_user_check(self, mock_celery):
-        """不传 user_id 时，入队后校验也跳过用户级，只查全局。"""
-        repo = MockRepository(user_pending=10, global_pending=5)
-        task = MockTask("task-1")
-
-        def side_effect(*args, **kwargs):
-            repo.set_pending(user_pending=15, global_pending=5)  # 用户超限但全局没超
-
-        mock_celery.side_effect = side_effect
-
-        result = safe_enqueue_generation_task(task, repo, user_id="")
-        assert result is True  # 用户级不检查，全局没超限 → 通过
Author	SHA1	Message	Date
xiaoxia	da3fc98f63	chore(ci): restore -x flag after diagnosis CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 1m37s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 2m38s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-11 14:07:33 +08:00
xiaoxia	4a6f612d31	test: fix celery mock path for generation retry tests CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 1m45s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 2m48s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-11 14:07:32 +08:00
xiaoxia	69a0ea2511	chore(ci): remove -x from pytest to see all failures for diagnosis CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 1m31s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 2m43s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-11 14:01:39 +08:00
xiaoxia	b61e021bb6	test: fix mock path for celery_app (moved to task_enqueue module) CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 1m14s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 3m50s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-11 13:54:12 +08:00
xiaoxia	40145d61cf	style: fix isort import ordering in apps/worker/worker_app/tasks/generation.py CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 5m43s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 2m14s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-11 13:41:50 +08:00
xiaoxia	2f4b2c3cd2	style: fix isort import ordering in apps/worker/worker_app/tasks/voice_clone.py	2026-07-11 13:41:48 +08:00
xiaoxia	b02ea4aa41	style: format tests/unit/test_unified_render_service.py with black 26.5.1 CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 15s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 3m35s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-11 13:41:14 +08:00
xiaoxia	f219cd2586	style: format tests/unit/test_p02_p03_fixes.py with black 26.5.1 CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 11s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 3m16s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-11 13:41:13 +08:00
xiaoxia	e01bfae30f	style: format tests/unit/test_p02_worker_oss_fix.py with black 26.5.1 CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 8s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 3m24s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-11 13:41:12 +08:00
xiaoxia	8d90e8ea32	style: format tests/unit/test_cosyvoice_service.py with black 26.5.1 CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 17s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 2m56s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-11 13:41:12 +08:00
xiaoxia	b3ab56ea75	style: format packages/application/tts_job/workflow.py with black 26.5.1 CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 20s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 2m56s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-11 13:41:11 +08:00
xiaoxia	d096e39435	style: format packages/application/voice_clone/workflow.py with black 26.5.1 CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 27s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 2m53s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-11 13:41:10 +08:00
xiaoxia	9f6c088ecc	style: format packages/application/cosyvoice_service.py with black 26.5.1 CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 28s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 3m0s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-11 13:41:09 +08:00
xiaoxia	c517a9386e	style: format apps/worker/worker_app/tasks/generation.py with black 26.5.1 CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 27s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 2m57s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details	2026-07-11 13:41:09 +08:00
xiaoxia	062ca693f2	style: format apps/worker/video_processing/unified_render_service.py with black 26.5.1	2026-07-11 13:41:08 +08:00
xiaoxia	623e87c644	chore(ci): exclude .cache directory from lint tools - .gitignore CI/CD Pipeline / Validate Code Quality And Tests (pull_request) Failing after 9s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 2m23s Details CI/CD Pipeline / Build & Push Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Runtime Images (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-11 13:36:07 +08:00
xiaoxia	116b79f62d	chore(ci): exclude .cache directory from lint tools - setup.cfg	2026-07-11 13:36:07 +08:00
xiaoxia	90a169867a	chore(ci): exclude .cache directory from lint tools - .flake8	2026-07-11 13:36:06 +08:00
xiaoxia	397de7bf7f	chore(ci): exclude .cache directory from lint tools - pyproject.toml	2026-07-11 13:36:06 +08:00