┌─────────────────────────────────────────────────────────┐
│                    CoWork 架构总览                       │
├─────────────────────────────────────────────────────────┤
│  Session Manager → Context Engine → Approval Gateway   │
│       ↓                  ↓                  ↓           │
│   会话管理          上下文引擎          审批网关        │
│   • 权限边界        • 代码索引          • 策略执行      │
│   • 状态持久化      • 智能压缩          • 风险评估      │
│   • 多会话协调      • 增量更新          • 审批流程      │
│                                                          │
│                    Activity Logger ←────────────┘        │
│                    活动日志（审计 + 优化）                │
└─────────────────────────────────────────────────────────┘

# cowork.config.yaml
approval_policy:
  database_migrations: always
  schema_changes: always
  payment_logic: always
  api_breaking_changes: always
  config_production: always
  api_changes: selective
  tests: never
  docs: never

// 我定义的接口规范，AI 必须遵守
interface UserAPI {
  // 所有接口必须遵循这个模式
  create: (data: CreateUserDTO) => Promise<User>;
  update: (id: string, data: UpdateUserDTO) => Promise<User>;
  delete: (id: string) => Promise<void>;
  findById: (id: string) => Promise<User | null>;
  list: (params: ListParams) => Promise<PaginatedResult<User>>;

  // 响应格式必须统一
  // 错误处理必须包含错误码
  // 日志必须记录关键操作
}

// 数据验证规则
const UserSchema = z.object({
  email: z.string().email(),
  name: z.string().min(1).max(50),
  role: z.enum(['admin', 'user', 'guest']),
  // AI 可以添加字段，但不能修改这些核心字段
});

# ci-gates.yaml
gates:
  - name: "单元测试"
    command: "npm test"
    required: true
    min_coverage: 80%

  - name: "类型检查"
    command: "npm run typecheck"
    required: true

  - name: "代码规范"
    command: "npm run lint"
    required: true

  - name: "集成测试"
    command: "npm run test:integration"
    required: false  # 可选，失败只警告

# cowork.config.yaml
approval_policy:
  data_ingestion: never
  report_generation: never
  file_operations:
    allowed_paths:
      - /data/raw/*
      - /reports/*
    denied_paths:
      - /src/*
      - /config/*
      - /database/*

# 沙箱配置
sandbox:
  enabled: true
  network_whitelist:
    - api.example.com
    - data.source.com
  resource_limits:
    cpu: 1.0
    memory: 2G
    disk: 10G

interface SessionContext {
  // 项目信息
  projectId: string;
  projectName: string;

  // 技术栈
  techStack: {
    language: string;
    framework: string;
    version: string;
  };

  // 代码规范
  codingStandards: CodeStyle;

  // 业务领域知识
  domainKnowledge: DomainEntity[];

  // 会话历史
  conversationHistory: Message[];
}

// 会话状态快照
interface SessionSnapshot {
  sessionId: string;
  timestamp: number;

  // 当前任务
  currentTask: Task;

  // 已完成的工作
  completedWork: WorkItem[];

  // 待办事项
  pendingTasks: Task[];

  // 上下文状态
  context: SessionContext;

  // 权限状态
  permissions: PermissionSet;
}

// 权限继承规则
class PermissionInheritance {
  inherit(parent: PermissionSet, childTask: Task): PermissionSet {
    // 默认继承父权限
    let permissions = { ...parent };

    // 根据子任务类型收紧权限
    if (childTask.type === 'read-only') {
      permissions.write = false;
      permissions.execute = false;
    }

    if (childTask.type === 'analysis') {
      permissions.write = false;
    }

    // 不能扩大权限
    permissions = this.intersect(permissions, parent);

    return permissions;
  }
}

# context.priorities.yaml
indexing:
  # L1: 当前文件（最高优先级，总是包含）
  level_1:
    - pattern: "**/current-file.*"
      priority: 100
      always_include: true

  # L2: 直接依赖的文件
  level_2:
    - pattern: "**/*.imported.*"
      priority: 80
      max_tokens: 50000

  # L3: 项目核心文档
  level_3:
    - pattern: "docs/architecture.md"
    - pattern: "docs/api-spec.md"
    - pattern: "README.md"
      priority: 60
      max_tokens: 30000

  # L4: 历史相关对话
  level_4:
    - type: "conversation"
      relevance_threshold: 0.7
      priority: 40
      max_tokens: 20000

