feat: M1-01~03 — AI Gateway deepening, Vector module, Task Queue deepening

M1-01 AI Gateway:
- DB-driven ModelRoute/ProviderConfig/FallbackEvent tables
- ModelRouter rewrite with loadFromDb() hot-reload
- Fallback event recording + AIUsageRecorded event publishing
- Admin AAPI: routes CRUD, provider enable/disable, fallback events log

M1-02 Vector & Retrieval:
- VectorService with Qdrant client (upsert/delete/search/rerank)
- Admin AAPI: collection status, vector count, reindex trigger

M1-03 Task Queue:
- 16 task types with default retry/timeout configs
- Task stats dashboard, worker status panel, batch retry endpoint

M0 audit fixes:
- ApiMetric retention policy (30-day cleanup)
- Content Safety integration in Files module
- Queue registration centralized (domain-events)
- SECRET_MASTER_KEY production validation

E2E tests:
- M0: 28 smoke tests covering all 14 M0 issues
- M1: 16 tests covering M1-01/02/03
- Mock infrastructure: prisma, ioredis, jose, bullmq, qdrant

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

package-lock.json

@@ -21,6 +21,7 @@
         "@nestjs/swagger": "^11.4.2",
         "@nestjs/throttler": "^6.5.0",
         "@prisma/client": "^5.22.0",
+        "@qdrant/js-client-rest": "^1.18.0",
         "bcryptjs": "^3.0.3",
         "class-transformer": "^0.5.1",
         "class-validator": "^0.15.1",
@@ -2860,6 +2861,33 @@
         "@prisma/debug": "5.22.0"
       }
     },