class ContextCompressor {
  compress(context: Context, maxTokens: number): Context {
    // 按优先级排序
    const sorted = context.items.sort((a, b) => b.priority - a.priority);

    let usedTokens = 0;
    const result: ContextItem[] = [];

    for (const item of sorted) {
      const itemTokens = this.countTokens(item.content);

      if (usedTokens + itemTokens <= maxTokens) {
        // 完整包含
        result.push(item);
        usedTokens += itemTokens;
      } else if (!item.alwaysInclude) {
        // 压缩或丢弃
        const compressed = this.compressItem(item, maxTokens - usedTokens);
        if (compressed) {
          result.push(compressed);
          break;
        }
      } else {
        // 必须包含，压缩其他内容
        result.push(item);
        usedTokens += itemTokens;
      }
    }

    return { items: result };
  }
}

class IncrementalIndexer {
  async update(changes: FileChange[]): Promise<void> {
    for (const change of changes) {
      if (change.type === 'modified') {
        // 只重新索引变更的文件
        await this.indexFile(change.path);
      } else if (change.type === 'deleted') {
        // 从索引中移除
        await this.removeFromIndex(change.path);
      } else if (change.type === 'added') {
        // 添加新文件到索引
        await this.indexFile(change.path);
      }
    }
  }
}

# approval.config.yaml
policies:
  # 总是需要审批的操作（红线）
  always:
    - "database.write"
    - "database.schema.change"
    - "filesystem.delete"
    - "filesystem.write:config/*"
    - "network.external"
    - "env.modify"
    - "production.deploy"
    - "secrets.access"

  # 从不需要审批的操作（安全区）
  never:
    - "filesystem.read"
    - "test.run"
    - "test.write"
    - "lint.fix"
    - "docs.write"
    - "analysis.*"

  # 选择性审批（基于条件）
  selective:
    # 代码修改：有测试可以不审批
    - operation: "code.write"
      condition: "hasTests && testCoverage > 80%"
      approval: false
    - operation: "code.write"
      condition: "!hasTests || testCoverage < 80%"
      approval: true

    # 文件写入：src 目录可以不审批
    - operation: "filesystem.write"
      condition: "path.startsWith('/src/')"
      approval: false
    - operation: "filesystem.write"
      condition: "path.startsWith('/config/')"
      approval: true

    # 代码执行：有测试可以不审批
    - operation: "code.execute"
      condition: "hasTests && testsPass"
      approval: false
    - operation: "code.execute"
      condition: "!hasTests"
      approval: true

  # 基于文件类型的审批
  file_types:
    "*.ts": "selective"
    "*.tsx": "selective"
    "*.sql": "always"
    "*.config.*": "always"
    "*.env*": "always"
    "*.test.*": "never"
    "*.md": "never"

class ApprovalGateway {
  async requestApproval(request: ApprovalRequest): Promise<boolean> {
    // 1. 检查策略
    const policy = this.matchPolicy(request);

    if (policy.approval === 'never') {
      return true; // 自动批准
    }

    if (policy.approval === 'always') {
      return await this.humanApproval(request);
    }

    // 2. 选择性审批：评估条件
    if (policy.approval === 'selective') {
      const conditionsMet = await this.evaluateConditions(
        request, 
        policy.conditions
      );

      if (conditionsMet.autoApprove) {
        return true;
      }

      return await this.humanApproval(request);
    }

    return false;
  }

  private async humanApproval(request: ApprovalRequest): Promise<boolean> {
    // 发送审批请求给人类
    const notification = await this.notifyHuman(request);

    // 等待响应（带超时）
    const response = await this.waitForResponse(notification, {
      timeout: 300000, // 5 分钟
      reminders: [60000, 180000] // 1 分钟、3 分钟提醒
    });

    return response.approved;
  }
}

interface ActivityLog {
  // 基本信息
  id: string;
  timestamp: string;
  sessionId: string;
  actor: 'human' | 'ai';

  // 操作信息
  operation: string;
  target: string;
  parameters: Record<string, any>;

  // 审批信息
  approvalRequired: boolean;
  approvalStatus?: 'pending' | 'approved' | 'rejected';
  approver?: string;
  approvalTime?: number; // 审批耗时（毫秒）

  // 执行结果
  status: 'success' | 'failure' | 'partial';
  result?: any;
  error?: Error;
  executionTime?: number; // 执行耗时（毫秒）

  // 上下文快照
  contextSnapshot: {
    filesChanged: string[];
    linesAdded: number;
    linesDeleted: number;
    testsRun: number;
    testsPassed: number;
  };

  // 元数据
  metadata: {
    task: string;
    project: string;
    branch?: string;
    commit?: string;
  };
}

-- 查询需要最多审批的操作类型
SELECT operation, COUNT(*) as approval_count
FROM activity_logs
WHERE approval_required = true
GROUP BY operation
ORDER BY approval_count DESC
LIMIT 10;

-- 查询 AI 自主执行失败率
SELECT operation, 
       COUNT(*) as total,
       SUM(CASE WHEN status = 'failure' THEN 1 ELSE 0 END) as failures,
       (SUM(CASE WHEN status = 'failure' THEN 1 ELSE 0 END) * 100.0 / COUNT(*)) as failure_rate
FROM activity_logs
WHERE approval_required = false
GROUP BY operation
HAVING failure_rate > 5;

-- 查询审批平均耗时
SELECT operation, AVG(approval_time) / 1000 as avg_approval_seconds
FROM activity_logs
WHERE approval_required = true
  AND approval_status = 'approved'
GROUP BY operation
ORDER BY avg_approval_seconds DESC;

// collaboration.metrics.ts
interface CollaborationDashboard {
  // 今日统计
  today: {
    tasksCompleted: number;
    aiSuggestions: number;
    humanInterventions: number;
    approvalRequests: number;
  };

  // 质量指标
  quality: {
    codeReviewPassRate: number;
    testCoverage: number;
    productionBugs: number;
  };

  // 效率指标
  efficiency: {
    averageTaskTime: number;
    approvalResponseTime: number;
    autonomousTaskRate: number;
  };

  // 安全指标
  security: {
    redLineViolations: number;
    approvalBypassAttempts: number;
    securityIncidents: number;
  };
}

# cowork-runtime.Dockerfile
FROM node:20-alpine

# 创建非 root 用户（安全最佳实践）
RUN addgroup -g 1000 cowork && \
    adduser -u 1000 -G cowork -s /bin/sh -D cowork

# 设置工作目录
WORKDIR /workspace

# 安装必要工具
RUN apk add --no-cache git curl

# 限制权限
USER cowork

# 只开放必要端口
EXPOSE 3000

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD wget -q --spider http://localhost:3000/health || exit 1

# 启动命令
CMD ["node", "server.js"]

# docker-compose.cowork.yaml
version: '3.8'
services:
  cowork-runtime:
    build:
      context: .
      dockerfile: cowork-runtime.Dockerfile
    container_name: cowork-sandbox

    # 资源限制（防止资源耗尽）
    deploy:
      resources:
        limits:
          cpus: '2.0'
          memory: 4G
        reservations:
          cpus: '0.5'
          memory: 1G

    # 文件系统隔离
    volumes:
      # 只读挂载项目代码
      - ./project:/workspace:ro
      # 可写输出目录
      - ./output:/output:rw
      # 临时文件
      - /tmp/cowork:/tmp:rw

    # 网络限制
    networks:
      - cowork-network

    # 安全配置
    security_opt:
      - no-new-privileges:true  # 禁止提权
    read_only: true  # 根文件系统只读
    tmpfs:
      - /tmp:size=1G  # 临时文件系统

    # 禁止的功能
    cap_drop:
      - ALL
    cap_add:
      - NET_BIND_SERVICE  # 只保留必要的功能