+    "node_modules/@qdrant/js-client-rest": {
+      "version": "1.18.0",
+      "resolved": "https://registry.npmmirror.com/@qdrant/js-client-rest/-/js-client-rest-1.18.0.tgz",
+      "integrity": "sha512-/0dqX5uV9chC1DnYSnU4gNMrDqse/pt6hHg3Rqqpl5isH7xl1xSNvffjzBoxycDD79luWn7Ho6Rh/61sOs5DNw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@qdrant/openapi-typescript-fetch": "1.2.6",
+        "undici": "^6.24.0"
+      },
+      "engines": {
+        "node": ">=18.17.0",
+        "pnpm": ">=8"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.7"
+      }
+    },
+    "node_modules/@qdrant/openapi-typescript-fetch": {
+      "version": "1.2.6",
+      "resolved": "https://registry.npmmirror.com/@qdrant/openapi-typescript-fetch/-/openapi-typescript-fetch-1.2.6.tgz",
+      "integrity": "sha512-oQG/FejNpItrxRHoyctYvT3rwGZOnK4jr3JdppO/c78ktDvkWiPXPHNsrDf33K9sZdRb6PR7gi4noIapu5q4HA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0",
+        "pnpm": ">=8"
+      }
+    },
     "node_modules/@scarf/scarf": {
       "version": "1.4.0",
       "resolved": "https://registry.npmmirror.com/@scarf/scarf/-/scarf-1.4.0.tgz",
@@ -10908,7 +10936,6 @@
       "version": "5.9.3",
       "resolved": "https://registry.npmmirror.com/typescript/-/typescript-5.9.3.tgz",
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
-      "dev": true,
       "license": "Apache-2.0",
       "peer": true,
       "bin": {
@@ -10981,6 +11008,15 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/undici": {
+      "version": "6.25.0",
+      "resolved": "https://registry.npmmirror.com/undici/-/undici-6.25.0.tgz",
+      "integrity": "sha512-ZgpWDC5gmNiuY9CnLVXEH8rl50xhRCuLNA97fAUnKi8RRuV4E6KG31pDTsLVUKnohJE0I3XDrTeEydAXRw47xg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.17"
+      }
+    },
     "node_modules/undici-types": {
       "version": "7.16.0",
       "resolved": "https://registry.npmmirror.com/undici-types/-/undici-types-7.16.0.tgz",

package.json

@@ -36,6 +36,7 @@
     "@nestjs/swagger": "^11.4.2",
     "@nestjs/throttler": "^6.5.0",
     "@prisma/client": "^5.22.0",
+    "@qdrant/js-client-rest": "^1.18.0",
     "bcryptjs": "^3.0.3",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.15.1",

prisma/migrations/20260524000000_add_model_route/migration.sql

@@ -0,0 +1,60 @@
+-- CreateTable
+CREATE TABLE `ModelRoute` (
+    `id` VARCHAR(191) NOT NULL,
+    `tier` VARCHAR(32) NOT NULL,
+    `taskType` VARCHAR(32) NOT NULL DEFAULT '*',
+    `preferredProvider` VARCHAR(32) NOT NULL,
+    `preferredModel` VARCHAR(100) NOT NULL,
+    `fallbackProvider` VARCHAR(32) NOT NULL,
+    `fallbackModel` VARCHAR(100) NOT NULL,
+    `maxRetries` INTEGER NOT NULL DEFAULT 2,
+    `isActive` BOOLEAN NOT NULL DEFAULT true,
+    `createdBy` VARCHAR(100) NULL,
+    `createdAt` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+    `updatedAt` DATETIME(3) NOT NULL,
+
+    UNIQUE INDEX `ModelRoute_tier_taskType_key`(`tier`, `taskType`),
+    PRIMARY KEY (`id`)
+) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+-- CreateTable
+CREATE TABLE `ProviderConfig` (
+    `id` VARCHAR(191) NOT NULL,
+    `name` VARCHAR(32) NOT NULL,
+    `enabled` BOOLEAN NOT NULL DEFAULT true,
+    `baseUrl` VARCHAR(255) NULL,
+    `updatedBy` VARCHAR(100) NULL,
+    `createdAt` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+    `updatedAt` DATETIME(3) NOT NULL,
+
+    UNIQUE INDEX `ProviderConfig_name_key`(`name`),
+    PRIMARY KEY (`id`)
+) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+-- CreateTable
+CREATE TABLE `FallbackEvent` (
+    `id` VARCHAR(191) NOT NULL,
+    `tier` VARCHAR(32) NOT NULL,
+    `taskType` VARCHAR(32) NOT NULL,
+    `fromProvider` VARCHAR(32) NOT NULL,
+    `fromModel` VARCHAR(100) NOT NULL,
+    `toProvider` VARCHAR(32) NOT NULL,
+    `toModel` VARCHAR(100) NOT NULL,
+    `errorMessage` VARCHAR(500) NULL,
+    `createdAt` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+
+    PRIMARY KEY (`id`)
+) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+-- Seed default routes
+INSERT INTO `ModelRoute` (`id`, `tier`, `taskType`, `preferredProvider`, `preferredModel`, `fallbackProvider`, `fallbackModel`, `maxRetries`) VALUES
+('route-cheap-default', 'cheap', '*', 'deepseek', 'deepseek-v4-flash', 'deepseek', 'deepseek-v4-flash', 2),
+('route-primary-default', 'primary', '*', 'minimax', 'minimax-m2.7', 'deepseek', 'deepseek-v4-pro', 3),
+('route-strong-default', 'strong', '*', 'deepseek', 'deepseek-v4-pro', 'deepseek', 'deepseek-v4-pro', 3);
+
+-- Seed provider configs
+INSERT INTO `ProviderConfig` (`id`, `name`, `enabled`) VALUES
+('prov-deepseek', 'deepseek', true),
+('prov-minimax', 'minimax', true),
+('prov-siliconflow', 'siliconflow', true),
+('prov-mock', 'mock', false);

prisma/schema.prisma

@@ -577,6 +577,45 @@ model AiUsageLog {
   @@index([createdAt])
 }
 
+model ModelRoute {
+  id                String   @id @default(cuid())
+  tier              String   @db.VarChar(32)
+  taskType          String   @default("*") @db.VarChar(32)
+  preferredProvider String   @db.VarChar(32)
+  preferredModel    String   @db.VarChar(100)
+  fallbackProvider  String   @db.VarChar(32)
+  fallbackModel     String   @db.VarChar(100)
+  maxRetries        Int      @default(2)
+  isActive          Boolean  @default(true)
+  createdBy         String?  @db.VarChar(100)
+  createdAt         DateTime @default(now())
+  updatedAt         DateTime @updatedAt
+
+  @@unique([tier, taskType])
+}
+
+model ProviderConfig {
+  id        String   @id @default(cuid())
+  name      String   @unique @db.VarChar(32)
+  enabled   Boolean  @default(true)
+  baseUrl   String?  @db.VarChar(255)
+  updatedBy String?  @db.VarChar(100)
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+model FallbackEvent {
+  id           String   @id @default(cuid())
+  tier         String   @db.VarChar(32)
+  taskType     String   @db.VarChar(32)
+  fromProvider String   @db.VarChar(32)
+  fromModel    String   @db.VarChar(100)
+  toProvider   String   @db.VarChar(32)
+  toModel      String   @db.VarChar(100)
+  errorMessage String?  @db.VarChar(500)
+  createdAt    DateTime @default(now())
+}
+
 model WaitlistEntry {
   id          String   @id @default(cuid())
   nickname    String   @db.VarChar(100)

src/app.module.ts

@@ -47,6 +47,7 @@ import { WaitlistModule } from './modules/waitlist/waitlist.module';
 import { KnowledgeSourceModule } from './modules/knowledge-source/knowledge-source.module';
 import { ImportCandidateModule } from './modules/import-candidate/import-candidate.module';
 import { RagModule } from './modules/rag/rag.module';
+import { VectorModule } from './modules/vector/vector.module';
 
 import { JwtAuthGuard } from './common/guards/jwt-auth.guard';
 import { RolesGuard } from './common/guards/roles.guard';
@@ -129,6 +130,7 @@ import appleConfig from './config/apple.config';
     ImportCandidateModule,
     DocumentImportModule,
     RagModule,
+    VectorModule,
     LearningSessionModule,
     ActiveRecallModule,
     AiAnalysisModule,

src/common/event-bus/event-bus.module.ts

@@ -2,8 +2,7 @@ import { Global, Module } from '@nestjs/common';
 import { EventEmitterModule } from '@nestjs/event-emitter';
 import { BullModule } from '@nestjs/bullmq';
 import { EventBusService } from './event-bus.service';
-
+import { QUEUE_DOMAIN_EVENTS } from '../../infrastructure/queue/queue.service';
-export const QUEUE_DOMAIN_EVENTS = 'domain-events';
 
 @Global()
 @Module({

src/infrastructure/queue/queue.module.ts

@@ -2,7 +2,7 @@ import { Global, Module } from '@nestjs/common';
 import { BullModule } from '@nestjs/bullmq';
 import { ConfigService } from '@nestjs/config';
 import { PrismaService } from '../database/prisma.service';
-import { QueueService, QUEUE_AI_ANALYSIS, QUEUE_AUDIT_LOG, QUEUE_FILE_CLEANUP, QUEUE_DOCUMENT_IMPORT, QUEUE_NOTIFICATION } from './queue.service';
+import { QueueService, QUEUE_AI_ANALYSIS, QUEUE_AUDIT_LOG, QUEUE_FILE_CLEANUP, QUEUE_DOCUMENT_IMPORT, QUEUE_NOTIFICATION, QUEUE_DOMAIN_EVENTS } from './queue.service';
 
 @Global()
 @Module({
@@ -28,6 +28,7 @@ import { QueueService, QUEUE_AI_ANALYSIS, QUEUE_AUDIT_LOG, QUEUE_FILE_CLEANUP, Q
       { name: QUEUE_AI_ANALYSIS },
       { name: QUEUE_DOCUMENT_IMPORT },
       { name: QUEUE_NOTIFICATION },
+      { name: QUEUE_DOMAIN_EVENTS },
       { name: QUEUE_AUDIT_LOG },
       { name: QUEUE_FILE_CLEANUP },
     ),

src/infrastructure/queue/queue.service.ts

@@ -8,6 +8,7 @@ import { Queue } from 'bullmq';
 export const QUEUE_AI_ANALYSIS = 'ai-analysis';
 export const QUEUE_DOCUMENT_IMPORT = 'document-import';
 export const QUEUE_NOTIFICATION = 'notification';
+export const QUEUE_DOMAIN_EVENTS = 'domain-events';
 export const QUEUE_AUDIT_LOG = 'audit-logs';
 export const QUEUE_FILE_CLEANUP = 'file-cleanup';
 

src/infrastructure/queue/task-types.ts

@@ -1,6 +1,16 @@
 export enum TaskType {
   DOCUMENT_IMPORT = 'document-import',
+  OCR_PROCESS = 'ocr-process',
+  VISION_ANALYZE = 'vision-analyze',
+  EMBEDDING_GENERATE = 'embedding-generate',
+  INDEXING_UPSERT = 'indexing-upsert',
+  GENERATE_ARTIFACT = 'generate-artifact',
   AI_ANALYSIS = 'ai-analysis',
+  GENERATE_REVIEW_CARD = 'generate-review-card',
+  BACKUP_EXECUTE = 'backup-execute',
+  CLEANUP_EXECUTE = 'cleanup-execute',
+  AGENT_TASK = 'agent-task',
+  REPORT_GENERATE = 'report-generate',
   NOTIFICATION = 'notification',
   DOMAIN_EVENTS = 'domain-events',
   AUDIT_LOG = 'audit-logs',
@@ -9,9 +19,57 @@ export enum TaskType {
 
 export const TASK_LABELS: Record<string, string> = {
   'document-import': '文档导入',
+  'ocr-process': 'OCR 处理',
+  'vision-analyze': 'Vision 分析',
+  'embedding-generate': 'Embedding 生成',
+  'indexing-upsert': '向量索引',
+  'generate-artifact': '学习工件生成',
   'ai-analysis': 'AI 分析',
+  'generate-review-card': '复习卡片生成',
+  'backup-execute': '备份执行',
+  'cleanup-execute': '清理执行',
+  'agent-task': 'Agent 任务',
+  'report-generate': '报表生成',
   'notification': '消息通知',
   'domain-events': '领域事件',
   'audit-logs': '审计日志',
   'file-cleanup': '文件清理',
 };
+
+export interface TaskTypeConfig {
+  type: string;
+  maxRetries: number;
+  backoffDelay: number;
+  timeoutMs: number;
+  label: string;
+}
+
+const DEFAULTS: Record<string, Partial<TaskTypeConfig>> = {
+  'document-import': { maxRetries: 3, timeoutMs: 300_000 },
+  'ocr-process': { maxRetries: 2, timeoutMs: 120_000 },
+  'vision-analyze': { maxRetries: 2, timeoutMs: 120_000 },
+  'embedding-generate': { maxRetries: 3, timeoutMs: 60_000 },
+  'indexing-upsert': { maxRetries: 2, timeoutMs: 30_000 },
+  'generate-artifact': { maxRetries: 2, timeoutMs: 120_000 },
+  'ai-analysis': { maxRetries: 3, timeoutMs: 180_000 },
+  'generate-review-card': { maxRetries: 2, timeoutMs: 180_000 },
+  'backup-execute': { maxRetries: 1, timeoutMs: 600_000 },
+  'cleanup-execute': { maxRetries: 1, timeoutMs: 300_000 },
+  'agent-task': { maxRetries: 3, timeoutMs: 300_000 },
+  'report-generate': { maxRetries: 1, timeoutMs: 120_000 },
+};
+
+export function getTaskConfig(taskType: string): TaskTypeConfig {
+  const overrides = DEFAULTS[taskType] || {};
+  return {
+    type: taskType,
+    maxRetries: overrides.maxRetries ?? 2,
+    backoffDelay: overrides.backoffDelay ?? 1000,
+    timeoutMs: overrides.timeoutMs ?? 60_000,
+    label: TASK_LABELS[taskType] || taskType,
+  };
+}
+
+export function getAllTaskConfigs(): TaskTypeConfig[] {
+  return Object.keys(TASK_LABELS).map(getTaskConfig);
+}

src/infrastructure/queue/worker-heartbeat.ts

@@ -10,10 +10,27 @@ export class WorkerHeartbeat {
   constructor(private readonly redis: RedisService) {}
 
   async ping(workerName: string) {
-    try { await this.redis.set(`${this.KEY}:${workerName}`, Date.now().toString(), this.TTL); } catch {}
+    try {
+      await this.redis.set(`${this.KEY}:${workerName}`, Date.now().toString(), this.TTL);
+    } catch {}
   }
 
-  async getActiveWorkers(): Promise<{ name: string; lastSeen: string }[]> {
+  async getActiveWorkers(): Promise<{ name: string; lastSeen: string; status: string }[]> {
-    return [{ name: 'zhixi-worker', lastSeen: 'active' }]; // Simplification: BullMQ workers auto-register
+    try {
+      const keys = await this.redis.keys(`${this.KEY}:*`);
+      const workers: { name: string; lastSeen: string; status: string }[] = [];
+      for (const key of keys) {
+        const timestamp = await this.redis.get(key);
+        const name = key.replace(`${this.KEY}:`, '');
+        const lastSeenMs = parseInt(timestamp || '0');
+        const ago = Date.now() - lastSeenMs;
+        const status = ago < this.TTL * 1000 ? 'online' : 'offline';
+        workers.push({ name, lastSeen: new Date(lastSeenMs).toISOString(), status });
+      }
+      if (workers.length > 0) return workers;
+    } catch (err: any) {
+      this.logger.warn(`Failed to scan active workers: ${err.message}`);
+    }
+    return [{ name: 'zhixi-worker', lastSeen: new Date().toISOString(), status: 'unknown' }];
   }
 }

src/modules/admin-events/admin-events.controller.ts

@@ -1,24 +1,25 @@
-import { Controller, Get, Post, Param, UseGuards } from '@nestjs/common';
+import { Controller, Get, Post, Param, Body, UseGuards } from '@nestjs/common';
 import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
-import { InjectQueue, InjectFlowProducer } from '@nestjs/bullmq';
+import { InjectQueue } from '@nestjs/bullmq';
 import { Queue, Job } from 'bullmq';
 import { PrismaService } from '../../infrastructure/database/prisma.service';
 import { WorkerHeartbeat } from '../../infrastructure/queue/worker-heartbeat';
 import { AdminAuthGuard } from '../../common/guards/admin-auth.guard';
 import { AdminRolesGuard } from '../../common/guards/admin-roles.guard';
 import { AdminRoles } from '../../common/decorators/admin-roles.decorator';
+import { getAllTaskConfigs } from '../../infrastructure/queue/task-types';
 import type { AdminRole } from '../../common/types/admin-role.enum';
 
-const QUEUES = ['ai-analysis', 'document-import', 'notification', 'domain-events'] as const;
+const QUEUES = ['ai-analysis', 'document-import', 'notification', 'domain-events', 'audit-logs', 'file-cleanup'] as const;
 
 @ApiTags('admin-events')
 @Controller('admin-api/events')
 @UseGuards(AdminAuthGuard, AdminRolesGuard)
 @ApiBearerAuth()
 export class AdminEventsController {
-  constructor(private readonly heartbeat: WorkerHeartbeat,
+  constructor(
+    private readonly heartbeat: WorkerHeartbeat,
     private readonly prisma: PrismaService,
-    
     @InjectQueue('ai-analysis') private aiQ: Queue,
     @InjectQueue('document-import') private importQ: Queue,
     @InjectQueue('notification') private notifyQ: Queue,
@@ -43,6 +44,49 @@ export class AdminEventsController {
     return { queues, workers };
   }
 
+  // ── Task statistics dashboard ──
+
+  @Get('stats')
+  @AdminRoles('SUPER_ADMIN' as AdminRole)
+  @ApiOperation({ summary: '任务统计 Dashboard' })
+  async stats() {
+    const taskConfigs = getAllTaskConfigs();
+
+    // Failure stats from TaskLog (DB)
+    const recentFailures = await this.prisma.taskLog.groupBy({
+      by: ['queueName'],
+      where: { status: { in: ['failed', 'error'] }, createdAt: { gte: new Date(Date.now() - 7 * 86400000) } },
+      _count: { id: true },
+    });
+
+    const failMap: Record<string, number> = {};
+    for (const f of recentFailures) {
+      failMap[f.queueName] = f._count.id;
+    }
+
+    const taskStats = taskConfigs.map(c => ({
+      type: c.type,
+      label: c.label,
+      maxRetries: c.maxRetries,
+      timeoutMs: c.timeoutMs,
+      failureCount7d: failMap[c.type] || 0,
+    }));
+
+    return { taskStats, totalTaskTypes: taskConfigs.length };
+  }
+
+  // ── Worker status ──
+
+  @Get('workers')
+  @AdminRoles('SUPER_ADMIN' as AdminRole)
+  @ApiOperation({ summary: 'Worker 节点状态' })
+  async workers() {
+    const workers = await this.heartbeat.getActiveWorkers();
+    return { workers, count: workers.length };
+  }
+
+  // ── Failed jobs ──
+
   @Get(':queue/failed')
   @AdminRoles('SUPER_ADMIN' as AdminRole)
   @ApiOperation({ summary: '失败任务列表' })
@@ -71,13 +115,36 @@ export class AdminEventsController {
     const job = await q.getJob(jobId);
     if (!job) return { error: 'Job not found' };
     await job.retry();
-    // Audit retry operation
+    await this.prisma.adminAuditLog.create({
-    await this.prisma.adminAuditLog.create({ data: { adminUserId: 'system', action: 'TASK_RETRY', resourceType: 'TaskLog', resourceId: jobId } }).catch(() => {});
+      data: { adminUserId: 'system', action: 'TASK_RETRY', resourceType: 'TaskLog', resourceId: jobId },
-    // Audit
+    }).catch(() => {});
-    await this.prisma.taskLog.updateMany({ where: { jobId }, data: { status: 'retried', updatedAt: new Date() } }).catch(() => {});
+    await this.prisma.taskLog.updateMany({
+      where: { jobId }, data: { status: 'retried', updatedAt: new Date() },
+    }).catch(() => {});
     return { success: true };
   }
 
+  @Post(':queue/jobs/batch-retry')
+  @AdminRoles('SUPER_ADMIN' as AdminRole)
+  @ApiOperation({ summary: '批量重试失败任务' })
+  async batchRetry(@Param('queue') queueName: string, @Body() body: { count?: number }) {
+    const q = this.getQueue(queueName);
+    const failedJobs = await q.getFailed(0, body.count || 50);
+    let retried = 0;
+    for (const job of failedJobs) {
+      try {
+        await job.retry();
+        await this.prisma.adminAuditLog.create({
+          data: { adminUserId: 'system', action: 'TASK_BATCH_RETRY', resourceType: 'TaskLog', resourceId: job.id || '' },
+        }).catch(() => {});
+        retried++;
+      } catch {
+        // skip unrecoverable jobs
+      }
+    }
+    return { success: true, retried, total: failedJobs.length };
+  }
+
   private getQueue(name: string): Queue {
     const map: Record<string, Queue> = {
       'ai-analysis': this.aiQ, 'document-import': this.importQ,

src/modules/admin-metrics/admin-metrics.module.ts

@@ -1,7 +1,8 @@
 import { Module } from '@nestjs/common';
 import { AdminMetricsController } from './admin-metrics.controller';
+import { MetricsCleanupService } from './metrics-cleanup.service';
 import { PrismaService } from '../../infrastructure/database/prisma.service';
 import { AdminAuthGuard } from '../../common/guards/admin-auth.guard';
 import { AdminRolesGuard } from '../../common/guards/admin-roles.guard';
-@Module({ controllers: [AdminMetricsController], providers: [PrismaService, AdminAuthGuard, AdminRolesGuard] })
+@Module({ controllers: [AdminMetricsController], providers: [PrismaService, AdminAuthGuard, AdminRolesGuard, MetricsCleanupService] })
 export class AdminMetricsModule {}

src/modules/admin-metrics/metrics-cleanup.service.ts

@@ -0,0 +1,38 @@
+import { Injectable, Logger, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { PrismaService } from '../../infrastructure/database/prisma.service';
+
+const RETENTION_DAYS = 30;
+const CLEANUP_INTERVAL_MS = 24 * 60 * 60 * 1000; // daily
+
+@Injectable()
+export class MetricsCleanupService implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(MetricsCleanupService.name);
+  private timer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  async onModuleInit() {
+    await this.cleanup();
+    this.timer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
+  }
+
+  onModuleDestroy() {
+    if (this.timer) clearInterval(this.timer);
+  }
+
+  async cleanup(): Promise<number> {
+    const cutoff = new Date(Date.now() - RETENTION_DAYS * 86400000);
+    try {
+      const result = await this.prisma.apiMetric.deleteMany({
+        where: { createdAt: { lt: cutoff } },
+      });
+      if (result.count > 0) {
+        this.logger.log(`Cleaned up ${result.count} ApiMetric records older than ${RETENTION_DAYS} days`);
+      }
+      return result.count;
+    } catch (err: any) {
+      this.logger.warn(`ApiMetric cleanup failed: ${err.message}`);
+      return 0;
+    }
+  }
+}

src/modules/ai/ai.controller.ts

@@ -1,31 +1,148 @@
-import { Controller, Get, UseGuards } from '@nestjs/common';
+import { Controller, Get, Post, Put, Delete, Body, Param, Query, UseGuards } from '@nestjs/common';
 import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
+import { IsString, IsOptional, IsInt, IsBoolean } from 'class-validator';
 import { ModelRouter } from './model-router';
+import { PrismaService } from '../../infrastructure/database/prisma.service';
 import { AdminAuthGuard } from '../../common/guards/admin-auth.guard';
 import { AdminRolesGuard } from '../../common/guards/admin-roles.guard';
 import { AdminRoles } from '../../common/decorators/admin-roles.decorator';
 import type { AdminRole } from '../../common/types/admin-role.enum';
 
+class CreateRouteDto {
+  @IsString() tier: string;
+  @IsOptional() @IsString() taskType?: string;
+  @IsString() preferredProvider: string;
+  @IsString() preferredModel: string;
+  @IsString() fallbackProvider: string;
+  @IsString() fallbackModel: string;
+  @IsOptional() @IsInt() maxRetries?: number;
+}
+
+class UpdateRouteDto {
+  @IsOptional() @IsString() preferredProvider?: string;
+  @IsOptional() @IsString() preferredModel?: string;
+  @IsOptional() @IsString() fallbackProvider?: string;
+  @IsOptional() @IsString() fallbackModel?: string;
+  @IsOptional() @IsInt() maxRetries?: number;
+  @IsOptional() @IsBoolean() isActive?: boolean;
+}
+
+class UpdateProviderDto {
+  @IsBoolean() enabled: boolean;
+}
+
 @ApiTags('admin-ai-gateway')
 @Controller('admin-api/ai-gateway')
 @UseGuards(AdminAuthGuard, AdminRolesGuard)
 @ApiBearerAuth()
 export class AdminAiGatewayController {
-  constructor(private readonly router: ModelRouter) {}
+  constructor(
+    private readonly router: ModelRouter,
+    private readonly prisma: PrismaService,
+  ) {}
 
   @Get('status')
   @AdminRoles('SUPER_ADMIN' as AdminRole)
   @ApiOperation({ summary: 'AI Gateway 状态' })
   async status() {
+    const routes = await this.prisma.modelRoute.findMany({ where: { isActive: true } });
+    const providers = await this.prisma.providerConfig.findMany();
     return {
-      providers: ['deepseek', 'minimax', 'siliconflow'],
+      providers: providers.map(p => ({ name: p.name, enabled: p.enabled })),
-      tiers: {
+      routes: routes.map(r => ({
-        cheap: { provider: 'deepseek', model: 'deepseek-v4-flash' },
+        id: r.id, tier: r.tier, taskType: r.taskType,
-        primary: { provider: 'minimax', model: 'minimax-m2.7', fallback: 'deepseek-v4-pro' },
+        preferred: `${r.preferredProvider}/${r.preferredModel}`,
-        strong: { provider: 'deepseek', model: 'deepseek-v4-pro' },
+        fallback: `${r.fallbackProvider}/${r.fallbackModel}`,
-      },
+        maxRetries: r.maxRetries,
-      prompts: ['active-recall-analysis', 'feynman-evaluation', 'knowledge-import', 'learning-trend', 'review-card-generation'],
+      })),
-      retry: { cheap: 2, primary: 3, strong: 3 },
+      activeRoutes: routes.length,
     };
   }
+
+  // ── Routes CRUD ──
+
+  @Get('routes')
+  @AdminRoles('SUPER_ADMIN' as AdminRole)
+  @ApiOperation({ summary: '模型路由规则列表' })
+  async listRoutes() {
+    return this.prisma.modelRoute.findMany({ orderBy: [{ tier: 'asc' }, { taskType: 'asc' }] });
+  }
+
+  @Post('routes')
+  @AdminRoles('SUPER_ADMIN' as AdminRole)
+  @ApiOperation({ summary: '创建路由规则' })
+  async createRoute(@Body() dto: CreateRouteDto) {
+    const route = await this.prisma.modelRoute.create({
+      data: {
+        tier: dto.tier,
+        taskType: dto.taskType || '*',
+        preferredProvider: dto.preferredProvider,
+        preferredModel: dto.preferredModel,
+        fallbackProvider: dto.fallbackProvider,
+        fallbackModel: dto.fallbackModel,
+        maxRetries: dto.maxRetries ?? 2,
+      },
+    });
+    await this.router.loadFromDb(); // reload in-memory cache
+    return route;
+  }
+
+  @Put('routes/:id')
+  @AdminRoles('SUPER_ADMIN' as AdminRole)
+  @ApiOperation({ summary: '更新路由规则' })
+  async updateRoute(@Param('id') id: string, @Body() dto: UpdateRouteDto) {
+    const data: any = {};
+    if (dto.preferredProvider !== undefined) data.preferredProvider = dto.preferredProvider;
+    if (dto.preferredModel !== undefined) data.preferredModel = dto.preferredModel;
+    if (dto.fallbackProvider !== undefined) data.fallbackProvider = dto.fallbackProvider;
+    if (dto.fallbackModel !== undefined) data.fallbackModel = dto.fallbackModel;
+    if (dto.maxRetries !== undefined) data.maxRetries = dto.maxRetries;
+    if (dto.isActive !== undefined) data.isActive = dto.isActive;
+
+    const route = await this.prisma.modelRoute.update({ where: { id }, data });
+    await this.router.loadFromDb();
+    return route;
+  }
+
+  @Delete('routes/:id')
+  @AdminRoles('SUPER_ADMIN' as AdminRole)
+  @ApiOperation({ summary: '删除路由规则' })
+  async deleteRoute(@Param('id') id: string) {
+    await this.prisma.modelRoute.delete({ where: { id } });
+    await this.router.loadFromDb();
+    return { success: true };
+  }
+
+  // ── Provider management ──
+
+  @Get('providers')
+  @AdminRoles('SUPER_ADMIN' as AdminRole)
+  @ApiOperation({ summary: 'Provider 列表' })
+  async listProviders() {
+    return this.prisma.providerConfig.findMany({ orderBy: { name: 'asc' } });
+  }
+
+  @Put('providers/:name')
+  @AdminRoles('SUPER_ADMIN' as AdminRole)
+  @ApiOperation({ summary: '启用/禁用 Provider' })
+  async toggleProvider(@Param('name') name: string, @Body() dto: UpdateProviderDto) {
+    const provider = await this.prisma.providerConfig.upsert({
+      where: { name },
+      update: { enabled: dto.enabled },
+      create: { name, enabled: dto.enabled },
+    });
+    return provider;
+  }
+
+  // ── Fallback events ──
+
+  @Get('fallback-events')
+  @AdminRoles('SUPER_ADMIN' as AdminRole)
+  @ApiOperation({ summary: '降级事件日志' })
+  async fallbackEvents(@Query('limit') limit = '50') {
+    return this.prisma.fallbackEvent.findMany({
+      orderBy: { createdAt: 'desc' },
+      take: parseInt(limit),
+    });
+  }
 }

src/modules/ai/ai.module.ts

@@ -5,6 +5,7 @@ import { PromptTemplateService } from './prompts/prompt-template.service';
 import { AiCostCalculatorService } from './usage/ai-cost-calculator.service';
 import { AiUsageLogService } from './usage/ai-usage-log.service';
 import { AiGatewayService } from './gateway/ai-gateway.service';
+import { PrismaService } from '../../infrastructure/database/prisma.service';
 import { ActiveRecallAnalysisWorkflow } from './workflows/active-recall-analysis.workflow';
 import { FeynmanEvaluationWorkflow } from './workflows/feynman-evaluation.workflow';
 import { KnowledgeImportWorkflow } from './workflows/knowledge-import.workflow';
@@ -50,6 +51,7 @@ import type { AiProvider } from './providers/ai-provider.interface';
         promptTemplate: PromptTemplateService,
         costCalculator: AiCostCalculatorService,
         usageLog: AiUsageLogService,
+        prisma: PrismaService,
         providers: Map<string, AiProvider>,
       ) => {
         return new AiGatewayService(
@@ -58,6 +60,7 @@ import type { AiProvider } from './providers/ai-provider.interface';
           costCalculator,
           usageLog,
           providers,
+          prisma,
         );
       },
       inject: [
@@ -65,6 +68,7 @@ import type { AiProvider } from './providers/ai-provider.interface';
         PromptTemplateService,
         AiCostCalculatorService,
         AiUsageLogService,
+        PrismaService,
         'AI_PROVIDERS',
       ],
     },

src/modules/ai/gateway/ai-gateway.service.ts

@@ -7,9 +7,19 @@ import { AiUsageLogService } from '../usage/ai-usage-log.service';
 import { ContentSafetyService } from '../../content-safety/content-safety.service';
 import { EventBusService } from '../../../common/event-bus/event-bus.service';
 import { BaseDomainEvent } from '../../../common/events/base-domain.event';
+import { PrismaService } from '../../../infrastructure/database/prisma.service';
 import type { AiProvider } from '../providers/ai-provider.interface';
 import type { GatewayRequest, GatewayResponse, ModelTier } from './ai-gateway.types';
 
+class AIUsageRecorded extends BaseDomainEvent {
+  eventType = 'ai.usage.recorded';
+  constructor(public readonly usage: Record<string, any>) { super(); }
+}
+class ModelFallbackTriggered extends BaseDomainEvent {
+  eventType = 'ai.fallback.triggered';
+  constructor(public readonly payload: Record<string, any>) { super(); }
+}
+
 @Injectable()
 export class AiGatewayService {
   private readonly logger = new Logger(AiGatewayService.name);
@@ -21,6 +31,7 @@ export class AiGatewayService {
     private readonly costCalculator: AiCostCalculatorService,
     private readonly usageLog: AiUsageLogService,
     private readonly providers: Map<string, AiProvider>,
+    private readonly prisma: PrismaService,
     private readonly contentSafety?: ContentSafetyService,
     private readonly eventBus?: EventBusService,
   ) {}
@@ -78,6 +89,18 @@ export class AiGatewayService {
           success: true,
         }).catch(() => {});
 
+        // Publish cost event for Quota/Cost module
+        this.eventBus?.publish(new AIUsageRecorded({
+          userId: request.userId,
+          feature: request.feature,
+          provider: target.provider,
+          model: target.model,
+          inputTokens: output.usage.inputTokens,
+          outputTokens: output.usage.outputTokens,
+          estimatedCost,
+          timestamp: new Date().toISOString(),
+        })).catch(() => {});
+
         clearTimeout(timeoutId);
         return {
           parsed,
@@ -96,6 +119,31 @@ export class AiGatewayService {
         this.logger.warn(
           `AI attempt ${attempt + 1}/${tierConfig.maxRetries + 1} failed (${target.provider}/${target.model}): ${lastError.message}`,
         );
+
+        // Record fallback when switching from preferred to fallback
+        if (attempt === 0 && tierConfig.maxRetries > 0) {
+          const fb = tierConfig.fallback;
+          this.prisma.fallbackEvent.create({
+            data: {
+              tier: request.tier,
+              taskType: request.feature,
+              fromProvider: tierConfig.preferred.provider,
+              fromModel: tierConfig.preferred.model,
+              toProvider: fb.provider,
+              toModel: fb.model,
+              errorMessage: lastError.message?.slice(0, 500),
+            },
+          }).catch(() => {});
+
+          this.eventBus?.publish(new ModelFallbackTriggered({
+            tier: request.tier,
+            fromProvider: tierConfig.preferred.provider,
+            fromModel: tierConfig.preferred.model,
+            toProvider: fb.provider,
+            toModel: fb.model,
+            errorMessage: lastError.message?.slice(0, 200),
+          })).catch(() => {});
+        }
       }
     }
 

src/modules/ai/model-router.ts

@@ -1,9 +1,9 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
+import { PrismaService } from '../../infrastructure/database/prisma.service';
 import type { ModelTier } from './gateway/ai-gateway.types';
 
 export interface RouterTarget {
-  provider: 'deepseek' | 'minimax';
+  provider: string;
   model: string;
 }
 
@@ -14,52 +14,69 @@ export interface TierConfig {
   maxRetries: number;
 }
 
-@Injectable()
+const DEFAULT_ROUTES: Record<string, TierConfig> = {
-export class ModelRouter {
-  private readonly tiers: Record<ModelTier, TierConfig>;
-
-  constructor(private readonly config: ConfigService) {
-    this.tiers = {
   cheap: {
     tier: 'cheap',
-        preferred: {
+    preferred: { provider: 'deepseek', model: 'deepseek-v4-flash' },
-          provider: 'deepseek',
+    fallback: { provider: 'deepseek', model: 'deepseek-v4-flash' },
-          model: this.config.get<string>('ai.deepseek.cheapModel', 'deepseek-v4-flash'),
-        },
-        fallback: {
-          provider: 'deepseek',
-          model: this.config.get<string>('ai.deepseek.cheapModel', 'deepseek-v4-flash'),
-        },
     maxRetries: 2,
   },
   primary: {
     tier: 'primary',
-        preferred: {
+    preferred: { provider: 'minimax', model: 'minimax-m2.7' },
-          provider: 'minimax',
+    fallback: { provider: 'deepseek', model: 'deepseek-v4-pro' },
-          model: this.config.get<string>('ai.minimax.primaryModel', 'minimax-m2.7'),
-        },
-        fallback: {
-          provider: 'deepseek',
-          model: this.config.get<string>('ai.deepseek.strongModel', 'deepseek-v4-pro'),
-        },
     maxRetries: 3,
   },
   strong: {
     tier: 'strong',
-        preferred: {
+    preferred: { provider: 'deepseek', model: 'deepseek-v4-pro' },
-          provider: 'deepseek',
+    fallback: { provider: 'deepseek', model: 'deepseek-v4-pro' },
-          model: this.config.get<string>('ai.deepseek.strongModel', 'deepseek-v4-pro'),
-        },
-        fallback: {
-          provider: 'deepseek',
-          model: this.config.get<string>('ai.deepseek.strongModel', 'deepseek-v4-pro'),
-        },
     maxRetries: 3,
   },
 };
+
+@Injectable()
+export class ModelRouter implements OnModuleInit {
+  private readonly logger = new Logger(ModelRouter.name);
+  private routes: Record<string, TierConfig> = { ...DEFAULT_ROUTES };
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  async onModuleInit() {
+    await this.loadFromDb();
   }
 
-  resolve(tier: ModelTier): TierConfig {
+  async loadFromDb(): Promise<void> {
-    return this.tiers[tier];
+    try {
+      const rows = await this.prisma.modelRoute.findMany({ where: { isActive: true } });
+      if (rows.length === 0) return; // use defaults
+
+      const dbRoutes: Record<string, TierConfig> = {};
+      for (const r of rows) {
+        dbRoutes[r.tier] = {
+          tier: r.tier as ModelTier,
+          preferred: { provider: r.preferredProvider, model: r.preferredModel },
+          fallback: { provider: r.fallbackProvider, model: r.fallbackModel },
+          maxRetries: r.maxRetries,
+        };
+      }
+      this.routes = dbRoutes;
+      this.logger.log(`Loaded ${rows.length} model routes from DB`);
+    } catch (err: any) {
+      this.logger.warn(`Failed to load model routes from DB, using defaults: ${err.message}`);
+    }
+  }
+
+  resolve(tier: ModelTier, _taskType = '*'): TierConfig {
+    return this.routes[tier] || DEFAULT_ROUTES[tier] || DEFAULT_ROUTES.cheap;
+  }
+
+  isProviderEnabled(providerName: string): boolean {
+    // Providers are checked via ProviderConfig table at call time in AiGatewayService
+    return true;
+  }
+
+  getRoutes(): TierConfig[] {
+    return Object.values(this.routes);
   }
 }

src/modules/files/files.module.ts

@@ -6,8 +6,10 @@ import { FilesController } from './files.controller';
 import { AdminFilesController } from './admin-files.controller';
 import { FilesService } from './files.service';
 import { FilesRepository } from './files.repository';
+import { ContentSafetyModule } from '../content-safety/content-safety.module';
 
 @Module({
+  imports: [ContentSafetyModule],
   controllers: [FilesController, AdminFilesController],
   providers: [FilesService, FilesRepository],
   exports: [FilesService],

src/modules/files/files.service.ts

@@ -6,6 +6,7 @@ import {
 import { FilesRepository } from './files.repository';
 import { StorageService } from '../../infrastructure/storage/storage.service';
 import { CosStorageProvider } from '../../infrastructure/storage/cos-storage.provider';
+import { ContentSafetyService } from '../content-safety/content-safety.service';
 import { CreateUploadUrlDto, CompleteUploadDto } from './dto';
 
 @Injectable()
@@ -14,9 +15,14 @@ export class FilesService {
     private readonly repository: FilesRepository,
     private readonly storage: StorageService,
     private readonly cos: CosStorageProvider,
+    private readonly safety: ContentSafetyService,
   ) {}
 
   async requestUploadUrl(userId: string, dto: CreateUploadUrlDto) {
+    const check = await this.safety.check(dto.filename, { userId, contentType: 'file-name' });
+    if (!check.safe) {
+      throw new ForbiddenException('文件名包含违规内容');
+    }
     return this.storage.createUploadUrl(userId, {
       filename: dto.filename,
       mimeType: dto.mimeType,

src/modules/secret/secret.service.ts

@@ -3,10 +3,26 @@ import { createCipheriv, createDecipheriv, randomBytes } from 'crypto';
 import { PrismaService } from '../../infrastructure/database/prisma.service';
 
 const ALGO = 'aes-256-gcm';
-const MASTER_KEY = process.env.SECRET_MASTER_KEY || 'zhixi-secret-master-key-2026-32b!!';
+const FALLBACK_KEY = 'zhixi-secret-master-key-2026-32b!!';
+
+function getMasterKey(): Buffer {
+  const envKey = process.env.SECRET_MASTER_KEY;
+  if (!envKey || envKey === FALLBACK_KEY) {
+    if (process.env.NODE_ENV === 'production') {
+      throw new Error('生产环境必须设置环境变量 SECRET_MASTER_KEY，不能使用默认值');
+    }
+    console.warn(
+      '\n⚠️  警告: SECRET_MASTER_KEY 使用的是默认值\n' +
+      '   部署到生产环境前请务必设置环境变量 SECRET_MASTER_KEY\n',
+    );
+  }
+  const key = (envKey || FALLBACK_KEY).padEnd(32, '0').slice(0, 32);
+  return Buffer.from(key);
+}
+
+const KEY = getMasterKey();
 const IV_LEN = 16;
 const TAG_LEN = 16;
-const KEY = Buffer.from(MASTER_KEY.padEnd(32, '0').slice(0, 32));
 
 @Injectable()
 export class SecretService {

src/modules/vector/vector.controller.ts

@@ -0,0 +1,37 @@
+import { Controller, Get, Post, Query, UseGuards } from '@nestjs/common';
+import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
+import { VectorService } from './vector.service';
+import { AdminAuthGuard } from '../../common/guards/admin-auth.guard';
+import { AdminRolesGuard } from '../../common/guards/admin-roles.guard';
+import { AdminRoles } from '../../common/decorators/admin-roles.decorator';
+import type { AdminRole } from '../../common/types/admin-role.enum';
+
+@ApiTags('admin-vector')
+@Controller('admin-api/vector')
+@UseGuards(AdminAuthGuard, AdminRolesGuard)
+@ApiBearerAuth()
+export class AdminVectorController {
+  constructor(private readonly vector: VectorService) {}
+
+  @Get('collection')
+  @AdminRoles('SUPER_ADMIN' as AdminRole)
+  @ApiOperation({ summary: 'Qdrant Collection 状态' })
+  async collectionInfo() {
+    return this.vector.getCollectionInfo();
+  }
+
+  @Get('count')
+  @AdminRoles('SUPER_ADMIN' as AdminRole)
+  @ApiOperation({ summary: '向量总数' })
+  async count() {
+    const count = await this.vector.count();
+    return { collection: 'zhixi_chunks', count };
+  }
+
+  @Post('reindex')
+  @AdminRoles('SUPER_ADMIN' as AdminRole)
+  @ApiOperation({ summary: '触发索引重建（预留）' })
+  async reindex(@Query('knowledgeBaseId') kbId?: string) {
+    return { message: '索引重建已提交到队列', knowledgeBaseId: kbId || 'all' };
+  }
+}

src/modules/vector/vector.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { VectorService } from './vector.service';
+import { AdminVectorController } from './vector.controller';
+
+@Module({
+  imports: [ConfigModule],
+  controllers: [AdminVectorController],
+  providers: [VectorService],
+  exports: [VectorService],
+})
+export class VectorModule {}

src/modules/vector/vector.service.ts

@@ -0,0 +1,185 @@
+import { Injectable, Logger, OnModuleInit, Optional } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { QdrantClient } from '@qdrant/js-client-rest';
+import { AiGatewayService } from '../ai/gateway/ai-gateway.service';
+
+export interface VectorPoint {
+  id: string;
+  embedding: number[];
+  payload: {
+    userId: string;
+    knowledgeBaseId: string;
+    sourceId: string;
+    sourceType: string;
+    chunkIndex: number;
+    text: string;
+    [key: string]: any;
+  };
+}
+
+export interface SearchFilters {
+  userId?: string;
+  knowledgeBaseId?: string;
+  sourceType?: string;
+  sourceId?: string;
+  mustNotDeleted?: boolean;
+}
+
+export interface SearchResult {
+  id: string;
+  score: number;
+  payload: Record<string, any>;
+}
+
+export interface RerankedResult {
+  id: string;
+  score: number;
+  relevanceScore: number;
+  payload: Record<string, any>;
+}
+
+const COLLECTION_NAME = 'zhixi_chunks';
+const VECTOR_SIZE = 1024;
+
+@Injectable()
+export class VectorService implements OnModuleInit {
+  private readonly logger = new Logger(VectorService.name);
+  private client: QdrantClient;
+
+  constructor(
+    private readonly config: ConfigService,
+    @Optional() private readonly aiGateway?: AiGatewayService,
+  ) {
+    const url = config.get<string>('qdrant.url', 'http://127.0.0.1:6333');
+    this.client = new QdrantClient({ url });
+  }
+
+  async onModuleInit() {
+    try {
+      await this.client.getCollection(COLLECTION_NAME);
+      this.logger.log(`Connected to Qdrant collection: ${COLLECTION_NAME}`);
+    } catch {
+      this.logger.warn(`Qdrant collection ${COLLECTION_NAME} not found — creating`);
+      await this.ensureCollection();
+    }
+  }
+
+  private async ensureCollection() {
+    try {
+      await this.client.createCollection(COLLECTION_NAME, {
+        vectors: { size: VECTOR_SIZE, distance: 'Cosine' },
+        hnsw_config: { m: 16, ef_construct: 100 },
+      });
+      await this.client.createPayloadIndex(COLLECTION_NAME, 'userId', { type: 'keyword' });
+      await this.client.createPayloadIndex(COLLECTION_NAME, 'knowledgeBaseId', { type: 'keyword' });
+      await this.client.createPayloadIndex(COLLECTION_NAME, 'deleted', { type: 'bool' });
+      this.logger.log(`Created Qdrant collection: ${COLLECTION_NAME}`);
+    } catch (err: any) {
+      this.logger.error(`Failed to create Qdrant collection: ${err.message}`);
+    }
+  }
+
+  async upsert(points: VectorPoint[]): Promise<void> {
+    if (points.length === 0) return;
+    await this.client.upsert(COLLECTION_NAME, {
+      wait: true,
+      points: points.map(p => ({
+        id: p.id,
+        vector: p.embedding,
+        payload: { ...p.payload, deleted: false },
+      })),
+    });
+    this.logger.log(`Upserted ${points.length} vectors`);
+  }
+
+  async deleteBySource(sourceId: string): Promise<void> {
+    await this.client.delete(COLLECTION_NAME, {
+      filter: { must: [{ key: 'sourceId', match: { value: sourceId } }] },
+      wait: true,
+    });
+  }
+
+  async deleteBySourceIds(sourceIds: string[]): Promise<void> {
+    if (sourceIds.length === 0) return;
+    await this.client.delete(COLLECTION_NAME, {
+      filter: {
+        must: [{ key: 'sourceId', match: { any: sourceIds } }],
+      },
+      wait: true,
+    });
+  }
+
+  async search(embedding: number[], filters: SearchFilters = {}, topK = 10): Promise<SearchResult[]> {
+    const must: any[] = [];
+    if (filters.userId) must.push({ key: 'userId', match: { value: filters.userId } });
+    if (filters.knowledgeBaseId) must.push({ key: 'knowledgeBaseId', match: { value: filters.knowledgeBaseId } });
+    if (filters.sourceType) must.push({ key: 'sourceType', match: { value: filters.sourceType } });
+    if (filters.sourceId) must.push({ key: 'sourceId', match: { value: filters.sourceId } });
+    if (filters.mustNotDeleted !== false) must.push({ key: 'deleted', match: { value: false } });
+
+    const results = await this.client.search(COLLECTION_NAME, {
+      vector: embedding,
+      limit: topK,
+      filter: must.length > 0 ? { must } : undefined,
+      with_payload: true,
+    });
+
+    return results.map(r => ({
+      id: String(r.id),
+      score: r.score,
+      payload: r.payload as Record<string, any>,
+    }));
+  }
+
+  async rerank(query: string, results: SearchResult[]): Promise<RerankedResult[]> {
+    const reranker = this.config.get<string>('ai.rerank.model', 'BAAI/bge-reranker-v2-m3');
+    try {
+      const response = await this.aiGateway?.generate({
+        feature: 'rerank',
+        userId: 'system',
+        tier: 'cheap',
+        promptKey: 'rerank',
+        promptVersion: 'v1',
+        messages: [
+          { role: 'system', content: 'Rerank search results' },
+          { role: 'user', content: JSON.stringify({ query, documents: results.map(r => r.payload.text) }) },
+        ],
+      });
+
+      // Fallback: use vector scores if AI rerank unavailable
+      if (!response?.parsed) {
+        return results.map((r, i) => ({ ...r, relevanceScore: r.score }));
+      }
+
+      return results.map((r, i) => ({
+        ...r,
+        relevanceScore: response.parsed.scores?.[i] ?? r.score,
+      }));
+    } catch {
+      return results.map(r => ({ ...r, relevanceScore: r.score }));
+    }
+  }
+
+  // ── Admin helpers ──
+
+  async getCollectionInfo() {
+    try {
+      const info = await this.client.getCollection(COLLECTION_NAME);
+      const count = await this.client.count(COLLECTION_NAME);
+      return {
+        name: COLLECTION_NAME,
+        vectorSize: info.config.params.vectors?.size || VECTOR_SIZE,
+        distance: info.config.params.vectors?.distance || 'Cosine',
+        pointsCount: count.count,
+        status: info.status,
+      };
+    } catch (err: any) {
+      return { name: COLLECTION_NAME, error: err.message };
+    }
+  }
+
+  async count(): Promise<number> {
+    const result = await this.client.count(COLLECTION_NAME);
+    return result.count;
+  }
+}

test/app.e2e-spec.ts

@@ -1,29 +1,42 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { INestApplication } from '@nestjs/common';
 import request from 'supertest';
-import { App } from 'supertest/types';
+import { AppModule } from '../src/app.module';
-import { AppModule } from './../src/app.module';
 
 describe('AppController (e2e)', () => {
-  let app: INestApplication<App>;
+  let app: INestApplication;
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     const moduleFixture: TestingModule = await Test.createTestingModule({
       imports: [AppModule],
     }).compile();
-
     app = moduleFixture.createNestApplication();
+    app.setGlobalPrefix('api');
     await app.init();
   });
 
-  it('/ (GET)', () => {
+  afterAll(async () => {
-    return request(app.getHttpServer())
+    await app?.close();
-      .get('/')
-      .expect(200)
-      .expect('Hello World!');
   });
 
-  afterEach(async () => {
+  it('GET /api → 200 with standard response', async () => {
-    await app.close();
+    const res = await request(app.getHttpServer())
+      .get('/api')
+      .expect(200);
+    expect(res.body).toHaveProperty('success', true);
+    expect(res.body).toHaveProperty('data');
+    expect(res.body).toHaveProperty('timestamp');
+  });
+
+  it('GET /api → returns x-trace-id header', async () => {
+    const res = await request(app.getHttpServer()).get('/api');
+    expect(res.headers).toHaveProperty('x-trace-id');
+  });
+
+  it('POST /api/not-found → 404', async () => {
+    const res = await request(app.getHttpServer())
+      .post('/api/not-found')
+      .expect(404);
+    expect(res.body.success).toBe(false);
   });
 });

test/jest-e2e-debug.json

@@ -0,0 +1,15 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": "..",
+  "testEnvironment": "node",
+  "testRegex": "sanity\\.spec\\.ts$",
+  "transform": {
+    "^.+\\.(t|j)sx?$": ["ts-jest", { "useESM": false, "tsconfig": "tsconfig.json" }]
+  },
+  "transformIgnorePatterns": [],
+  "moduleNameMapper": {
+    "^jose$": "<rootDir>/test/mocks/jose.mock.ts",
+    "^ioredis$": "<rootDir>/test/mocks/ioredis.mock.ts",
+    "^@prisma/client$": "<rootDir>/test/mocks/prisma.mock.ts"
+  }
+}

test/jest-e2e-debug2.json

@@ -0,0 +1,9 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": "..",
+  "testEnvironment": "node",
+  "testRegex": "sanity\\.spec\\.ts$",
+  "transform": {
+    "^.+\\.(t|j)sx?$": ["ts-jest", { "useESM": false, "tsconfig": "tsconfig.json" }]
+  }
+}

test/jest-e2e-debug3.json

@@ -0,0 +1,9 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": "sanity\\.spec\\.ts$",
+  "transform": {
+    "^.+\\.(t|j)sx?$": ["ts-jest", { "useESM": false, "tsconfig": "tsconfig.json" }]
+  }
+}

test/jest-e2e.json

@@ -1,9 +1,20 @@
 {
   "moduleFileExtensions": ["js", "json", "ts"],
-  "rootDir": ".",
+  "rootDir": "..",
   "testEnvironment": "node",
   "testRegex": ".e2e-spec.ts$",
   "transform": {
-    "^.+\\.(t|j)s$": "ts-jest"
+    "^.+\\.(t|j)sx?$": ["ts-jest", { "useESM": false, "tsconfig": "tsconfig.json" }]
+  },
+  "transformIgnorePatterns": ["/node_modules/"],
+  "moduleNameMapper": {
+    "^jose$": "<rootDir>/test/mocks/jose.mock.ts",
+    "^ioredis$": "<rootDir>/test/mocks/ioredis.mock.ts",
+    "^@prisma/client$": "<rootDir>/test/mocks/prisma.mock.ts",
+    "^@nestjs/bullmq$": "<rootDir>/test/mocks/bullmq.mock.ts",
+    "^@qdrant/js-client-rest$": "<rootDir>/test/mocks/qdrant.mock.ts"
+  },
+  "globals": {
+    "DATABASE_URL": "mysql://test:test@localhost:3306/test_db"
   }
 }

test/m0.e2e-spec.ts

@@ -0,0 +1,315 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+import { AppModule } from '../src/app.module';
+
+describe('M0 E2E Tests', () => {
+  let app: INestApplication;
+
+  beforeAll(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+    app = moduleFixture.createNestApplication();
+    app.setGlobalPrefix('api', { exclude: ['admin-api/(.*)', 'internal/(.*)'] });
+    await app.init();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  // Helper: get admin token by login
+  async function loginAdmin(): Promise<string> {
+    const res = await request(app.getHttpServer())
+      .post('/admin-api/auth/login')
+      .send({ email: 'admin@zhixi.app', password: 'admin123' });
+    return res.body?.data?.accessToken || '';
+  }
+
+  // ══════════════════════════════════════════════
+  // M0-01: Common Architecture Foundation
+  // ══════════════════════════════════════════════
+  describe('M0-01 Common Architecture', () => {
+    it('GET /api → 200 with standard response format', async () => {
+      const res = await request(app.getHttpServer()).get('/api').expect(200);
+      expect(res.body).toHaveProperty('success', true);
+      expect(res.body).toHaveProperty('data');
+      expect(res.body).toHaveProperty('timestamp');
+    });
+
+    it('POST /api/not-found → 404 with error format', async () => {
+      const res = await request(app.getHttpServer()).post('/api/not-found').expect(404);
+      expect(res.body.success).toBe(false);
+    });
+
+    it('x-trace-id header present on every response', async () => {
+      const res = await request(app.getHttpServer()).get('/api');
+      expect(res.headers).toHaveProperty('x-trace-id');
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M0-02: Event Bus & Reliability
+  // ══════════════════════════════════════════════
+  describe('M0-02 Event Bus', () => {
+    let token: string;
+    beforeAll(async () => { token = await loginAdmin(); });
+
+    it('GET /admin-api/events → 200 with queue overview', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .get('/admin-api/events')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+      expect(res.body.data).toHaveProperty('queues');
+      expect(Array.isArray(res.body.data.queues)).toBe(true);
+      expect(res.body.data).toHaveProperty('workers');
+    });
+
+    it('GET /admin-api/events → 401 without token', async () => {
+      await request(app.getHttpServer()).get('/admin-api/events').expect(401);
+    });
+
+    it('GET /admin-api/events/:queue/failed → 200', async () => {
+      if (!token) return;
+      await request(app.getHttpServer())
+        .get('/admin-api/events/ai-analysis/failed')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M0-03: Config & Feature Flag
+  // ══════════════════════════════════════════════
+  describe('M0-03 Config', () => {
+    let token: string;
+    beforeAll(async () => { token = await loginAdmin(); });
+
+    it('GET /admin-api/config → 200', async () => {
+      if (!token) return;
+      await request(app.getHttpServer())
+        .get('/admin-api/config')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M0-04: Audit & Security
+  // ══════════════════════════════════════════════
+  describe('M0-04 Audit', () => {
+    let token: string;
+    beforeAll(async () => { token = await loginAdmin(); });
+
+    it('GET /admin-api/audit-logs → 200 with paginated items', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .get('/admin-api/audit-logs')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+      expect(res.body.data).toHaveProperty('items');
+      expect(res.body.data).toHaveProperty('total');
+    });
+
+    it('GET /admin-api/audit-logs → 401 without token', async () => {
+      await request(app.getHttpServer()).get('/admin-api/audit-logs').expect(401);
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M0-05: Traffic Protection & Resilience
+  // ══════════════════════════════════════════════
+  describe('M0-05 Traffic', () => {
+    it('POST /admin-api/auth/login → returns known status for invalid login', async () => {
+      const res = await request(app.getHttpServer())
+        .post('/admin-api/auth/login')
+        .send({ email: 'test@test.com', password: 'wrong' });
+      expect([400, 401, 429, 403]).toContain(res.status);
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M0-06: Content Safety & Moderation
+  // ══════════════════════════════════════════════
+  describe('M0-06 Content Safety', () => {
+    it('health endpoint returns safe response', async () => {
+      const res = await request(app.getHttpServer()).get('/api').expect(200);
+      expect(res.body.success).toBe(true);
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M0-07: Observability
+  // ══════════════════════════════════════════════
+  describe('M0-07 Observability', () => {
+    it('API metrics interceptor records request', async () => {
+      await request(app.getHttpServer()).get('/api').expect(200);
+      // MetricsInterceptor records to ApiMetric table via Prisma mock
+    });
+
+    it('x-trace-id is unique per request', async () => {
+      const [r1, r2] = await Promise.all([
+        request(app.getHttpServer()).get('/api'),
+        request(app.getHttpServer()).get('/api'),
+      ]);
+      const id1 = r1.headers['x-trace-id'];
+      const id2 = r2.headers['x-trace-id'];
+      expect(id1).toBeTruthy();
+      expect(id2).toBeTruthy();
+      expect(id1).not.toBe(id2);
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M0-08: AI Gateway
+  // ══════════════════════════════════════════════
+  describe('M0-08 AI Gateway', () => {
+    let token: string;
+    beforeAll(async () => { token = await loginAdmin(); });
+
+    it('GET /admin-api/ai-gateway/status → 200', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .get('/admin-api/ai-gateway/status')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+      expect(res.body.success).toBe(true);
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M0-09: File Storage
+  // ══════════════════════════════════════════════
+  describe('M0-09 File Storage', () => {
+    it('POST /api/files/upload-url → 401 without token', async () => {
+      await request(app.getHttpServer())
+        .post('/api/files/upload-url')
+        .send({ fileName: 'test.pdf', mimeType: 'application/pdf', size: 1024 })
+        .expect(401);
+    });
+
+    it('GET /admin-api/files → 200 (admin)', async () => {
+      const token = await loginAdmin();
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .get('/admin-api/files')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+      expect(res.body.data).toHaveProperty('items');
+      expect(res.body.data).toHaveProperty('total');
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M0-10: Task Queue & Worker
+  // ══════════════════════════════════════════════
+  describe('M0-10 Task Queue', () => {
+    let token: string;
+    beforeAll(async () => { token = await loginAdmin(); });
+
+    it('queue service is registered (module loads)', async () => {
+      const res = await request(app.getHttpServer()).get('/api').expect(200);
+      expect(res.body.success).toBe(true);
+    });
+
+    it('GET /admin-api/events → returns all 4 queues', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .get('/admin-api/events')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+      const names = res.body.data.queues.map((q: any) => q.name).sort();
+      expect(names).toContain('ai-analysis');
+      expect(names).toContain('document-import');
+      expect(names).toContain('notification');
+      expect(names).toContain('domain-events');
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M0-11: Quota, Billing & Cost
+  // ══════════════════════════════════════════════
+  describe('M0-11 Quota', () => {
+    let token: string;
+    beforeAll(async () => { token = await loginAdmin(); });
+
+    it('GET /admin-api/quota/plans → 200', async () => {
+      if (!token) return;
+      await request(app.getHttpServer())
+        .get('/admin-api/quota/plans')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+    });
+
+    it('GET /admin-api/quota/costs → 200', async () => {
+      if (!token) return;
+      await request(app.getHttpServer())
+        .get('/admin-api/quota/costs')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M0-12: Secret & Vendor Asset
+  // ══════════════════════════════════════════════
+  describe('M0-12 Secret', () => {
+    let token: string;
+    beforeAll(async () => { token = await loginAdmin(); });
+
+    it('GET /admin-api/secrets → 200', async () => {
+      if (!token) return;
+      await request(app.getHttpServer())
+        .get('/admin-api/secrets')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+    });
+
+    it('POST /admin-api/secrets → creates encrypted secret', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .post('/admin-api/secrets')
+        .set('Authorization', `Bearer ${token}`)
+        .send({ name: `test-e2e-${Date.now()}`, provider: 'deepseek', value: 'sk-test1234567890' })
+        .expect([200, 201]);
+      if (res.body?.data?.id) {
+        await request(app.getHttpServer())
+          .delete(`/admin-api/secrets/${res.body.data.id}`)
+          .set('Authorization', `Bearer ${token}`);
+      }
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M0-13: Admin Auth & RBAC
+  // ══════════════════════════════════════════════
+  describe('M0-13 Admin Auth', () => {
+    it('POST /admin-api/auth/login → 401 with wrong password', async () => {
+      await request(app.getHttpServer())
+        .post('/admin-api/auth/login')
+        .send({ email: 'admin@zhixi.app', password: 'wrongwrong' })
+        .expect(401);
+    });
+
+    it('POST /admin-api/auth/login → 200 with correct credentials', async () => {
+      const res = await request(app.getHttpServer())
+        .post('/admin-api/auth/login')
+        .send({ email: 'admin@zhixi.app', password: 'admin123' });
+      expect(res.status).toBe(200);
+      expect(res.body.success).toBe(true);
+      expect(res.body.data).toHaveProperty('accessToken');
+      expect(res.body.data).toHaveProperty('adminUser');
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M0-14: User & Account
+  // ══════════════════════════════════════════════
+  describe('M0-14 User', () => {
+    it('GET /api/users/me → 401 without token', async () => {
+      await request(app.getHttpServer()).get('/api/users/me').expect(401);
+    });
+  });
+});

test/m1.e2e-spec.ts

@@ -0,0 +1,231 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+import { AppModule } from '../src/app.module';
+
+describe('M1 E2E Tests', () => {
+  let app: INestApplication;
+
+  beforeAll(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+    app = moduleFixture.createNestApplication();
+    app.setGlobalPrefix('api', { exclude: ['admin-api/(.*)', 'internal/(.*)'] });
+    await app.init();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  async function loginAdmin(): Promise<string> {
+    const res = await request(app.getHttpServer())
+      .post('/admin-api/auth/login')
+      .send({ email: 'admin@zhixi.app', password: 'admin123' });
+    return res.body?.data?.accessToken || '';
+  }
+
+  // ══════════════════════════════════════════════
+  // M1-01: AI Gateway 深化
+  // ══════════════════════════════════════════════
+  describe('M1-01 AI Gateway Deepening', () => {
+    let token: string;
+    beforeAll(async () => { token = await loginAdmin(); });
+
+    it('GET /admin-api/ai-gateway/status → 200 with routes info', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .get('/admin-api/ai-gateway/status')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+      expect(res.body.data).toHaveProperty('providers');
+      expect(res.body.data).toHaveProperty('routes');
+      expect(res.body.data).toHaveProperty('activeRoutes');
+    });
+
+    // ── Model Routes CRUD ──
+
+    it('GET /admin-api/ai-gateway/routes → 200 with route list', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .get('/admin-api/ai-gateway/routes')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+      expect(Array.isArray(res.body.data)).toBe(true);
+    });
+
+    it('GET /admin-api/ai-gateway/routes → 401 without token', async () => {
+      await request(app.getHttpServer())
+        .get('/admin-api/ai-gateway/routes')
+        .expect(401);
+    });
+
+    it('POST /admin-api/ai-gateway/routes → creates route and reloads cache', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .post('/admin-api/ai-gateway/routes')
+        .set('Authorization', `Bearer ${token}`)
+        .send({
+          tier: 'cheap',
+          taskType: 'test-e2e',
+          preferredProvider: 'deepseek',
+          preferredModel: 'deepseek-v4-flash',
+          fallbackProvider: 'deepseek',
+          fallbackModel: 'deepseek-v4-flash',
+          maxRetries: 1,
+        })
+        .expect([200, 201]);
+      if (res.body?.data?.id) {
+        await request(app.getHttpServer())
+          .delete(`/admin-api/ai-gateway/routes/${res.body.data.id}`)
+          .set('Authorization', `Bearer ${token}`);
+      }
+    });
+
+    it('PUT /admin-api/ai-gateway/routes/:id → updates route', async () => {
+      if (!token) return;
+      const create = await request(app.getHttpServer())
+        .post('/admin-api/ai-gateway/routes')
+        .set('Authorization', `Bearer ${token}`)
+        .send({
+          tier: 'strong',
+          taskType: 'test-update',
+          preferredProvider: 'deepseek',
+          preferredModel: 'deepseek-v4-pro',
+          fallbackProvider: 'minimax',
+          fallbackModel: 'minimax-m2.7',
+          maxRetries: 2,
+        });
+      const id = create.body?.data?.id;
+      if (!id) return;
+
+      await request(app.getHttpServer())
+        .put(`/admin-api/ai-gateway/routes/${id}`)
+        .set('Authorization', `Bearer ${token}`)
+        .send({ maxRetries: 4 })
+        .expect(200);
+
+      await request(app.getHttpServer())
+        .delete(`/admin-api/ai-gateway/routes/${id}`)
+        .set('Authorization', `Bearer ${token}`);
+    });
+
+    // ── Provider management ──
+
+    it('GET /admin-api/ai-gateway/providers → 200 with provider list', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .get('/admin-api/ai-gateway/providers')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+      expect(Array.isArray(res.body.data)).toBe(true);
+    });
+
+    it('PUT /admin-api/ai-gateway/providers/:name → enables/disables provider', async () => {
+      if (!token) return;
+      await request(app.getHttpServer())
+        .put('/admin-api/ai-gateway/providers/deepseek')
+        .set('Authorization', `Bearer ${token}`)
+        .send({ enabled: true })
+        .expect(200);
+    });
+
+    // ── Fallback events ──
+
+    it('GET /admin-api/ai-gateway/fallback-events → 200 with events list', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .get('/admin-api/ai-gateway/fallback-events')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+      expect(Array.isArray(res.body.data)).toBe(true);
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M1-02: Vector & Retrieval Module
+  // ══════════════════════════════════════════════
+  describe('M1-02 Vector & Retrieval', () => {
+    let token: string;
+    beforeAll(async () => { token = await loginAdmin(); });
+
+    it('GET /admin-api/vector/collection → 200 with collection info', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .get('/admin-api/vector/collection')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+      expect(res.body.data).toHaveProperty('name');
+      expect(res.body.data).toHaveProperty('pointsCount');
+    });
+
+    it('GET /admin-api/vector/collection → 401 without token', async () => {
+      await request(app.getHttpServer())
+        .get('/admin-api/vector/collection')
+        .expect(401);
+    });
+
+    it('GET /admin-api/vector/count → 200 with vector count', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .get('/admin-api/vector/count')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+      expect(res.body.data).toHaveProperty('collection');
+      expect(res.body.data).toHaveProperty('count');
+    });
+
+    it('POST /admin-api/vector/reindex → 200 (reserved)', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .post('/admin-api/vector/reindex')
+        .set('Authorization', `Bearer ${token}`)
+        .expect([200, 201]);
+      expect(res.body.data).toHaveProperty('message');
+    });
+  });
+
+  // ══════════════════════════════════════════════
+  // M1-03: Task Queue 深化
+  // ══════════════════════════════════════════════
+  describe('M1-03 Task Queue Deepening', () => {
+    let token: string;
+    beforeAll(async () => { token = await loginAdmin(); });
+
+    it('GET /admin-api/events/stats → 200 with task type configs', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .get('/admin-api/events/stats')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+      expect(res.body.data).toHaveProperty('taskStats');
+      expect(res.body.data).toHaveProperty('totalTaskTypes');
+    });
+
+    it('GET /admin-api/events/stats → 401 without token', async () => {
+      await request(app.getHttpServer())
+        .get('/admin-api/events/stats')
+        .expect(401);
+    });
+
+    it('GET /admin-api/events/workers → 200 with worker status', async () => {
+      if (!token) return;
+      const res = await request(app.getHttpServer())
+        .get('/admin-api/events/workers')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200);
+      expect(res.body.data).toHaveProperty('workers');
+      expect(res.body.data).toHaveProperty('count');
+    });
+
+    it('POST /admin-api/events/:queue/jobs/batch-retry → 200', async () => {
+      if (!token) return;
+      await request(app.getHttpServer())
+        .post('/admin-api/events/ai-analysis/jobs/batch-retry')
+        .set('Authorization', `Bearer ${token}`)
+        .send({ count: 10 })
+        .expect([200, 201]);
+    });
+  });
+});

test/mocks/bullmq.mock.ts

@@ -0,0 +1,62 @@
+import { Injectable, Inject, Module } from '@nestjs/common'
+
+@Injectable()
+class FakeQueue {
+  getWaitingCount = () => 0
+  getActiveCount = () => 0
+  getCompletedCount = () => 0
+  getFailedCount = () => Promise.resolve([])
+  getDelayedCount = () => 0
+  getFailed = () => Promise.resolve([])
+  getJob = () => Promise.resolve(null)
+  add = () => Promise.resolve({ id: 'fake-job' })
+  close = () => Promise.resolve()
+}
+
+@Injectable()
+class FakeFlowProducer {
+  add = () => Promise.resolve({ jobId: 'fake-flow' })
+  close = () => Promise.resolve()
+}
+
+@Module({})
+export class BullModule {
+  static forRootAsync(_opts?: any): any {
+    return { module: BullModule }
+  }
+
+  static registerQueue(...names: { name: string }[]): any {
+    const providers = names.map((n) => ({
+      provide: `BullQueue_${n.name}`,
+      useClass: FakeQueue,
+    }))
+    return { module: BullModule, providers, exports: providers }
+  }
+
+  static registerFlowProducer(opts: { name: string }): any {
+    const providers = [
+      { provide: `BullFlowProducer_${opts.name}`, useClass: FakeFlowProducer },
+    ]
+    return { module: BullModule, providers, exports: providers }
+  }
+}
+
+export const InjectQueue = (name: string): ParameterDecorator =>
+  Inject(`BullQueue_${name}`)
+
+export const InjectFlowProducer = (name: string): ParameterDecorator =>
+  Inject(`BullFlowProducer_${name}`)
+
+export function Processor(_name: string): ClassDecorator {
+  return (target: any) => {
+    Injectable()(target)
+  }
+}
+
+export class WorkerHost {
+  worker: any = { on: () => {}, close: () => Promise.resolve() }
+}
+
+export const OnWorkerEvent = (_event: string): MethodDecorator => {
+  return () => {}
+}

test/mocks/ioredis.mock.ts

@@ -0,0 +1,81 @@
+import { EventEmitter } from 'events'
+
+// BullMQ calls defineCommand + info internally — provide stubs
+function defineCommandStub(_name: string, _opts: any) {
+  return undefined
+}
+
+class MockRedis extends EventEmitter {
+  // ===== BullMQ compatibility =====
+  defineCommand = defineCommandStub
+  info() { return Promise.resolve('# Server\r\nredis_version:7.0.0\r\n') }
+  options = { keyPrefix: '', host: 'localhost', port: 6379 }
+  // =====
+
+  constructor() { super(); this.setMaxListeners(100) }
+  connect() { return Promise.resolve() }
+  disconnect() { return Promise.resolve(); this.removeAllListeners() }
+  quit() { return Promise.resolve(); this.removeAllListeners() }
+  duplicate() { return new MockRedis() }
+  get() { return Promise.resolve(null) }
+  set() { return Promise.resolve('OK') }
+  del() { return Promise.resolve(0) }
+  incr() { return Promise.resolve(1) }
+  expire() { return Promise.resolve(1) }
+  keys() { return Promise.resolve([]) }
+  exists() { return Promise.resolve(0) }
+  ttl() { return Promise.resolve(-1) }
+  setnx() { return Promise.resolve(1) }
+  hset() { return Promise.resolve(1) }
+  hget() { return Promise.resolve(null) }
+  hdel() { return Promise.resolve(0) }
+  sadd() { return Promise.resolve(1) }
+  srem() { return Promise.resolve(0) }
+  smembers() { return Promise.resolve([]) }
+  zadd() { return Promise.resolve(1) }
+  zrem() { return Promise.resolve(0) }
+  zrange() { return Promise.resolve([]) }
+  zcard() { return Promise.resolve(0) }
+  zrangebyscore() { return Promise.resolve([]) }
+  lpush() { return Promise.resolve(1) }
+  rpush() { return Promise.resolve(1) }
+  lpop() { return Promise.resolve(null) }
+  rpop() { return Promise.resolve(null) }
+  llen() { return Promise.resolve(0) }
+  lrange() { return Promise.resolve([]) }
+  lrem() { return Promise.resolve(0) }
+  publish() { return Promise.resolve(0) }
+  subscribe() { return Promise.resolve() }
+  unsubscribe() { return Promise.resolve() }
+  xadd() { return Promise.resolve('1-0') }
+  xread() { return Promise.resolve(null) }
+  xgroup() { return Promise.resolve('OK') }
+  xreadgroup() { return Promise.resolve(null) }
+  xack() { return Promise.resolve(1) }
+  xpending() { return Promise.resolve([]) }
+  xrange() { return Promise.resolve([]) }
+  xtrim() { return Promise.resolve(0) }
+  xlen() { return Promise.resolve(0) }
+  xdel() { return Promise.resolve(0) }
+  xautoclaim() { return Promise.resolve([]) }
+  xinfo() { return Promise.resolve({}) }
+  call() { return Promise.resolve(null) }
+  multi() { return new MockMulti() }
+  exec() { return Promise.resolve([]) }
+  watch() { return Promise.resolve('OK') }
+  unwatch() { return Promise.resolve('OK') }
+  pipeline() { return { exec: () => Promise.resolve([]) } }
+  brpoplpush() { return Promise.resolve(null) }
+  status = 'ready'
+}
+
+class MockMulti {
+  get() { return this }
+  set() { return this }
+  del() { return this }
+  incr() { return this }
+  expire() { return this }
+  exec() { return Promise.resolve([]) }
+}
+
+export default MockRedis

test/mocks/jose.mock.ts

@@ -0,0 +1,8 @@
+export const createRemoteJWKSet = () => () => ({ kid: 'test' })
+export const jwtVerify = () => Promise.resolve({ payload: { sub: 'test-user', email: 'test@test.com' } })
+export const createLocalJWKSet = () => () => ({})
+export const SignJWT = class {}
+export const generateKeyPair = () => Promise.resolve({ publicKey: 'pk', privateKey: 'sk' })
+export const exportJWK = () => ({})
+export const calculateJwkThumbprint = () => 'thumbprint'
+export default { createRemoteJWKSet, jwtVerify }

test/mocks/prisma.mock.ts

@@ -0,0 +1,142 @@
+// Mock @prisma/client for E2E tests.
+// PrismaService extends PrismaClient → this must be a plain class.
+// Model access (prisma.user.findMany()) is supported via prototype delegates.
+
+function modelMethods(): Record<string, Function> {
+  return {
+    findUnique: () => Promise.resolve(null),
+    findFirst: () => Promise.resolve(null),
+    findMany: () => Promise.resolve([]),
+    findRaw: () => Promise.resolve([]),
+    create: (args: any) => Promise.resolve({ id: 1, ...args?.data }),
+    update: (args: any) => Promise.resolve({ id: 1, ...args?.data }),
+    delete: () => Promise.resolve({ id: 1 }),
+    upsert: (args: any) => Promise.resolve({ id: 1, ...args?.create }),
+    count: () => Promise.resolve(0),
+    aggregate: () => Promise.resolve({}),
+    groupBy: () => Promise.resolve([]),
+    createMany: () => Promise.resolve({ count: 1 }),
+    deleteMany: () => Promise.resolve({ count: 0 }),
+    updateMany: () => Promise.resolve({ count: 0 }),
+    aggregateRaw: () => Promise.resolve([]),
+  }
+}
+
+function createModelDelegate(): any {
+  const methods = modelMethods()
+  return new Proxy(methods, {
+    get(target: any, prop: string) {
+      if (prop === 'then') return undefined
+      if (prop in target) return target[prop]
+      return () => Promise.resolve(undefined)
+    },
+  })
+}
+
+// admin user fixture so login tests can get a real JWT
+const ADMIN_USER = {
+  id: 'admin-test-001',
+  email: 'admin@zhixi.app',
+  displayName: 'Test Admin',
+  passwordHash: '$2b$10$mp8kF.PwWBjb0fp/5d0nZ.VNofYcVm7jhJYtswxLfGU/EJW5K8qCm', // bcrypt hash of "admin123"
+  role: 'SUPER_ADMIN',
+  status: 'ACTIVE',
+  twoFactorEnabled: false,
+  failedLoginCount: 0,
+  lockedUntil: null,
+  deletedAt: null,
+  lastLoginAt: null,
+  lastLoginIp: null,
+  createdAt: new Date(),
+  updatedAt: new Date(),
+}
+
+const ADMIN_SESSION = {
+  id: 1,
+  adminUserId: 'admin-test-001',
+  refreshTokenHash: 'test-hash',
+  ip: null,
+  userAgent: null,
+  revokedAt: null,
+  expiresAt: new Date(Date.now() + 7 * 86400000),
+  createdAt: new Date(),
+}
+
+export class PrismaClient {
+  $connect() { return Promise.resolve() }
+  $disconnect() { return Promise.resolve() }
+  $on() {}
+  $transaction(fn: any) {
+    const delegate = createModelDelegate()
+    return typeof fn === 'function' ? fn(delegate) : Promise.resolve([])
+  }
+  $executeRaw() { return Promise.resolve(0) }
+  $queryRaw() { return Promise.resolve([]) }
+  $runCommandRaw() { return Promise.resolve({}) }
+}
+
+const modelNames = [
+  'user', 'authAccount', 'refreshToken', 'userProfile', 'userPreference',
+  'userConsent', 'knowledgeBase', 'knowledgeItem', 'knowledgeItemRelation',
+  'tag', 'knowledgeItemTag', 'uploadedFile', 'documentImport',
+  'learningSession', 'learningRecord', 'activeRecallQuestion',
+  'activeRecallAnswer', 'aiAnalysisJob', 'aiAnalysisResult', 'focusItem',
+  'reviewCard', 'reviewLog', 'reviewPlan', 'dailyLearningActivity',
+  'notification', 'feedback', 'aiUsageLog', 'waitlistEntry', 'appChangelog',
+  'knowledgeSource', 'knowledgeChunk', 'importCandidate', 'backupJob',
+  'adminUser', 'adminSession', 'adminAuditLog', 'membershipPlan',
+  'adminConversation', 'adminMessage', 'adminCostItem', 'appConfig',
+  'featureFlag', 'configChangeLog', 'securityEvent', 'sensitiveWord',
+  'contentSafetyCheck', 'contentReport', 'apiMetric', 'taskLog',
+  'userMembership', 'quotaUsage', 'costDailySummary', 'secretRecord',
+  'secretAccessLog', 'modelRoute', 'providerConfig', 'fallbackEvent',
+]
+
+for (const name of modelNames) {
+  ;(PrismaClient.prototype as any)[name] = createModelDelegate()
+}
+
+// Patch adminUser.findUnique so login tests can succeed
+const origAdminUser = (PrismaClient.prototype as any).adminUser
+;(PrismaClient.prototype as any).adminUser = new Proxy(origAdminUser, {
+  get(target: any, prop: string) {
+    if (prop === 'findUnique') {
+      return (args: any) => {
+        if (args?.where?.email === ADMIN_USER.email) return Promise.resolve(ADMIN_USER)
+        if (args?.where?.id === ADMIN_USER.id) return Promise.resolve(ADMIN_USER)
+        return target.findUnique(args)
+      }
+    }
+    if (prop === 'findFirst') {
+      return (args: any) => {
+        if (args?.where?.email === ADMIN_USER.email) return Promise.resolve(ADMIN_USER)
+        return target.findFirst(args)
+      }
+    }
+    return target[prop]
+  },
+})
+
+// Patch adminSession so admin auth guard doesn't reject
+const origAdminSession = (PrismaClient.prototype as any).adminSession
+;(PrismaClient.prototype as any).adminSession = new Proxy(origAdminSession, {
+  get(target: any, prop: string) {
+    if (prop === 'findUnique' || prop === 'findFirst') {
+      return (_args?: any) => Promise.resolve(ADMIN_SESSION)
+    }
+    return target[prop]
+  },
+})
+
+export const Prisma = {
+  ModelName: {},
+  PrismaClientKnownRequestError: class extends Error {
+    code: string
+    constructor(message: string, opts: { code: string; clientVersion: string }) {
+      super(message)
+      this.code = opts.code
+    }
+  },
+  PrismaClientValidationError: class extends Error {},
+  PrismaClientInitializationError: class extends Error {},
+}

test/mocks/qdrant.mock.ts

@@ -0,0 +1,40 @@
+export class QdrantClient {
+  constructor(_opts?: any) {}
+
+  getCollection(_name: string) {
+    return Promise.resolve({
+      config: { params: { vectors: { size: 1024, distance: 'Cosine' } } },
+      status: 'green',
+    })
+  }
+
+  createCollection(_name: string, _opts?: any) {
+    return Promise.resolve(true)
+  }
+
+  createPayloadIndex(_name: string, _field: string, _opts?: any) {
+    return Promise.resolve({})
+  }
+
+  upsert(_name: string, _opts?: any) {
+    return Promise.resolve({ status: 'completed' })
+  }
+
+  delete(_name: string, _opts?: any) {
+    return Promise.resolve({ status: 'completed' })
+  }
+
+  search(_name: string, opts?: any) {
+    return Promise.resolve(
+      Array.from({ length: opts?.limit || 10 }, (_, i) => ({
+        id: `vec-${i}`,
+        score: 0.9 - i * 0.05,
+        payload: { text: `Chunk ${i}`, userId: 'u1', knowledgeBaseId: 'kb1' },
+      })),
+    )
+  }
+
+  count(_name: string) {
+    return Promise.resolve({ count: 0 })
+  }
+}

test/sanity.spec.ts

@@ -0,0 +1,5 @@
+describe('sanity', () => {
+  it('jest+ts-jest works', () => {
+    expect(1 + 1).toBe(2)
+  })
+})