networks:
  cowork-network:
    driver: bridge
    internal: true  # 隔离外部网络，只能通过代理访问

# network.policy.yaml
network:
  # 默认拒绝所有外部访问
  default_policy: deny

  # 白名单域名
  allowed_domains:
    - registry.npmjs.org
    - api.github.com
    - docs.example.com

  # 禁止访问的地址
  denied_addresses:
    - 169.254.169.254  # 云元数据服务
    - localhost
    - 127.0.0.1
    - 10.0.0.0/8
    - 192.168.0.0/16

  # 代理配置（所有外部请求通过代理）
  proxy:
    enabled: true
    url: http://proxy:8080
    log_all_requests: true

# filesystem.permissions.yaml
permissions:
  # 完全访问（读 + 写 + 执行）
  full_access:
    - /workspace/src
    - /workspace/tests
    - /output
    - /tmp

  # 只读访问
  read_only:
    - /workspace/config
    - /workspace/docs
    - /workspace/package.json
    - /workspace/tsconfig.json

  # 禁止访问（红线）
  denied:
    - /workspace/.env
    - /workspace/.env.*
    - /workspace/.git
    - /root
    - /etc
    - /home
    - /var

  # 条件访问（基于操作类型）
  conditional:
    - path: /workspace/database
      operations: [read]
      write_allowed: false
      reason: "数据库目录只读，防止意外修改"

    - path: /workspace/migrations
      operations: [read, write]
      requires_approval: true
      reason: "迁移文件需要审批"

    - path: /workspace/src/core
      operations: [read, write]
      requires_approval: true
      reason: "核心代码修改需要审批"

// filesystem.middleware.ts
class FilesystemMiddleware {
  private permissions: PermissionSet;
  private logger: ActivityLogger;

  async checkAccess(
    path: string, 
    operation: 'read' | 'write' | 'execute'
  ): Promise<boolean> {
    const resolvedPath = path.resolve(path);
    const sessionId = this.getCurrentSessionId();

    // 1. 检查是否在禁止列表
    if (this.isDenied(resolvedPath)) {
      await this.logViolation(sessionId, path, operation, 'denied_path');
      throw new ForbiddenError(`Access denied to ${path}`);
    }

    // 2. 检查是否在授权列表
    if (!this.isAuthorized(resolvedPath, operation)) {
      await this.logViolation(sessionId, path, operation, 'unauthorized');
      throw new UnauthorizedError(`No ${operation} permission for ${path}`);
    }

    // 3. 检查是否需要审批
    if (this.requiresApproval(resolvedPath, operation)) {
      const approved = await this.requestApproval(sessionId, path, operation);
      if (!approved) {
        throw new ApprovalRejectedError(`Approval rejected for ${operation} on ${path}`);
      }
    }

    // 4. 记录成功访问
    await this.logger.log({
      sessionId,
      operation: 'filesystem.' + operation,
      target: path,
      status: 'success'
    });

    return true;
  }

  private isDenied(path: string): boolean {
    return this.permissions.denied.some(pattern => 
      minimatch(path, pattern)
    );
  }

  private isAuthorized(path: string, operation: string): boolean {
    // 检查完全访问
    if (this.permissions.full_access.some(pattern => 
      minimatch(path, pattern)
    )) {
      return true;
    }

    // 检查只读访问
    if (operation === 'read' && this.permissions.read_only.some(pattern => 
      minimatch(path, pattern)
    )) {
      return true;
    }

    return false;
  }
}

// 防止路径遍历攻击
function safeResolvePath(basePath: string, inputPath: string): string {
  const resolved = path.resolve(basePath, inputPath);
  const normalizedBase = path.normalize(basePath + path.sep);

  // 确保解析后的路径在基准目录内
  if (!resolved.startsWith(normalizedBase)) {
    throw new SecurityError(
      `Path traversal attempt detected: ${inputPath}`
    );
  }

  return resolved;
}

# cowork.config.yaml
project: api-refactor
version: 1.0

session:
  mode: human-on-the-loop
  timeout: 3600  # 1 小时无操作自动暂停

approval_policy:
  always:
    - "database.schema"
    - "database.migration"
    - "api.breaking_changes"
    - "config.production"
    - "env.modify"

  selective:
    - operation: "code.refactor"
      condition: "test_coverage > 80%"
      approval: false
    - operation: "code.refactor"
      condition: "test_coverage < 80%"
      approval: true
    - operation: "code.write"
      condition: "path.includes('/src/api/')"
      approval: false
    - operation: "code.write"
      condition: "path.includes('/src/core/')"
      approval: true

  never:
    - "test.write"
    - "test.run"
    - "lint.fix"
    - "docs.write"

permissions:
  full_access:
    - /src/api
    - /tests
    - /output
  read_only:
    - /src/core
    - /config
    - /docs
  denied:
    - /.env
    - /.git
    - /scripts/prod-*

context:
  include:
    - "src/**/*.ts"
    - "tests/**/*.ts"
    - "docs/api-spec.md"
    - "docs/architecture.md"
  exclude:
    - "node_modules"
    - "dist"
    - "coverage"

# 重构专用配置
refactor:
  strategy: "incremental"  # 渐进式
  max_files_per_batch: 5
  require_tests: true
  min_test_coverage: 80

// AI 生成的测试示例
describe('UserService', () => {
  describe('createUser', () => {
    it('应该创建新用户', async () => {
      const user = await userService.createUser({
        email: 'test@example.com',
        name: 'Test User'
      });

      expect(user.id).toBeDefined();
      expect(user.email).toBe('test@example.com');
    });

    it('邮箱重复应该抛出错误', async () => {
      await userService.createUser({
        email: 'existing@example.com',
        name: 'User 1'
      });

      await expect(
        userService.createUser({
          email: 'existing@example.com',
          name: 'User 2'
        })
      ).rejects.toThrow('Email already exists');
    });
  });
});

重构顺序：
1. 用户模块（独立，依赖少）
2. 认证模块（依赖用户模块）
3. 订单模块（复杂，最后重构）

// 新旧 API 并存
app.use('/api/v1/users', oldUserRoutes);  // 旧 API
app.use('/api/v2/users', newUserRoutes);  // 新 API

// 逐步迁移流量
// 第 1 周：10% 流量到新 API
// 第 2 周：50% 流量到新 API
// 第 3 周：100% 流量到新 API
// 第 4 周：下线旧 API

# cowork.config.yaml
project: data-migration
version: 1.0

session:
  mode: hybrid  # 混合模式

approval_policy:
  always:
    - "database.write"
    - "data.delete"
    - "migration.execute"
    - "rollback.execute"

  selective:
    - operation: "data.transform"
      condition: "sample_size < 1000"
      approval: false
    - operation: "data.transform"
      condition: "sample_size >= 1000"
      approval: true

  never:
    - "data.read"
    - "validation.run"
    - "report.generate"
    - "analysis.*"

permissions:
  full_access:
    - /migration/scripts
    - /migration/logs
    - /migration/samples
    - /migration/output
  read_only:
    - /migration/config
    - /migration/source-schema
  denied:
    - /migration/production-db
    - /src
    - /.env

# 数据迁移专用配置
migration:
  batch_size: 10000
  dry_run_required: true
  rollback_enabled: true
  validation_rules:
    - "row_count_match"
    - "checksum_verify"
    - "foreign_key_check"
    - "business_rules_check"

  # 熔断机制
  circuit_breaker:
    enabled: true
    failure_threshold: 3
    reset_timeout: 300  # 5 分钟后重置

// 小样本测试
const sampleData = await sourceDb.users.limit(1000).select();
const transformed = await transform(sampleData);
const validation = await validate(transformed);

if (!validation.passed) {
  throw new MigrationError('小样本验证失败', validation.errors);
}

// 分批迁移
const totalRecords = await sourceDb.users.count();
const batchSize = 10000;
const totalBatches = Math.ceil(totalRecords / batchSize);

for (let i = 0; i < totalBatches; i++) {
  const offset = i * batchSize;
  const batch = await sourceDb.users.limit(batchSize).offset(offset);

  // 请求审批
  const approved = await requestApproval({
    operation: 'migration.execute',
    batchId: i,
    recordCount: batch.length
  });

  if (!approved) {
    logger.warn(`批次 ${i} 未获批准，跳过`);
    continue;
  }

  // 执行迁移
  await migrateBatch(batch);

  // 批间暂停，让人类检查
  if (i % 10 === 0) {
    logger.info(`已完成 ${i} 批，暂停检查`);
    await pauseForHumanCheck();
  }
}

// 验证函数
async function validateMigration(sourceCount: number, targetCount: number): Promise<void> {
  // 1. 行数检查
  if (sourceCount !== targetCount) {
    throw new ValidationError(`行数不匹配：源${sourceCount}, 目标${targetCount}`);
  }

  // 2. 校验和检查
  const sourceChecksum = await calculateChecksum(sourceDb);
  const targetChecksum = await calculateChecksum(targetDb);

  if (sourceChecksum !== targetChecksum) {
    throw new ValidationError(`校验和不匹配`);
  }

  // 3. 外键检查
  await checkForeignKeys(targetDb);

  // 4. 业务规则检查
  await checkBusinessRules(targetDb);
}

// 回滚机制
class MigrationExecutor {
  async executeBatch(batch: DataBatch): Promise<MigrationResult> {
    // 1. 创建回滚点
    const rollbackPoint = await this.createRollbackPoint();

    try {
      // 2. 执行迁移
      const result = await this.migrate(batch);

      // 3. 验证结果
      await this.validateResult(result);

      // 4. 提交（删除回滚点）
      await this.commitRollbackPoint(rollbackPoint);

      return result;
    } catch (error) {
      // 5. 失败回滚
      logger.error('迁移失败，执行回滚', error);
      await this.rollback(rollbackPoint);
      throw error;
    }
  }
}

session:
  mode: human-out-of-the-loop
approval_policy:
  never:
    - "test.write"
    - "test.run"
permissions:
  denied:
    - /src/**/*.ts  # 禁止修改源代码
test_generation:
  target_coverage: 80
  quality_gates:
    - test_must_pass: true
    - min_coverage_increase: 1%

# red_lines.yaml
never_autonomous:
  # 安全相关
  - "credentials.access"
  - "secrets.modify"
  - "encryption.keys"
  - "api_keys.read"

  # 生产环境
  - "production.deploy"
  - "production.config"
  - "production.database"
  - "production.logs.delete"

  # 用户数据
  - "user_data.delete"
  - "user_data.export"
  - "user_data.modify_schema"
  - "user_data.bulk_update"

  # 财务相关
  - "payment.process"
  - "billing.modify"
  - "refund.execute"
  - "invoice.delete"

  # 法律合规
  - "audit_logs.modify"
  - "compliance.config"
  - "legal_documents.change"
  - "gdpr_data.delete"

  # 基础设施
  - "infrastructure.delete"
  - "backup.delete"
  - "monitoring.disable"

// red_lines.enforcer.ts
class RedLinesEnforcer {
  private static readonly RED_LINES = [
    /.*\.env.*/,
    /.*secrets.*/,
    /.*production.*config.*/,
    /.*payment.*process.*/,
    /.*user.*data.*delete.*/,
    /.*audit.*log.*modify.*/,
  ];

  async checkOperation(operation: string, target: string): Promise<void> {
    const redLine = this.RED_LINES.find(pattern => 
      pattern.test(target)
    );

    if (redLine) {
      // 记录违规尝试
      await this.logViolation(operation, target);

      // 立即终止会话
      await this.terminateSession();

      // 发送告警
      await this.sendAlert(`红线违规：${operation} on ${target}`);

      throw new RedLineViolationError(
        `Operation '${operation}' on '${target}' violates red line`
      );
    }
  }
}

# rollback.config.yaml
rollback:
  # 自动回滚触发条件
  auto_rollback_triggers:
    - "test_failure_rate > 10%"
    - "production_error_rate > 1%"
    - "performance_degradation > 20%"
    - "security_scan_failed"

  # 回滚点保留策略
  retention:
    keep_last_n: 10
    keep_hourly: 24
    keep_daily: 7
    keep_weekly: 4
    keep_monthly: 12

  # 回滚时间目标
  rto:
    target: "5 minutes"
    maximum: "15 minutes"

  # 回滚验证
  validation:
    - "health_check"
    - "smoke_test"
    - "data_integrity"
    - "critical_path_test"

  # 通知配置
  notification:
    on_rollback: true
    on_auto_rollback: true
    recipients:
      - team-lead
      - on-call

// 自动创建回滚点
class RollbackManager {
  async beforeOperation(operation: string): Promise<string> {
    const rollbackPoint = await this.createSnapshot();

    await this.logger.log({
      operation: 'rollback.create',
      target: rollbackPoint.id,
      metadata: {
        beforeOperation: operation
      }
    });

    return rollbackPoint.id;
  }
}

// 快速回滚
async function rollback(pointId: string): Promise<void> {
  const startTime = Date.now();

  // 1. 停止当前服务
  await stopService();

  // 2. 恢复快照
  await restoreSnapshot(pointId);

  // 3. 验证恢复
  await validateRestoration();

  // 4. 重启服务
  await startService();

  const duration = (Date.now() - startTime) / 1000;
  logger.info(`回滚完成，耗时${duration}秒`);

  if (duration > 300) {
    logger.warn('回滚时间超过 5 分钟，需要优化');
  }
}

// 回滚验证
async function validateRestoration(): Promise<void> {
  // 1. 健康检查
  const health = await healthCheck();
  if (!health.healthy) {
    throw new RollbackError('健康检查失败');
  }

  // 2. 冒烟测试
  const smokeTest = await runSmokeTests();
  if (!smokeTest.passed) {
    throw new RollbackError('冒烟测试失败');
  }

  // 3. 数据完整性检查
  const integrity = await checkDataIntegrity();
  if (!integrity.valid) {
    throw new RollbackError('数据完整性检查失败');
  }
}

// collaboration.metrics.ts
interface CollaborationMetrics {
  // 效率指标
  tasksCompleted: number;
  averageTaskTime: number;
  humanInterventionRate: number;
  autonomousTaskRate: number;

  // 质量指标
  codeReviewPassRate: number;
  testCoverage: number;
  productionBugs: number;
  technicalDebt: number;

  // 安全指标
  approvalBypassAttempts: number;
  redLineViolations: number;
  securityIncidents: number;
  rollbackCount: number;

  // 信任指标
  autonomousTaskSuccessRate: number;
  aiSuggestionAcceptanceRate: number;
  approvalApprovalRate: number;
}

✅ 数据库写操作    ✅ 生产配置修改    ✅ 用户数据删除
✅ 支付/财务逻辑   ✅ 密钥/密码访问   ✅ 审计日志修改

阶段 1→2: 审批通过率 >95%，无事故
阶段 2→3: 自主执行成功率 >98%
阶段 3→4: 测试覆盖率 >80%，代码审查通过率 >90%