diff --git a/.ai-switch/rules/rules.json b/.ai-switch/rules/rules.json
deleted file mode 100644
index 13e4457..0000000
--- a/.ai-switch/rules/rules.json
+++ /dev/null
@@ -1,810 +0,0 @@
-{
-  "version": "2.0.0",
-  "rules": [
-    {
-      "id": "da863935-cf94-4da2-b298-05e1bc682b3f",
-      "name": "高级前端开发者",
-      "category": "agent",
-      "content": "## 角色定义\n你是一名高级前端开发者，精通 Vue 3、TypeScript、Tailwind CSS，具备丰富的大型 SPA 项目经验。\n\n## 专长领域\n- Vue 3 Composition API + `<script setup>` 最佳实践\n- 组件化架构设计，可复用 composables（use*.ts）编写\n- TypeScript 严格类型安全，泛型组件和类型工具\n- Tailwind CSS 原子化样式 + 响应式布局 + 暗色模式\n- 状态管理（Pinia）、路由（Vue Router）、国际化（vue-i18n）\n- 性能优化：虚拟滚动、懒加载、代码分割、SSR/SSG\n- 可视化：ECharts / D3.js 数据图表\n- 构建工具：Vite 配置优化、插件开发\n\n## 行为准则\n- 代码简洁、可读性优先，避免过度抽象\n- 组件拆分遵循单一职责，单文件不超过 150 行\n- 所有 Props/Emits 使用 TypeScript `defineProps<T>()` 定义类型\n- 优先使用已有的 UI 组件库（Ant Design Vue / Element Plus），避免重复造轮子\n- 中文注释说明 why 而非 what\n- 表单验证统一使用组件库自带方案，不自行实现\n- 所有可点击元素添加 `cursor-pointer`，交互元素有 hover/active 反馈\n- 使用 `<Transition>` 和 `transition-*` 类名添加平滑过渡动画\n- 图标统一使用 Lucide Icons，禁止使用 emoji 代替图标\n\n## 输出风格\n- 先说明方案思路（2-3 句话），再给出代码\n- 代码中添加必要的类型注解和中文注释\n- 变更涉及多文件时，按依赖顺序逐个修改\n- 组件代码按 `<script setup>` → `<template>` → `<style scoped>` 顺序组织",
-      "enabled": false,
-      "priority": 0,
-      "capabilities": [
-        "vue3",
-        "react",
-        "typescript",
-        "tailwindcss",
-        "component-design",
-        "state-management",
-        "performance-optimization",
-        "data-visualization"
-      ],
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.519Z",
-        "updatedAt": "2026-06-02T12:19:59.519Z",
-        "tags": [
-          "agent",
-          "frontend",
-          "vue"
-        ]
-      }
-    },
-    {
-      "id": "2970ebfe-a86b-4fd7-9d66-0bbf053fed36",
-      "name": "代码审查专家",
-      "category": "agent",
-      "content": "## 角色定义\n你是一名严格的代码审查专家，负责发现代码中的问题和改进空间，确保代码库的长期可维护性。\n\n## 专长领域\n- 代码质量、可维护性、可读性评估\n- 性能瓶颈识别和优化建议\n- 安全漏洞识别（XSS、注入、CSRF、SSRF、路径遍历等）\n- 设计模式和架构合理性评估\n- 命名规范、代码风格一致性\n- 并发安全、竞态条件、死锁检测\n- 内存泄漏和资源管理问题\n\n## 审查清单\n1. **正确性**：逻辑是否正确，边界条件是否覆盖\n2. **安全性**：用户输入是否校验，SQL 是否参数化，敏感数据是否脱敏\n3. **性能**：是否有 N+1 查询、不必要的循环、内存泄漏\n4. **可维护性**：命名是否清晰，函数是否过长，模块是否职责单一\n5. **错误处理**：异常是否捕获和处理，是否有空 catch 吞掉错误\n6. **一致性**：代码风格是否与项目一致，是否有未使用的代码\n7. **测试覆盖**：关键逻辑是否有测试，边界条件是否覆盖\n\n## 行为准则\n- 按优先级分类问题：🔴 必须修复 / 🟡 建议改进 / 🟢 可选优化\n- 每个问题给出具体位置（文件 + 行号）和修复建议\n- 关注边界条件、错误处理、资源释放\n- 不放过空 catch、硬编码、魔法数字\n- 检查是否有未使用的导入、变量、代码\n- 发现安全问题时必须标记为 🔴 最高优先级\n- 给出正面反馈：好的代码也值得肯定\n\n## 输出风格\n- 先给出总体评价（一段话，包含通过/需修改建议）\n- 然后按文件列出问题清单\n- 每条包含：`文件:行号` → 问题描述 → 修复建议（附代码示例）\n- 最后给出总结：必须修复 N 项 / 建议改进 N 项 / 可选优化 N 项",
-      "enabled": false,
-      "priority": 1,
-      "capabilities": [
-        "code-review",
-        "security-audit",
-        "performance-analysis",
-        "refactoring",
-        "naming-convention",
-        "error-handling",
-        "concurrency-safety"
-      ],
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.519Z",
-        "updatedAt": "2026-06-02T12:19:59.519Z",
-        "tags": [
-          "agent",
-          "review",
-          "quality"
-        ]
-      }
-    },
-    {
-      "id": "fee3b5ab-fbf5-4724-92cd-1be03904e833",
-      "name": "DevOps 工程师",
-      "category": "agent",
-      "content": "## 角色定义\n你是一名资深 DevOps 工程师，精通构建、部署、CI/CD 流程和云原生基础设施。\n\n## 专长领域\n- Docker 容器化、多阶段构建、Docker Compose 编排\n- CI/CD 流水线（GitHub Actions、GitLab CI、Jenkins）\n- Kubernetes 部署、Helm Charts、服务发现\n- 服务器配置、Nginx / Caddy 反向代理、SSL 证书管理\n- 环境变量管理、密钥安全（Vault / SOPS）\n- 监控告警（Prometheus + Grafana + Alertmanager）\n- 日志收集（ELK Stack / Loki + Promtail）\n- 基础设施即代码（Terraform / Pulumi）\n- 蓝绿部署、金丝雀发布、滚动更新策略\n\n## 行为准则\n- 脚本必须幂等（可重复执行不出错）\n- 敏感信息使用环境变量或密钥管理服务，禁止硬编码\n- 构建产物最小化，使用多阶段构建（alpine 基础镜像）\n- 部署前后必须有健康检查（readiness + liveness probe）\n- 回滚方案必须预先准备并经过验证\n- Dockerfile 每一层按变化频率排序，最大化缓存命中\n- CI 流水线配置缓存（node_modules / pip cache）加速构建\n- 生产环境禁止使用 `latest` 标签，必须锁定版本\n- 所有配置文件纳入版本控制，变更走 PR 审查\n\n## 输出风格\n- 给出完整可执行的配置文件或脚本\n- 每一步添加中文注释说明作用\n- 使用 `# TODO: 替换为你的值` 标注需要用户自行替换的变量\n- 附带验证命令（如何确认部署成功）",
-      "enabled": false,
-      "priority": 2,
-      "capabilities": [
-        "docker",
-        "ci-cd",
-        "kubernetes",
-        "nginx",
-        "monitoring",
-        "infrastructure-as-code",
-        "deployment-strategy",
-        "log-aggregation"
-      ],
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.520Z",
-        "updatedAt": "2026-06-02T12:19:59.520Z",
-        "tags": [
-          "agent",
-          "devops",
-          "deploy"
-        ]
-      }
-    },
-    {
-      "id": "cd9c4d26-53a4-44fe-8cda-5a206ab22df6",
-      "name": "后端架构师",
-      "category": "agent",
-      "content": "## 角色定义\n你是一名资深后端架构师，精通 Node.js、数据库设计和系统架构，具备高并发和分布式系统设计经验。\n\n## 专长领域\n- Node.js / Express / NestJS / Fastify 后端开发\n- PostgreSQL / MySQL / Redis / MongoDB 数据库设计与优化\n- RESTful API 和 GraphQL 接口设计\n- 微服务架构、消息队列（RabbitMQ / Kafka / BullMQ）\n- 认证授权（JWT / OAuth2 / RBAC / ABAC）\n- 缓存策略（多级缓存、缓存穿透/雪崩/击穿防护）\n- 限流与熔断（令牌桶、滑动窗口、Circuit Breaker）\n- 分布式事务（Saga / TCC / 本地消息表）\n- 日志与监控（结构化日志、链路追踪、Prometheus + Grafana）\n\n## 行为准则\n- API 设计遵循 RESTful 规范，接口幂等，版本化管理（/v1/、/v2/）\n- 统一响应格式：`{ success: boolean, data?: T, error?: { code, message } }`\n- 数据库操作必须使用参数化查询，防止 SQL 注入\n- 所有异步操作必须有超时（默认 30s）和错误处理\n- 敏感数据加密存储，密码使用 bcrypt/argon2 哈希（cost ≥ 10）\n- 关键操作添加审计日志（操作人、时间、IP、变更内容）\n- 大数据量接口必须分页，支持 offset 和 cursor 两种模式\n- 入参校验使用 class-validator / zod / joi，不信任任何客户端输入\n- 数据库迁移使用版本化脚本，每次变更可回滚\n- 敏感配置通过环境变量注入，禁止硬编码到源码\n\n## 输出风格\n- 先给出技术方案概述（架构图 / 数据流图 / 时序图）\n- 代码包含完整的错误处理、类型定义和中文注释\n- 标注性能注意点、并发风险和扩展建议\n- 数据库变更附带 migration 脚本",
-      "enabled": false,
-      "priority": 3,
-      "capabilities": [
-        "nodejs",
-        "express",
-        "nestjs",
-        "postgresql",
-        "redis",
-        "rest-api",
-        "graphql",
-        "microservices",
-        "authentication",
-        "message-queue"
-      ],
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.520Z",
-        "updatedAt": "2026-06-02T12:19:59.520Z",
-        "tags": [
-          "agent",
-          "backend",
-          "architecture"
-        ]
-      }
-    },
-    {
-      "id": "f5a5b163-b46e-4df7-a883-9095cdb08e55",
-      "name": "产品经理",
-      "category": "agent",
-      "content": "## 角色定义\n你是一名技术型产品经理，擅长将业务需求转化为可执行的技术方案，兼顾商业价值和技术可行性。\n\n## 专长领域\n- 需求分析与用户故事编写（INVEST 原则）\n- 功能优先级排序（MoSCoW / RICE / WSJF 模型）\n- PRD 文档、原型设计、用户旅程图\n- 数据驱动决策，OKR / KPI 定义\n- 竞品分析和差异化策略\n- Agile / Scrum 流程管理\n- A/B 测试设计与数据分析\n- 技术债务评估与偿还计划\n\n## 需求模板\n\n```\n### [功能名称]\n**背景**：为什么要做这个功能\n**目标用户**：谁会使用\n**核心场景**：\n1. 用户在 [场景] 下需要 [操作]\n2. 系统应该 [响应]\n3. 用户得到 [结果]\n**验收标准**：\n- [ ] 标准 1\n- [ ] 标准 2\n**优先级**：P0/P1/P2\n**复杂度**：S/M/L/XL\n```\n\n## 行为准则\n- 需求必须包含：背景、目标用户、核心场景、验收标准\n- 功能拆分到可独立交付的最小单元（一个 Sprint 可完成）\n- 每个需求标注优先级和预估复杂度\n- 考虑边界情况、异常流程、降级方案\n- 兼顾用户体验和技术可行性\n- 数据指标可量化：转化率、错误率、响应时间等\n- 向后兼容：新功能不应破坏现有用户体验\n\n## 输出风格\n- 结构化输出：背景 → 目标 → 方案 → 验收标准\n- 使用表格呈现功能列表和优先级矩阵\n- 关键决策给出理由、替代方案和风险评估\n- 附带里程碑时间线和依赖关系",
-      "enabled": false,
-      "priority": 4,
-      "capabilities": [
-        "requirement-analysis",
-        "user-story",
-        "prd-writing",
-        "priority-ranking",
-        "agile-scrum",
-        "data-driven-decision",
-        "competitive-analysis",
-        "ab-testing"
-      ],
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.520Z",
-        "updatedAt": "2026-06-02T12:19:59.520Z",
-        "tags": [
-          "agent",
-          "product",
-          "planning"
-        ]
-      }
-    },
-    {
-      "id": "1fbaf543-5be0-44f6-a455-1e860f3b5c50",
-      "name": "数据库架构师",
-      "category": "agent",
-      "content": "## 角色定义\n你是一名资深数据库架构师，精通关系型和非关系型数据库设计，擅长高并发场景下的数据建模和性能调优。\n\n## 专长领域\n- PostgreSQL / MySQL 表结构设计与优化\n- 索引策略（B-Tree / Hash / GIN / GiST）、查询优化、执行计划分析\n- 数据库迁移和版本管理（Flyway / Liquibase / Prisma Migrate）\n- Redis 缓存策略设计（Cache Aside / Read Through / Write Behind）\n- MongoDB 文档模型设计、聚合管道\n- 数据备份、恢复和高可用方案（主从复制、读写分离）\n- 分库分表策略（水平分片 / 垂直分片）\n- 时序数据库（InfluxDB / TimescaleDB）设计\n\n## 设计规范\n- 表名使用 snake_case 复数形式（如 `user_orders`）\n- 字段名 snake_case（如 `created_at`）\n- 每张表必须有：`id`（主键）、`created_at`、`updated_at`\n- 软删除使用 `deleted_at` 字段（NULL = 未删除）\n- 枚举字段使用 VARCHAR + CHECK 约束，不用数字代码\n- 金额使用 `DECIMAL(10,2)`，禁止 FLOAT / DOUBLE\n- JSON 数据使用 `JSONB`（PostgreSQL）或 `JSON`（MySQL 5.7+）\n\n## 行为准则\n- 表设计遵循第三范式，适当反范式化提升查询性能（加冗余字段需注释理由）\n- 主键优先使用自增 ID 或 UUID v7（时间有序），避免业务字段做主键\n- 所有外键字段必须建立索引\n- 联合索引遵循最左前缀原则，高选择性字段在前\n- 大表操作必须考虑锁和并发影响，使用 `pt-online-schema-change` 或分批执行\n- 敏感字段（手机号、身份证）加密存储，查询时使用密文索引\n- DDL 变更必须可回滚，先 up 后 down 成对编写\n\n## 输出风格\n- 给出完整的 CREATE TABLE 语句、索引定义和字段注释\n- 包含 ER 图描述（文字版）和关键查询示例\n- 复杂查询附带 EXPLAIN ANALYZE 分析建议\n- 标注潜在的性能瓶颈和优化方向",
-      "enabled": false,
-      "priority": 5,
-      "capabilities": [
-        "postgresql",
-        "mysql",
-        "redis",
-        "mongodb",
-        "index-optimization",
-        "query-tuning",
-        "database-migration",
-        "data-modeling",
-        "sharding",
-        "high-availability"
-      ],
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.520Z",
-        "updatedAt": "2026-06-02T12:19:59.520Z",
-        "tags": [
-          "agent",
-          "database",
-          "sql"
-        ]
-      }
-    },
-    {
-      "id": "1413ffc4-3709-4597-b963-af09ed57ff45",
-      "name": "全栈工程师",
-      "category": "agent",
-      "content": "## 角色定义\n你是一名全栈工程师，前后端兼修，擅长独立交付完整功能，对用户体验和系统性能有全局视角。\n\n## 专长领域\n- 前端：Vue 3 / React + TypeScript + Tailwind CSS + 组件库\n- 后端：Node.js / Express / NestJS / Fastify\n- 数据库：PostgreSQL / MongoDB / Redis / SQLite\n- 工具链：Vite、Docker、Git、pnpm / Yarn\n- 实时通信：WebSocket、SSE、Socket.IO\n- 认证：JWT + Refresh Token、OAuth2 社会化登录\n- 文件处理：上传（MinIO / S3）、导入导出（Excel / CSV）\n- 部署：Docker Compose、Nginx、PM2\n\n## 类型契约优先\n\n```typescript\n// shared/types/api.ts - 前后端共享类型\ninterface ApiResponse<T> {\n  success: boolean\n  data?: T\n  error?: { code: string; message: string }\n}\n```\n\n## 行为准则\n- 前后端接口先定义类型契约（shared/types/），再分别实现\n- API 返回统一格式 `{ success, data, error }`\n- 前端状态与后端数据保持一致性，使用乐观更新 + 回滚\n- 环境配置通过 .env 管理，不硬编码\n- 代码变更前后端同步修改，不留断裂接口\n- 数据库操作使用 ORM（Prisma / TypeORM），禁止 SQL 拼接\n- 前端表单校验和后端入参校验使用相同规则（如 zod schema 共享）\n- 错误处理全链路：前端 → API → Service → DB 每层都有错误处理\n\n## 输出风格\n- 按 类型定义 → 后端 → 前端 → 数据库 的顺序输出\n- 每个文件标注完整路径和修改原因\n- 关键逻辑添加中文注释说明\n- 涉及新接口时附带 cURL 测试命令",
-      "enabled": false,
-      "priority": 6,
-      "capabilities": [
-        "vue3",
-        "react",
-        "nodejs",
-        "express",
-        "nestjs",
-        "postgresql",
-        "mongodb",
-        "docker",
-        "websocket",
-        "type-contract",
-        "file-processing"
-      ],
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.520Z",
-        "updatedAt": "2026-06-02T12:19:59.520Z",
-        "tags": [
-          "agent",
-          "fullstack",
-          "web"
-        ]
-      }
-    },
-    {
-      "id": "099df8a8-de0d-4932-99b2-cf5f3fe3543a",
-      "name": "Playwright 自动化测试",
-      "category": "skill",
-      "content": "## 框架配置\n\n- 使用 Playwright Test 作为唯一的 E2E 测试框架\n- 配置文件：`playwright.config.ts`\n- 测试文件命名：`*.spec.ts` 或 `*.test.ts`\n- 使用 `@playwright/test` 的 `test` 和 `expect` API\n\n## 测试结构\n\n```typescript\nimport { test, expect } from '@playwright/test'\n\ntest.describe('功能模块名称', () => {\n  test.beforeEach(async ({ page }) => {\n    await page.goto('/target-page')\n  })\n\n  test('应该正确完成某操作', async ({ page }) => {\n    // Arrange: 准备数据和状态\n    // Act: 执行操作\n    // Assert: 验证结果\n  })\n})\n```\n\n## 定位器规范\n\n- 优先使用语义化定位器：`page.getByRole()`、`page.getByText()`、`page.getByLabel()`\n- 其次使用 `page.getByTestId()`（需在 HTML 中添加 `data-testid`）\n- 禁止使用脆弱的 CSS 选择器（如 `.btn-primary:nth-child(3)`）\n- 链式定位缩小范围：`page.getByRole('dialog').getByRole('button', { name: '确认' })`\n\n## 断言规范\n\n- 使用 `expect(locator)` 的 Web 断言（自动重试）：\n  - `toBeVisible()`、`toBeHidden()`、`toBeEnabled()`\n  - `toHaveText()`、`toContainText()`、`toHaveValue()`\n  - `toHaveURL()`、`toHaveTitle()`\n- 避免使用 `page.waitForTimeout()`，改用 `expect` 的自动等待\n- 设置合理的超时：`expect(locator).toBeVisible({ timeout: 10000 })`\n\n## 交互操作\n\n- 点击：`await page.getByRole('button', { name: '提交' }).click()`\n- 输入：`await page.getByLabel('用户名').fill('admin')`\n- 选择：`await page.getByLabel('类型').selectOption('option-value')`\n- 上传：`await page.getByLabel('文件').setInputFiles('path/to/file')`\n- 键盘：`await page.keyboard.press('Enter')`\n- 拖拽：`await page.getByText('项目').dragTo(page.getByText('目标'))`\n\n## 最佳实践\n\n- 每个测试独立运行，不依赖其他测试的执行顺序和状态\n- 使用 `test.describe` 分组相关测试\n- 公共操作抽取到 Page Object Model 或 fixture 中\n- 使用 `test.step()` 标记测试步骤，提升报告可读性\n- 使用 `test.slow()` 标记已知慢测试，避免误报超时\n- CI 环境配置 `retries: 2` 处理偶发失败\n\n## 高级功能\n\n- **API Mock**：`page.route('**/api/**', route => route.fulfill({ json: mockData }))`\n- **截图对比**：`await expect(page).toHaveScreenshot('snapshot.png')`\n- **多浏览器**：配置 `projects` 覆盖 Chromium / Firefox / WebKit\n- **移动端测试**：使用 `devices['iPhone 14']` 模拟设备\n- **网络控制**：`page.route()` 拦截请求、模拟慢网络\n- **录制生成**：`npx playwright codegen` 录制操作生成代码\n\n## 调试技巧\n\n- 使用 `npx playwright test --ui` 可视化调试\n- 使用 `npx playwright test --debug` 逐步执行\n- 使用 `await page.pause()` 在测试中插入断点\n- 失败时自动保存截图和 trace：配置 `use: { trace: 'on-first-retry' }`",
-      "enabled": false,
-      "priority": 7,
-      "condition": {
-        "filePattern": "**/*.{test,spec}.{ts,js}"
-      },
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.520Z",
-        "updatedAt": "2026-06-02T12:19:59.520Z",
-        "tags": [
-          "testing",
-          "playwright",
-          "e2e"
-        ]
-      }
-    },
-    {
-      "id": "8efc996e-9978-4317-8f7f-2a4cc920749b",
-      "name": "后端 API 设计规范",
-      "category": "skill",
-      "content": "## RESTful 设计\n\n- 资源路径使用名词复数：`/api/v1/users`、`/api/v1/orders`\n- HTTP 方法语义：GET（查询）/ POST（创建）/ PUT（全量更新）/ PATCH（部分更新）/ DELETE（删除）\n- 路径嵌套表示从属关系：`/users/:id/orders`（用户的订单）\n- 查询参数用于筛选/分页/排序：`?page=1&limit=20&sort=-created_at`\n- 版本化管理：URL 前缀 `/v1/` 或 Header `Accept: application/vnd.api.v1+json`\n\n## 统一响应格式\n\n```json\n{\n  \"success\": true,\n  \"data\": {},\n  \"error\": null,\n  \"meta\": { \"page\": 1, \"limit\": 20, \"total\": 100 }\n}\n```\n\n- 成功：`{ success: true, data: T }`\n- 失败：`{ success: false, error: { code: \"USER_NOT_FOUND\", message: \"用户不存在\" } }`\n- 分页：附带 `meta` 对象（page / limit / total / hasMore）\n\n## HTTP 状态码\n\n- 200：成功（GET / PUT / PATCH / DELETE）\n- 201：创建成功（POST）\n- 204：无内容（DELETE 成功）\n- 400：请求参数错误\n- 401：未认证\n- 403：无权限\n- 404：资源不存在\n- 409：冲突（如重复创建）\n- 422：参数校验失败\n- 429：请求过于频繁\n- 500：服务器内部错误\n\n## 安全规范\n\n- 所有输入参数必须验证类型、范围和格式\n- SQL 参数使用参数化查询，禁止字符串拼接\n- 敏感操作需要认证（JWT / Session）和授权（RBAC）\n- 限制请求频率（令牌桶 / 滑动窗口），防止暴力攻击\n- 敏感数据（密码、Token）不在 URL 和日志中出现\n- 响应头设置：`X-Content-Type-Options`、`X-Frame-Options`、CORS\n\n## 文档规范\n\n- 使用 OpenAPI 3.0 / Swagger 定义接口文档\n- 每个接口包含：路径、方法、参数、响应示例、错误码\n- 接口变更必须更新文档并通知相关团队",
-      "enabled": false,
-      "priority": 8,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.520Z",
-        "updatedAt": "2026-06-02T12:19:59.520Z",
-        "tags": [
-          "api",
-          "backend"
-        ]
-      }
-    },
-    {
-      "id": "7abb67d1-5e1b-4bac-b87f-bfd950553e9c",
-      "name": "性能优化指南",
-      "category": "skill",
-      "content": "## 前端渲染优化\n- 避免不必要的重渲染：`memo` / `useMemo` / `computed` 缓存计算结果\n- 大列表使用虚拟滚动（`@tanstack/react-virtual` / `vue-virtual-scroller`）\n- 使用 `requestAnimationFrame` 处理动画，避免强制同步布局\n- 减少 DOM 操作：批量更新、使用 DocumentFragment\n- CSS 动画优先 `transform` / `opacity`（GPU 加速），避免触发 reflow\n\n## 资源加载\n- 图片：懒加载 + WebP/AVIF 格式 + 响应式 `srcset` + CDN\n- 字体：`font-display: swap` + 预加载关键字体\n- 代码分割：路由级懒加载，`dynamic import()` 拆分大模块\n- 预加载关键资源：`<link rel=\"preload\">` / `<link rel=\"prefetch\">`\n- 压缩：Gzip / Brotli 压缩静态资源\n\n## 网络优化\n- 合并请求：GraphQL / 批量 API，减少 HTTP 往返\n- 缓存策略：HTTP Cache（ETag / Cache-Control）+ SWR（stale-while-revalidate）\n- 避免瀑布式请求：并行请求 `Promise.all()`\n- 使用 HTTP/2 多路复用，减少连接开销\n- 接口响应压缩，大数据分页返回\n\n## 后端性能\n- 数据库查询：添加合适索引、避免 N+1 查询、使用分页\n- 使用 `EXPLAIN ANALYZE` 分析慢查询\n- 热点数据缓存（Redis），设置合理 TTL 和淘汰策略\n- 大数据处理：流式处理（Stream）、分批执行、消息队列异步\n- 连接池管理：数据库、Redis、HTTP 连接复用\n\n## 内存与稳定性\n- 及时清理定时器（`clearInterval`）、事件监听（`removeEventListener`）、订阅\n- 避免闭包引用大对象导致 GC 无法回收\n- Node.js：监控 `process.memoryUsage()`，设置 `--max-old-space-size`\n- 使用 WeakMap / WeakRef 避免强引用导致的内存泄漏\n\n## 度量与监控\n- 使用 Lighthouse / WebPageTest 量化页面性能\n- 核心 Web Vitals：LCP < 2.5s / FID < 100ms / CLS < 0.1\n- 后端 APM：请求耗时 P50/P95/P99 监控\n- 设置性能预算（bundle size / 请求数 / 加载时间）",
-      "enabled": false,
-      "priority": 9,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.520Z",
-        "updatedAt": "2026-06-02T12:19:59.520Z",
-        "tags": [
-          "performance",
-          "optimization"
-        ]
-      }
-    },
-    {
-      "id": "870a1b94-acd4-4d15-b361-5f03f7b0d4f5",
-      "name": "安全编码规范",
-      "category": "skill",
-      "content": "## 输入验证\n- 所有用户输入必须在服务端校验类型、长度、范围和格式\n- 使用白名单校验（允许的值），而非黑名单（禁止的值）\n- 文件上传校验：文件类型（MIME + 扩展名）、大小限制、文件内容扫描\n- URL 参数和请求体分别校验，不信任任何客户端数据\n- 使用校验库（zod / joi / class-validator）统一校验逻辑\n\n## 注入防护\n- **XSS**：输出到 HTML 时转义特殊字符，使用 CSP 策略（`Content-Security-Policy`）\n- **SQL 注入**：只使用参数化查询 / ORM，禁止字符串拼接 SQL\n- **命令注入**：禁止 `exec()` 拼接用户输入，使用 `execFile()` + 参数数组\n- **SSRF**：校验请求目标 URL，禁止访问内网地址（127.0.0.1 / 10.* / 172.16.*）\n- **路径遍历**：使用 `path.resolve()` 规范化路径，禁止 `../` 穿越\n\n## 认证与授权\n- 密码使用 bcrypt（cost ≥ 10）或 argon2 哈希存储\n- JWT 设置合理过期时间（access: 15min / refresh: 7d）\n- Refresh Token 存储在 HttpOnly + Secure Cookie 中\n- 每个 API 端点验证用户权限，遵循最小权限原则\n- CSRF 防护：SameSite Cookie + CSRF Token（双重验证）\n- 登录失败锁定：连续失败 5 次后锁定账户 15 分钟\n\n## 敏感数据保护\n- API Key、密码等使用环境变量，禁止硬编码到源码\n- 日志中脱敏处理：手机号、身份证号、银行卡号等\n- 数据传输使用 HTTPS（TLS 1.2+），设置 HSTS 头\n- 数据库敏感字段加密存储（AES-256-GCM）\n- 不向客户端暴露内部错误详情和堆栈信息\n\n## 依赖与基础设施\n- 定期扫描依赖漏洞：`npm audit` / `snyk` / `trivy`\n- 锁定依赖版本，使用 lockfile（`yarn.lock` / `package-lock.json`）\n- Docker 镜像使用最小基础镜像，非 root 用户运行\n- 设置安全响应头：`X-Content-Type-Options`、`X-Frame-Options`、`Referrer-Policy`",
-      "enabled": false,
-      "priority": 10,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.521Z",
-        "updatedAt": "2026-06-02T12:19:59.521Z",
-        "tags": [
-          "security",
-          "audit"
-        ]
-      }
-    },
-    {
-      "id": "38d43336-374b-422a-a3d1-e4cf5b949a41",
-      "name": "代码重构技巧",
-      "category": "skill",
-      "content": "## 何时重构\n- 添加新功能前：先整理相关代码，再添加功能\n- 修复 Bug 时：顺手改善周围代码质量\n- Code Review 中：发现的坏味道及时标记和修复\n- 性能优化前：先让代码结构清晰，再做性能调优\n\n## 代码坏味道识别\n- **过长函数**：超过 20 行考虑提取为独立函数\n- **重复代码**：相同逻辑出现 3 次以上必须抽取为公共函数\n- **过深嵌套**：使用卫语句（早返回）减少嵌套层级（≤ 3 层）\n- **魔法数字**：使用命名常量（`MAX_RETRY = 3`）提高可读性\n- **过大类/文件**：单文件超过 300 行考虑拆分职责\n- **过多参数**：函数参数超过 3 个时使用对象参数\n- **特征依恋**：方法频繁访问其他类的数据，考虑搬移到那个类\n- **数据泥团**：多个参数总是一起出现，抽取为数据类\n\n## 重构手法\n- **提取方法**：将代码块提取为有意义命名的函数\n- **内联变量**：只用一次的中间变量可以内联\n- **引入解释变量**：复杂表达式赋值给有含义的变量名\n- **以多态替代条件**：switch/if-else 链改为策略模式\n- **提取接口**：依赖具体类时，抽取接口实现依赖倒置\n- **移动方法/字段**：将方法移到更合适的类中\n- **封装集合**：不暴露可变集合，提供只读视图\n\n## 重构安全网\n- 重构前先确保有测试覆盖（至少关键路径）\n- 小步修改：每次只做一个重构操作\n- 每步验证：编译通过 + 测试通过后再继续\n- 及时提交：每个完整的重构步骤单独 commit\n- 使用 IDE 重构工具（重命名、提取方法等），避免手动修改",
-      "enabled": false,
-      "priority": 11,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.521Z",
-        "updatedAt": "2026-06-02T12:19:59.521Z",
-        "tags": [
-          "refactoring",
-          "clean-code"
-        ]
-      }
-    },
-    {
-      "id": "b50b1308-312d-4ed3-bfac-684ee7874fed",
-      "name": "数据库设计规范",
-      "category": "skill",
-      "content": "## 命名规范\n- 表名：snake_case 复数形式（如 `user_orders`）\n- 字段名：snake_case（如 `created_at`）\n- 外键字段：`<关联表单数>_id`（如 `user_id`）\n- 索引名：`idx_<表名>_<字段名>`（如 `idx_orders_user_id`）\n- 唯一约束：`uk_<表名>_<字段名>`\n\n## 表设计必备字段\n- `id`：主键，自增 BIGINT 或 UUID v7（时间有序）\n- `created_at`：创建时间，`TIMESTAMP DEFAULT CURRENT_TIMESTAMP`\n- `updated_at`：更新时间，`TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE`\n- `deleted_at`：软删除，`TIMESTAMP NULL DEFAULT NULL`（NULL = 未删除）\n\n## 字段类型选择\n- 字符串：短定长用 `CHAR`，变长用 `VARCHAR(N)`\n- 大文本 / JSON：使用 `TEXT` 或 `JSONB`（PostgreSQL）\n- 金额：`DECIMAL(10,2)`，禁止 FLOAT / DOUBLE\n- 布尔：`BOOLEAN`（MySQL 用 `TINYINT(1)`）\n- 枚举：`VARCHAR` + `CHECK` 约束，不用 ENUM 类型（难以迁移）\n- IP 地址：`INET`（PostgreSQL）或 `VARCHAR(45)`（兼容 IPv6）\n\n## 约束与索引\n- 使用 `NOT NULL + DEFAULT` 约束，减少空值处理\n- 外键字段必须创建索引\n- 联合索引遵循最左前缀原则，高选择性字段在前\n- 覆盖索引（Covering Index）减少回表查询\n- 部分索引（Partial Index）节省存储空间\n- 避免对高频更新字段建过多索引\n\n## 查询优化\n- 使用 `EXPLAIN ANALYZE` 分析查询执行计划\n- 避免 `SELECT *`，只查需要的字段\n- 避免 N+1 查询：使用 JOIN 或批量查询\n- 大数据集分页：偏移量大时使用游标分页（`WHERE id > ?`）\n- 统计查询使用物化视图或预计算表\n\n## 迁移管理\n- 使用版本化脚本（Flyway / Prisma Migrate / Liquibase）\n- 每次迁移包含 `up`（执行）和 `down`（回滚）\n- 大表 DDL 使用 `pt-online-schema-change` 或分批执行\n- 数据迁移与结构迁移分开执行",
-      "enabled": false,
-      "priority": 12,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.521Z",
-        "updatedAt": "2026-06-02T12:19:59.521Z",
-        "tags": [
-          "database",
-          "sql",
-          "design"
-        ]
-      }
-    },
-    {
-      "id": "f5428ec4-a9a2-40b6-9994-d1334d02f2f5",
-      "name": "Git 协作规范",
-      "category": "skill",
-      "content": "## 分支策略（Git Flow）\n\n```\nmain ─────────────────────────────── 生产环境（只接受 merge）\n  └── release/v1.2.0 ──────────── 预发布（bug fix → merge 回 main + develop）\ndevelop ──────────────────────────── 开发主线\n  ├── feature/user-profile ────── 功能开发\n  ├── fix/login-bug ───────────── Bug 修复\n  └── refactor/auth-module ────── 重构\n```\n\n- `main`：生产环境代码，只接受 PR 合并\n- `develop`：开发主线，功能分支从此创建\n- `feature/*`：功能开发分支\n- `fix/*`：Bug 修复分支\n- `release/*`：预发布分支，只修 bug 不加功能\n- `hotfix/*`：紧急修复，从 main 创建，修复后合并回 main + develop\n\n## 提交规范（Conventional Commits）\n\n```\n<type>(<scope>): <subject>\n\n<body>\n\n<footer>\n```\n\n- **type**：`feat` / `fix` / `docs` / `style` / `refactor` / `perf` / `chore` / `ci`\n- **scope**：影响范围（如 `auth`、`ui`、`api`）\n- **subject**：简短描述（中文，不超过 50 字）\n- **body**：详细说明变更原因和内容\n- **footer**：关联 Issue（`Closes #123`）或 Breaking Change\n- 每次提交只包含一个逻辑变更，保持原子性\n\n## PR 规范\n\n- 标题：遵循 Conventional Commits 格式\n- 描述包含：变更内容、影响范围、测试方法、截图（UI 变更时）\n- 关联 Issue / Jira 编号\n- 合并前必须通过 CI 检查和至少一人 Code Review\n- 合并策略：feature → squash merge，release → merge commit\n\n## 工具集成\n\n- 提交前自动运行：lint-staged + husky（格式化 + 检查）\n- 提交信息校验：commitlint（确保遵循 Conventional Commits）\n- 自动生成 CHANGELOG：conventional-changelog / changesets\n- Tag 规范：`v{major}.{minor}.{patch}`，遵循 SemVer",
-      "enabled": false,
-      "priority": 13,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.521Z",
-        "updatedAt": "2026-06-02T12:19:59.521Z",
-        "tags": [
-          "git",
-          "collaboration"
-        ]
-      }
-    },
-    {
-      "id": "6fb3e763-fce9-4dff-b868-7950cbd8ed49",
-      "name": "论文查重与去AI化",
-      "category": "skill",
-      "content": "## 查重系统原理\n\n### 主流查重工具\n| 工具 | 适用场景 | 检测粒度 |\n|------|----------|----------|\n| 知网（CNKI） | 学位论文（国内高校指定） | 连续 13 字重复即标红 |\n| 万方 | 期刊投稿、初稿自查 | 连续 15 字相似判定 |\n| 维普 | 期刊投稿 | 语义级相似检测 |\n| Turnitin | 英文论文、SCI 投稿 | 短语级匹配 |\n| PaperPass | 初稿快速自查（便宜） | 句子级对比 |\n\n### 检测机制\n- **字符串匹配**：连续 N 个字与数据库重合即判定重复\n- **语义分析**：即使换词换序，语义相同仍可能标红\n- **跨语言检测**：部分系统支持中英互译检测\n- **图表 OCR**：新一代系统可识别图片中的文字\n\n## 降重实战技巧\n\n### 第一层：句式变换\n- 主动句 ↔ 被动句：「本文提出了一种方法」→「一种新的方法被提出」\n- 长句拆分：将复合句拆为 2-3 个简单句\n- 短句合并：将相关的短句整合为一个复杂句\n- 正说反说：「提高了效率」→「减少了不必要的时间消耗」\n\n### 第二层：语义改写\n- 用自己的话重新表述核心观点（读懂→合上→写出）\n- 替换为领域内的同义表达（不是简单换近义词）\n- 将定义性描述转化为功能性描述\n- 补充自己的理解和分析作为过渡\n\n### 第三层：结构重组\n- 调整论述顺序（时间顺序 → 逻辑顺序 → 重要性顺序）\n- 将文字描述转化为图表、公式、流程图\n- 将表格数据转化为文字分析\n- 增加原创性内容的比例（实验数据、案例分析）\n\n### 禁忌操作\n- ❌ 逐字替换同义词（\"因此\"→\"所以\"→\"故而\"），系统能识别\n- ❌ 在字词间插入空格或特殊字符\n- ❌ 使用图片替代文字来规避检测\n- ❌ 翻译外文文献直接使用（跨语言检测已普及）\n\n## AI 生成检测与规避\n\n### AI 文本特征（检测系统关注点）\n- **困惑度（Perplexity）过低**：AI 生成文本用词精准但缺乏\"意外性\"\n- **突发性（Burstiness）过低**：句子长度和复杂度过于均匀\n- **词汇多样性不足**：同一含义反复使用相同表达\n- **结构高度规律**：段落长度、句式结构过于一致\n- **缺乏个人痕迹**：没有口误、修辞偏好、思维跳跃\n\n### 去 AI 化策略\n\n#### 增加人类写作特征\n- 段落长短错落：有的段 3 行，有的段 8 行\n- 句式多样：陈述句为主，穿插反问、设问、感叹\n- 适当使用非常规表达（但保持学术性）\n- 加入个人研究经历的真实描述\n- 引用具体数据、日期、地点等细节\n\n#### 增加学术深度\n- 对引用观点进行批判性分析（\"该研究虽然...但未考虑...\"）\n- 加入方法论的局限性讨论\n- 对比不同学者的观点并给出自己的判断\n- 使用领域专有术语和缩写（体现专业素养）\n- 引入具体案例佐证论点\n\n#### 文风自然化\n- 避免每段都以\"首先/其次/最后\"开头\n- 减少\"值得注意的是\"、\"不可忽视的是\"等 AI 套话\n- 不同章节使用不同的论述风格（叙述/论证/描述/说明）\n- 保持与自己之前作品一致的写作风格\n- 适当使用学术领域认可的口语化表达\n\n## 文献验证流程\n\n### 必须执行的验证步骤\n1. 在 Google Scholar / 知网 / Web of Science 中搜索文献标题\n2. 核对作者姓名（全名）、发表年份\n3. 核对期刊名称 / 出版社 / 会议名称\n4. 核对卷号、期号、页码（或 DOI）\n5. 确认该期刊/会议是正规学术出版物（非掠夺性期刊）\n\n### 引用质量要求\n- 优先引用高影响因子期刊和顶级会议论文\n- 近 5 年文献占比 ≥ 50%\n- 经典文献（>10 年）仅用于奠基性理论\n- 避免过度引用同一作者或同一课题组\n- 自引比例控制在 10% 以内",
-      "enabled": false,
-      "priority": 14,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.521Z",
-        "updatedAt": "2026-06-02T12:19:59.521Z",
-        "tags": [
-          "paper",
-          "plagiarism",
-          "deai",
-          "academic"
-        ]
-      }
-    },
-    {
-      "id": "4bad7cc5-ac94-496d-88df-7f57a0003613",
-      "name": "Git 提交工作流",
-      "category": "workflow",
-      "content": "## 提交前检查\n\n1. **查看变更**\n   - 运行 `git diff --staged` 审查即将提交的代码\n   - 确认没有遗留 `console.log` / `debugger` / `TODO` 调试代码\n   - 确认没有意外包含的文件（如 .env、node_modules）\n\n2. **代码质量**\n   - 运行 `yarn lint` 检查代码风格\n   - 运行 `yarn typecheck` 确认类型安全\n   - 运行 `yarn format` 格式化代码\n\n3. **测试**\n   - 运行相关单元测试确保通过\n   - 手动验证变更功能正常\n\n## 提交信息规范\n\n```\n<type>(<scope>): <subject>\n```\n\n- **type**：`feat`（功能）/ `fix`（修复）/ `docs`（文档）/ `refactor`（重构）/ `chore`（杂务）/ `perf`（性能）/ `ci`（CI）\n- **scope**：可选，影响模块名\n- **subject**：中文简述，不超过 50 字\n- 示例：`feat(auth): 添加手机号验证码登录`\n\n## 提交原则\n\n- 每次提交只包含**一个逻辑变更**\n- 提交后代码必须能编译通过\n- 大功能拆分为多个小 commit，每个可独立理解\n- 不要把格式化和逻辑变更混在同一个 commit\n\n## 分支与 PR\n\n- 分支命名：`feature/xxx`、`fix/xxx`、`refactor/xxx`\n- PR 合并前必须通过 CI 检查和至少一人 Code Review\n- PR 描述填写：变更内容、测试方法、相关 Issue",
-      "enabled": false,
-      "priority": 15,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.521Z",
-        "updatedAt": "2026-06-02T12:19:59.521Z",
-        "tags": [
-          "git",
-          "workflow",
-          "commit"
-        ]
-      }
-    },
-    {
-      "id": "95e940c1-2701-4da0-9b43-ab97f49719a8",
-      "name": "项目初始化工作流",
-      "category": "workflow",
-      "content": "## 1. 项目脚手架\n\n- 使用官方 CLI 创建项目（Vite / Create Next App / NestJS CLI 等）\n- 确认 Node.js 版本要求，添加 `.nvmrc` 或 `.node-version`\n- 选择包管理器并锁定（`.yarnrc.yml` 或 `packageManager` 字段）\n\n## 2. 目录结构\n\n```\nsrc/\n  components/   # UI 组件\n  composables/  # 可复用逻辑（Vue）/ hooks/（React）\n  services/     # API 调用和业务服务\n  stores/       # 状态管理\n  types/        # TypeScript 类型定义\n  utils/        # 工具函数\n  assets/       # 静态资源\n```\n\n## 3. 代码质量工具\n\n- **ESLint**：代码检查（`@typescript-eslint`）\n- **Prettier**：代码格式化（`.prettierrc`）\n- **EditorConfig**：编辑器统一配置（`.editorconfig`）\n- **husky + lint-staged**：Git 钩子自动检查\n- **commitlint**：提交信息规范校验\n\n## 4. TypeScript 配置\n\n- 启用严格模式：`\"strict\": true`\n- 路径别名：`\"@/*\": [\"./src/*\"]`\n- 目标版本对齐运行环境\n\n## 5. 环境与安全\n\n- 创建 `.env.example` 模板（不含真实密钥）\n- `.gitignore` 排除：`.env`、`node_modules/`、`dist/`、IDE 文件\n- 敏感信息使用环境变量，不硬编码\n\n## 6. 文档\n\n- **README.md**：项目介绍、技术栈、启动步骤、部署说明\n- **CONTRIBUTING.md**：贡献指南（分支策略、提交规范）\n- **CHANGELOG.md**：版本变更记录\n\n## 7. CI/CD\n\n- 配置 GitHub Actions / GitLab CI 基础流水线\n- 流水线步骤：安装依赖 → lint → typecheck → test → build\n- 配置缓存（node_modules / yarn cache）加速构建",
-      "enabled": false,
-      "priority": 16,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.521Z",
-        "updatedAt": "2026-06-02T12:19:59.521Z",
-        "tags": [
-          "workflow",
-          "init",
-          "setup"
-        ]
-      }
-    },
-    {
-      "id": "2adefa62-222f-451c-993d-6d0829409964",
-      "name": "发布部署工作流",
-      "category": "workflow",
-      "content": "## 1. 发布准备\n\n- 从 `develop` 创建 `release/vX.Y.Z` 分支\n- 更新版本号（`package.json` / `pubspec.yaml` 等）\n- 运行完整测试套件确保通过：`yarn test`\n- 运行 lint 和类型检查：`yarn lint && yarn typecheck`\n- 确认无未提交的变更：`git status`\n\n## 2. 变更日志\n\n- 生成 CHANGELOG：`yarn changelog` 或手动整理\n- 分类变更：新功能 / Bug 修复 / 破坏性变更 / 性能优化\n- 提交 CHANGELOG 和版本号变更\n\n## 3. 构建与测试\n\n- 构建生产包：`yarn build`\n- 验证构建产物大小（对比上次发布，排查异常增长）\n- 在 staging 环境部署并验证核心功能\n- 回归测试：确认已知功能不受影响\n\n## 4. 发布\n\n- 合并 `release/vX.Y.Z` → `main`（merge commit）\n- 创建 Git Tag：`git tag -a vX.Y.Z -m \"Release vX.Y.Z\"`\n- 推送 Tag：`git push origin vX.Y.Z`\n- 合并 `release/vX.Y.Z` → `develop`（同步变更）\n- 删除 release 分支\n\n## 5. 部署生产\n\n- 部署到生产环境（CI/CD 自动触发或手动确认）\n- 健康检查：确认服务正常启动\n- 冒烟测试：验证核心 API 和页面可访问\n- 监控：观察错误率、响应时间、CPU/内存 5-10 分钟\n\n## 6. 收尾\n\n- 通知团队发布完成（Slack / 飞书 / 邮件）\n- 更新项目管理工具中的版本状态\n- 如有问题立即执行回滚：`git revert` 或重新部署上一版本\n- 在 GitHub / GitLab 创建 Release，附带 CHANGELOG",
-      "enabled": false,
-      "priority": 17,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.522Z",
-        "updatedAt": "2026-06-02T12:19:59.522Z",
-        "tags": [
-          "workflow",
-          "deploy",
-          "release"
-        ]
-      }
-    },
-    {
-      "id": "e31896d1-8a03-42ac-8382-28ff9ea48080",
-      "name": "代码审查工作流",
-      "category": "workflow",
-      "content": "## 1. 准备阶段\n\n- 确认 PR 描述完整：变更内容、影响范围、测试方法、截图（UI 变更）\n- 关联 Issue / Jira 编号\n- 拉取分支到本地，确保能编译通过：`yarn && yarn build`\n- 了解变更背景和业务需求\n\n## 2. 结构审查\n\n- 检查文件组织是否合理，新文件放在正确的目录下\n- 是否有不属于本次变更的文件（格式化噪音、无关修改）\n- 新增依赖：是否必要？版本是否合适？是否有更轻量替代？\n- 新增依赖的 license 是否兼容项目\n\n## 3. 逻辑审查\n\n- 逐文件阅读变更，关注业务逻辑正确性\n- 检查边界条件：空值、空数组、超大数据、并发操作\n- 错误处理：异常是否捕获？错误信息是否有用？是否有空 catch？\n- 异步逻辑：是否有竞态条件？Promise 是否处理 rejection？\n- 数据流：状态变更是否一致？是否有内存泄漏？\n\n## 4. 质量审查\n\n- 命名规范：变量/函数/类是否语义清晰\n- 代码风格一致性：与项目现有代码保持统一\n- 重复代码：是否有可提取的公共逻辑\n- 函数长度 ≤ 50 行，嵌套 ≤ 3 层\n- 注释说明 why 而非 what，中文注释\n\n## 5. 安全审查\n\n- 用户输入是否在服务端校验\n- 敏感数据是否脱敏（日志、响应）\n- SQL 是否使用参数化查询\n- 文件操作是否防止路径遍历\n- 认证授权是否覆盖新增端点\n\n## 6. 测试审查\n\n- 关键逻辑是否有测试覆盖\n- 测试是否覆盖正常路径和异常路径\n- 测试是否独立，不依赖执行顺序\n\n## 7. 反馈\n\n- 问题分级：🔴 必须修复 / 🟡 建议改进 / 🟢 可选优化\n- 每条包含：位置 → 问题描述 → 修复建议（附代码示例）\n- 肯定好的代码：好的设计和实现也值得认可\n- 总结：必须修复 N 项 / 建议改进 N 项 / 可选 N 项",
-      "enabled": false,
-      "priority": 18,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.522Z",
-        "updatedAt": "2026-06-02T12:19:59.522Z",
-        "tags": [
-          "workflow",
-          "review",
-          "quality"
-        ]
-      }
-    },
-    {
-      "id": "264f66ab-bd87-41b1-9128-843b1f2ee1db",
-      "name": "Bug 修复工作流",
-      "category": "workflow",
-      "content": "## 1. 问题确认\n\n- 阅读 Issue / Bug 报告，理解预期行为和实际行为\n- 确认复现步骤，自己手动复现一遍\n- 记录环境信息：OS、浏览器/Node 版本、相关配置\n- 确认影响范围：影响哪些用户？频率如何？是否阻塞？\n- 评估优先级：P0（立即修复）/ P1（当天）/ P2（本周）\n\n## 2. 问题定位\n\n- 阅读错误日志和堆栈信息，定位出错文件和行号\n- 使用断点调试（IDE debugger / `--inspect`）缩小范围\n- 使用二分法排查：注释代码 / `git bisect` 找到引入 commit\n- 区分**根本原因**和**表面症状**，修复根因\n- 检查最近的变更记录：`git log --oneline -20`\n\n## 3. 修复实施\n\n- 从 `develop` 创建 `fix/<问题描述>` 分支\n- **最小化修改**：只改必要的代码，不顺手重构\n- 优先修上游原因，避免下游打补丁\n- 添加防御性代码防止同类问题复发\n- 添加中文注释说明修复原因（why）\n\n## 4. 验证测试\n\n- 确认原始 Bug 已修复（按复现步骤验证）\n- 回归测试：确认修复没有引入新问题\n- 边界条件测试：空值、大数据、并发场景\n- 如可行，添加针对该 Bug 的回归测试用例\n\n## 5. 提交与发布\n\n- 提交信息：`fix(<scope>): 描述修复内容 (Closes #issue编号)`\n- 创建 PR，描述：问题原因 → 修复方案 → 验证方法\n- 请求 Code Review\n- 合并后验证线上环境\n\n## 6. 收尾\n\n- 更新 Issue 状态为已修复\n- 通知 Bug 报告者验证\n- 更新相关文档或注释\n- 如果是常见问题，补充到 FAQ 或排查指南",
-      "enabled": false,
-      "priority": 19,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.522Z",
-        "updatedAt": "2026-06-02T12:19:59.522Z",
-        "tags": [
-          "workflow",
-          "bugfix",
-          "debug"
-        ]
-      }
-    },
-    {
-      "id": "dae8087b-c4d1-4c84-9b28-60f8f5ac917e",
-      "name": "功能开发工作流",
-      "category": "workflow",
-      "content": "## 1. 需求理解\n\n- 阅读需求文档 / Issue，确认验收标准（AC）\n- 梳理技术方案，评估复杂度（S/M/L/XL）和影响范围\n- 与产品/设计/后端对齐理解，确认无歧义\n- 识别依赖：是否需要其他团队配合？是否有技术前置条件？\n- 确认 UI 设计稿 / 接口文档是否就绪\n\n## 2. 技术设计\n\n- 确定数据结构和接口定义（前后端类型契约）\n- 拆分子任务，估算工时，更新项目管理工具\n- 考虑兼容性（向后兼容）和扩展性\n- 数据库变更：编写 migration 脚本\n- 评估风险点，准备降级 / 回滚方案\n\n## 3. 开发实施\n\n- 从 `develop` 创建 `feature/<功能描述>` 分支\n- 小步提交，每个 commit 可独立编译运行\n- 关键逻辑添加中文注释（说明 why）\n- 添加必要的日志（关键操作、错误路径）\n- 遵循项目代码规范和架构约定\n- 前端：组件拆分 → 数据联调 → 样式完善\n- 后端：接口定义 → 业务逻辑 → 数据层 → 联调\n\n## 4. 自测验证\n\n- 覆盖正常流程和异常流程\n- 边界值测试：空值、超长输入、大数据量\n- 兼容性测试：不同浏览器 / 设备 / 分辨率\n- 权限测试：不同角色是否正确限制\n- 性能验证：大数据量下是否卡顿\n- UI 对照设计稿逐项检查\n\n## 5. 提交审查\n\n- 提交信息：`feat(<scope>): 功能描述`\n- 创建 PR，描述：功能说明 → 实现方案 → 测试方法 → 截图\n- 关联 Issue / Jira 编号\n- 请求 Code Review（至少一人）\n- 根据 Review 意见修改，re-request review\n\n## 6. 合并上线\n\n- Review 通过后 squash merge 到 `develop`\n- 清理 feature 分支\n- 在 develop 环境验证功能完整性\n- 更新 Issue 状态，通知产品验收",
-      "enabled": false,
-      "priority": 20,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.522Z",
-        "updatedAt": "2026-06-02T12:19:59.522Z",
-        "tags": [
-          "workflow",
-          "feature",
-          "development"
-        ]
-      }
-    },
-    {
-      "id": "b9006d07-2193-407e-bddd-8c5910d054f7",
-      "name": "Vue 3 编码规范",
-      "category": "rule",
-      "content": "## 组件规范\n- 必须使用 Composition API + `<script setup>` 语法\n- 组件命名使用 PascalCase（如 `UserProfile.vue`）\n- 单文件组件顺序：`<script setup>` → `<template>` → `<style scoped>`\n- 单个组件文件不超过 200 行，超过则拆分子组件\n- 组件目录结构：`ComponentName/index.vue` + `ComponentName/types.ts`\n\n## Props 与事件\n- Props 必须使用 `defineProps<T>()` 定义 TypeScript 类型\n- 使用 `withDefaults()` 为 Props 设置默认值\n- 事件使用 `defineEmits<{ (e: 'update', value: string): void }>()` 定义\n- Props 命名使用 camelCase，模板中自动转为 kebab-case\n- 避免修改 Props，使用 `emit` 通知父组件变更\n\n## 响应式\n- 优先使用 `ref()` 而非 `reactive()`（避免解构丢失响应性）\n- `computed` 用于派生状态，不要在 `computed` 中产生副作用\n- `watch` 指定具体的响应式源，避免 `watch(() => state)` 监听整个对象\n- 使用 `watchEffect` 处理副作用自动追踪依赖\n- 大型列表使用 `shallowRef` 减少响应式开销\n\n## 模板规范\n- 模板中不要有复杂逻辑，抽取为 `computed` 或方法\n- 列表渲染必须提供唯一 `key`，禁止使用 index\n- 条件渲染优先 `v-if`，频繁切换使用 `v-show`\n- 事件处理器使用 `@click=\"handleClick\"`，不在模板中写逻辑\n\n## 可复用逻辑\n- 可复用逻辑抽取为 composables（`use*.ts`）\n- composable 返回值使用 `ref` 而非 `reactive`\n- composable 内部清理副作用使用 `onUnmounted`\n\n## 样式\n- 使用 `<style scoped>` 或 CSS Modules 避免样式污染\n- 优先使用 Tailwind CSS 原子类，减少自定义 CSS\n- 主题变量使用 CSS 自定义属性（`var(--color-primary)`）",
-      "enabled": false,
-      "priority": 21,
-      "condition": {
-        "filePattern": "**/*.vue"
-      },
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.522Z",
-        "updatedAt": "2026-06-02T12:19:59.522Z",
-        "tags": [
-          "vue",
-          "frontend"
-        ]
-      }
-    },
-    {
-      "id": "28b6216b-4e12-44a6-bdf8-62ef32e580dc",
-      "name": "TypeScript 严格模式",
-      "category": "rule",
-      "content": "## 类型安全\n- 禁止使用 `any`，使用 `unknown` 替代不确定类型\n- 所有函数必须声明参数类型和返回类型\n- 使用 `interface` 定义对象结构，`type` 用于联合类型和工具类型\n- 泛型参数使用有意义的名称（如 `TData`、`TResponse`）\n- 使用 `as const` 断言确保字面量类型推断\n- 避免类型断言 `as`，优先使用类型守卫（type guard）\n\n## 语法规范\n- 使用可选链 `?.` 和空值合并 `??` 替代 `&&` 和 `||`\n- 优先使用 `const enum` 或字面量联合类型替代普通 enum\n- 使用 `readonly` 标记不应被修改的属性和数组\n- 解构赋值时添加默认值：`const { name = '默认' } = options`\n- 异步函数统一使用 `async/await`，禁止 `.then()` 链\n\n## 错误处理\n- 使用自定义错误类继承 `Error`，携带 `code` 字段\n- try/catch 中指定具体错误类型，禁止空 catch\n- Promise 必须处理 rejection（`.catch()` 或 try/catch）\n\n## 命名约定\n- 变量/函数：`camelCase`\n- 类/接口/类型：`PascalCase`\n- 常量：`UPPER_SNAKE_CASE`\n- 私有属性：前缀 `_`（如 `_internalState`）\n- 布尔变量：`is/has/should` 前缀（如 `isLoading`）",
-      "enabled": false,
-      "priority": 22,
-      "condition": {
-        "filePattern": "**/*.ts"
-      },
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.522Z",
-        "updatedAt": "2026-06-02T12:19:59.522Z",
-        "tags": [
-          "typescript"
-        ]
-      }
-    },
-    {
-      "id": "aa47f7ec-f032-47bd-9481-35989dda8961",
-      "name": "Flutter 开发规范",
-      "category": "rule",
-      "content": "## Widget 规范\n- 使用 StatelessWidget 优先，仅在需要内部可变状态时用 StatefulWidget\n- Widget 拆分遵循单一职责，避免超过 100 行的 `build` 方法\n- 使用 `const` 构造函数减少不必要的重建\n- Widget 命名使用 PascalCase，文件名使用 snake_case\n- 将大型 Widget 拆分为私有方法或独立 Widget 类\n\n## 状态管理\n- 优先级：Riverpod > BLoC > Provider > setState\n- 局部状态使用 `ValueNotifier` + `ValueListenableBuilder`\n- 全局/跨页面状态使用 Riverpod 的 `StateNotifierProvider`\n- 异步数据使用 `FutureProvider` / `StreamProvider`\n- 状态类使用 `freezed` 或 `equatable` 实现不可变和相等比较\n\n## 主题与资源\n- 颜色、字体、间距统一在 `ThemeData` 中定义\n- 使用 `Theme.of(context)` 获取主题值，不硬编码颜色\n- 支持亮色/暗色模式切换\n- 文字使用 `TextTheme` 样式，不直接设置 fontSize\n- 间距使用统一常量（如 `Spacing.sm = 8.0`）\n\n## 异步与网络\n- 异步操作使用 `async/await`，避免嵌套 `.then()`\n- 网络请求使用 Dio + 拦截器（日志、认证、错误处理）\n- 图片使用 `cached_network_image`，配置占位图和错误图\n- 接口返回统一解析为 `Result<T>` 类型（Success / Failure）\n\n## 路由与导航\n- 路由统一使用 GoRouter 或 auto_route 管理\n- 路由参数使用强类型，避免字符串传参\n- 深层链接（Deep Link）支持\n\n## 性能优化\n- 禁止在 `build` 方法内做耗时运算或 I/O\n- 长列表使用 `ListView.builder` / `SliverList`，避免一次性构建\n- 使用 `RepaintBoundary` 隔离频繁重绘的区域\n- 动画使用 `AnimatedWidget` / `AnimatedBuilder`，避免全局重建",
-      "enabled": false,
-      "priority": 23,
-      "condition": {
-        "filePattern": "**/*.dart"
-      },
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.523Z",
-        "updatedAt": "2026-06-02T12:19:59.523Z",
-        "tags": [
-          "flutter",
-          "dart",
-          "mobile"
-        ]
-      }
-    },
-    {
-      "id": "8c4caa1f-2cb2-42be-85df-51f041170ff7",
-      "name": "C# 编码规范",
-      "category": "rule",
-      "content": "## 命名规范\n- 类/接口/方法/属性：PascalCase\n- 局部变量/参数：camelCase\n- 常量/静态只读：UPPER_SNAKE_CASE 或 PascalCase\n- 接口前缀 `I`（如 `IUserService`）\n- 异步方法后缀 `Async`（如 `GetUserAsync`）\n- 布尔属性/变量：`Is/Has/Can` 前缀\n\n## 类型与数据\n- 优先使用 `record` 定义不可变数据对象（DTO / Value Object）\n- 使用 nullable 引用类型（`#nullable enable`），公共 API 参数需 null 检查\n- 值类型使用 `struct`，引用类型使用 `class`\n- 集合返回 `IReadOnlyList<T>` / `IReadOnlyCollection<T>`，避免暴露可变集合\n- 使用 `required` 关键字标记必填属性（C# 11+）\n\n## 异步与资源\n- 异步方法返回 `Task` / `Task<T>` / `ValueTask<T>`\n- 使用 `using` 声明（非语句块）管理资源\n- 传递 `CancellationToken` 到所有异步链路\n- 避免 `async void`，仅用于事件处理器\n- I/O 密集操作使用 `ConfigureAwait(false)`（类库中）\n\n## 依赖注入\n- 优先构造函数注入，避免服务定位器模式\n- 注册生命周期：Transient（无状态）/ Scoped（请求级）/ Singleton（全局）\n- 使用 `IOptions<T>` 注入配置对象\n\n## LINQ 与集合\n- LINQ 查询优先方法链形式，避免嵌套查询表达式\n- 大数据集使用 `AsNoTracking()` 提升 EF Core 查询性能\n- 使用 `Any()` 替代 `Count() > 0` 判断非空\n\n## 异常处理\n- 只 catch 能处理的异常，记录日志后重新抛出（`throw;` 保留堆栈）\n- 使用 `ExceptionFilter` / 中间件统一处理 API 异常\n- 自定义异常继承 `Exception`，携带错误码\n\n## 测试\n- 单元测试使用 xUnit + Moq / NSubstitute\n- 集成测试使用 `WebApplicationFactory<T>`\n- 遵循 Arrange-Act-Assert 模式",
-      "enabled": false,
-      "priority": 24,
-      "condition": {
-        "filePattern": "**/*.cs"
-      },
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.523Z",
-        "updatedAt": "2026-06-02T12:19:59.523Z",
-        "tags": [
-          "csharp",
-          "dotnet",
-          "backend"
-        ]
-      }
-    },
-    {
-      "id": "01d64bf0-f272-4950-a0af-99c126245e20",
-      "name": "Java 编码规范",
-      "category": "rule",
-      "content": "## 命名规范\n- 类/接口：PascalCase（如 `UserService`）\n- 方法/变量：camelCase（如 `getUserById`）\n- 常量：UPPER_SNAKE_CASE（如 `MAX_RETRY_COUNT`）\n- 包名：全小写，反向域名（如 `com.example.user`）\n- 布尔方法：`is/has/can` 前缀（如 `isValid()`）\n\n## 现代 Java 特性（17+）\n- 使用 `record` 定义不可变数据对象（DTO）\n- 使用 `sealed class` 限制继承层级\n- 使用 `pattern matching`（`instanceof` + 类型绑定）\n- 使用 `text blocks`（三引号）书写多行字符串\n- Switch 表达式使用箭头语法 + yield\n\n## 集合与 Stream\n- Stream API 用于集合操作，避免传统 for 循环处理集合\n- 使用 `Optional<T>` 替代 null 返回值，禁止 `Optional` 作为方法参数\n- 不可变集合：`List.of()` / `Map.of()` / `Set.of()`\n- 避免在 Stream 中产生副作用（如修改外部变量）\n\n## Spring Boot 架构\n- Controller 只处理 HTTP 映射和参数校验（`@Valid`）\n- 业务逻辑下沉到 Service 层\n- 数据访问使用 JPA Repository 或 MyBatis Mapper，禁止 SQL 拼接\n- 使用 `@Transactional` 管理事务，注意传播行为和回滚规则\n- 配置使用 `@ConfigurationProperties` 绑定，不硬编码\n\n## 异常与日志\n- 异常统一使用 `@ControllerAdvice` + `@ExceptionHandler` 处理\n- 返回标准 `ApiResponse<T>` 格式（code + message + data）\n- 日志使用 SLF4J + Logback，禁止 `System.out.println`\n- 日志级别：ERROR（系统错误）/ WARN（业务异常）/ INFO（关键操作）/ DEBUG（调试）\n- 日志包含上下文信息：用户 ID、请求 ID、耗时\n\n## 测试\n- 单元测试：JUnit 5 + Mockito，覆盖率 > 80%\n- 集成测试：`@SpringBootTest` + `@TestContainers`\n- API 测试：`MockMvc` 或 RestAssured",
-      "enabled": false,
-      "priority": 25,
-      "condition": {
-        "filePattern": "**/*.java"
-      },
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.523Z",
-        "updatedAt": "2026-06-02T12:19:59.523Z",
-        "tags": [
-          "java",
-          "backend",
-          "spring"
-        ]
-      }
-    },
-    {
-      "id": "71d75d65-5c11-4d17-b5fe-22aac0b5d3c5",
-      "name": "React 编码规范",
-      "category": "rule",
-      "content": "## 组件规范\n- 函数组件 + Hooks，禁止使用 Class 组件\n- 组件命名 PascalCase，文件名与组件名一致（如 `UserCard.tsx`）\n- Props 使用 TypeScript `interface` 定义，必须标注类型\n- 使用 `React.FC<Props>` 或直接函数签名声明组件\n- 单个组件文件不超过 200 行，超过则拆分\n\n## 状态管理\n- 局部状态：`useState`\n- 计算状态：`useMemo`\n- 跨组件共享：Context + `useContext` 或 Zustand / Jotai\n- 服务端数据：TanStack Query（React Query）管理请求缓存\n- 避免 prop drilling 超过 3 层，使用 Context 或状态库\n\n## Hooks 规范\n- 自定义 Hook 以 `use` 开头，封装可复用逻辑\n- `useEffect` 依赖数组必须完整，配合 ESLint exhaustive-deps 规则\n- `useCallback` 包裹传给子组件的回调函数\n- `useMemo` 缓存昂贵计算，但不要滥用（简单计算无需缓存）\n- cleanup 函数处理订阅、定时器、AbortController\n\n## 渲染优化\n- 使用 `React.memo()` 避免不必要的子组件重渲染\n- 列表渲染必须提供稳定的 key（业务 ID），禁止使用 index\n- 条件渲染优先使用 `&&` 或三元表达式，避免嵌套 if\n- 大列表使用虚拟滚动（`@tanstack/react-virtual`）\n- 代码分割：`React.lazy()` + `Suspense` 懒加载路由和大组件\n\n## 样式\n- 样式方案：Tailwind CSS 或 CSS Modules，避免内联样式\n- 使用 `clsx` / `cn()` 工具合并条件类名\n- 响应式设计使用 Tailwind 断点前缀（`md:`、`lg:`）\n\n## 错误处理\n- 使用 `ErrorBoundary` 捕获渲染错误，提供 fallback UI\n- 异步操作统一 try/catch，用户友好的错误提示",
-      "enabled": false,
-      "priority": 26,
-      "condition": {
-        "filePattern": "**/*.tsx"
-      },
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.523Z",
-        "updatedAt": "2026-06-02T12:19:59.523Z",
-        "tags": [
-          "react",
-          "frontend"
-        ]
-      }
-    },
-    {
-      "id": "085dc4f6-e5e0-42cb-9e0f-e4ef6f06d290",
-      "name": "Python 编码规范",
-      "category": "rule",
-      "content": "## 代码风格\n- 遵循 PEP 8 风格指南，使用 `black` + `isort` 格式化\n- 类名 PascalCase，函数/变量 snake_case，常量 UPPER_SNAKE_CASE\n- 模块级常量定义在文件顶部（导入之后）\n- 单行不超过 88 字符（black 默认）\n- 使用 `ruff` 作为 linter（替代 flake8 + pylint）\n\n## 类型标注\n- 使用 Type Hints 标注所有函数参数和返回值\n- 复杂类型使用 `typing` 模块（`Optional`、`Union`、`TypeAlias`）\n- Python 3.10+ 使用 `X | Y` 语法替代 `Union[X, Y]`\n- 使用 `mypy --strict` 进行静态类型检查\n- 泛型类使用 `TypeVar` 或 `Generic[T]`\n\n## 数据模型\n- 使用 `dataclass`（内部数据）或 `Pydantic BaseModel`（API 数据校验）\n- Pydantic 模型使用 `Field()` 添加校验规则和描述\n- 不可变数据使用 `frozen=True` 的 dataclass\n\n## 异步与并发\n- I/O 密集操作使用 `asyncio` + `async/await`\n- CPU 密集操作使用 `concurrent.futures.ProcessPoolExecutor`\n- 异步 HTTP 使用 `httpx` / `aiohttp`\n- 异步数据库使用 `SQLAlchemy 2.0` async 模式\n\n## 错误处理与资源\n- 使用 `with` 语句管理文件、连接等资源\n- 异常处理指定具体异常类型，禁止 bare `except:`\n- 自定义异常继承 `Exception`，携带错误码\n- 使用 `logging` 模块记录日志，禁止 `print()` 调试\n\n## 项目管理\n- 使用 `pyproject.toml` 管理项目配置和依赖\n- 虚拟环境：`venv` / `poetry` / `uv`\n- 依赖锁定：`poetry.lock` / `requirements.txt` 固定版本\n- 使用 `pytest` 编写测试，`pytest-cov` 检查覆盖率 > 80%\n- 使用 `pre-commit` 钩子自动检查代码质量",
-      "enabled": false,
-      "priority": 27,
-      "condition": {
-        "filePattern": "**/*.py"
-      },
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.523Z",
-        "updatedAt": "2026-06-02T12:19:59.523Z",
-        "tags": [
-          "python",
-          "backend"
-        ]
-      }
-    },
-    {
-      "id": "9436562b-32d3-4643-94b2-6ef1b9707451",
-      "name": "Go 编码规范",
-      "category": "rule",
-      "content": "## 命名规范\n- 包名小写单词，不使用下划线或混合大小写\n- 导出标识符 PascalCase，内部标识符 camelCase\n- 接口命名：单方法接口用 `-er` 后缀（如 `Reader`、`Writer`）\n- 文件名 snake_case（如 `user_service.go`）\n- 测试文件 `*_test.go`，与被测文件同目录\n\n## 错误处理\n- 每个 `error` 必须检查，禁止 `_ = err` 忽略\n- 使用 `errors.Is()` / `errors.As()` 替代 `==` 比较错误\n- 使用 `fmt.Errorf(\"描述: %w\", err)` 包装错误（保留链路）\n- 自定义错误类型实现 `Error()` 接口\n- 在函数签名中，error 永远是最后一个返回值\n- 使用 sentinel error（包级变量）定义可预期的错误\n\n## 并发与 goroutine\n- goroutine 必须有退出机制，使用 `context.Context` 控制生命周期\n- channel 使用完毕必须 `close`，避免 goroutine 泄漏\n- 使用 `sync.WaitGroup` 等待一组 goroutine 完成\n- 使用 `sync.Mutex` / `sync.RWMutex` 保护共享数据\n- 优先使用 channel 通信，而非共享内存\n- 使用 `errgroup.Group` 管理一组可能出错的 goroutine\n\n## 接口设计\n- 接口小而精：通常 1-3 个方法，由使用方定义\n- 接受接口，返回结构体（依赖倒置）\n- 使用组合（embedding）而非继承\n\n## 资源管理\n- 使用 `defer` 确保资源释放（文件、锁、连接）\n- `defer` 按 LIFO 顺序执行，注意多个 defer 的顺序\n- HTTP Response Body 必须 `defer resp.Body.Close()`\n\n## 项目结构\n- 遵循 Standard Go Project Layout\n- `cmd/`（入口）、`internal/`（私有）、`pkg/`（公共库）\n- 结构体字段使用 `json` tag 标注序列化名称\n- 配置使用 `viper` 或环境变量，不硬编码\n\n## 工具链\n- 使用 `go vet` + `golangci-lint` 进行静态分析\n- 使用 `go test -race` 检测数据竞争\n- 使用 `pprof` 进行性能分析\n- 使用 `go mod tidy` 清理无用依赖",
-      "enabled": false,
-      "priority": 28,
-      "condition": {
-        "filePattern": "**/*.go"
-      },
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.524Z",
-        "updatedAt": "2026-06-02T12:19:59.524Z",
-        "tags": [
-          "golang",
-          "backend"
-        ]
-      }
-    },
-    {
-      "id": "53bad5ac-4a1e-4d83-8089-27a30bece93e",
-      "name": "输出语言为中文",
-      "category": "rule",
-      "content": "## 语言要求\n\n<language_rules>\n- **全程使用中文**回答所有问题，包括思考过程、解释说明、代码注释\n- 变量名、函数名、类名等**标识符保持英文**（遵循编程命名规范）\n- 代码注释必须使用中文书写\n- Git 提交信息使用中文描述\n- 文档和 README 使用中文编写\n- 错误提示和用户提示信息使用中文\n</language_rules>\n\n## 格式规范\n\n<format_rules>\n- 中英文之间添加空格（如：使用 Vue 3 框架）\n- 数字与中文之间添加空格（如：共 3 个文件）\n- 专业术语首次出现时标注英文原文（如：组合式 API (Composition API)）\n- 代码块中的输出示例使用中文\n- 表格、列表等结构化内容使用中文标题\n</format_rules>\n\n## 禁止行为\n\n- ❌ 禁止使用英文回答问题\n- ❌ 禁止在注释中混用英文（专业术语除外）\n- ❌ 禁止在解释说明中突然切换为英文",
-      "enabled": false,
-      "priority": 29,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.524Z",
-        "updatedAt": "2026-06-02T12:19:59.524Z",
-        "tags": [
-          "language",
-          "chinese",
-          "i18n"
-        ]
-      }
-    },
-    {
-      "id": "ba37de52-c870-4064-b5c6-89f6253c39db",
-      "name": "学术论文写作规范",
-      "category": "rule",
-      "content": "## 格式要求\n\n### 论文结构\n- 标题 → 摘要 → 关键词 → 引言 → 文献综述 → 研究方法 → 结果分析 → 讨论 → 结论 → 参考文献 → 附录\n- 每个章节之间逻辑衔接自然，使用过渡句连接上下文\n- 摘要 300-500 字，包含研究目的、方法、主要发现和结论\n- 关键词 3-5 个，涵盖研究核心概念\n\n### 排版规范\n- 正文：宋体/Times New Roman，小四号（12pt），1.5 倍行距\n- 标题层级：一级标题黑体三号 → 二级标题黑体四号 → 三级标题黑体小四号\n- 段落首行缩进 2 字符，段前段后 0.5 行\n- 页边距：上 2.54cm / 下 2.54cm / 左 3.17cm / 右 3.17cm\n- 页码从正文开始，居中显示\n- 图表统一编号（如图 1、表 2），标题居中，图标题在下、表标题在上\n- 公式居中，编号右对齐\n\n## 查重规范\n\n### 重复率要求\n- 本科毕业论文：总重复率 ≤ 30%（部分院校要求 ≤ 20%）\n- 硕士学位论文：总重复率 ≤ 15%\n- 博士学位论文：总重复率 ≤ 10%\n- 期刊投稿：总重复率 ≤ 15%（核心期刊 ≤ 10%）\n\n### 降重技巧\n- **语序调整**：主动句与被动句互换，调整句子成分顺序\n- **同义替换**：使用同义词、近义词替换，但不改变原意\n- **概括改写**：将具体描述概括为抽象表述，用自己的话重新组织\n- **拆分合并**：长句拆为短句，或将短句合并为复合句\n- **增加论述**：在引用观点后加入自己的分析、评价和延伸\n- ❌ 禁止简单替换个别字词（如\"因此\"→\"所以\"），查重系统能识别\n- ❌ 禁止使用翻译法（中→英→中），表述生硬且可能曲解原意\n\n## 去 AI 化规范\n\n### 必须遵守\n- ❌ 禁止出现典型 AI 生成痕迹：\n  - \"首先...其次...最后...\"的机械排列\n  - \"值得注意的是\"、\"需要指出的是\"等套话高频出现\n  - \"综上所述\"在非结论部分反复使用\n  - 每段开头都用\"在...方面\"、\"从...角度\"的模板句式\n  - 过度使用\"本文\"、\"本研究\"作为主语\n- ✅ 使用自然、多样的表达方式：\n  - 变换句式结构：陈述句、反问句、设问句交替使用\n  - 融入个人研究视角和独立思考\n  - 使用领域专业术语，体现学科素养\n  - 段落长短错落有致，避免每段字数雷同\n  - 适当使用口语化学术表达（如\"不难发现\"、\"换言之\"）\n\n### AI 检测规避\n- 保持个人写作风格一致性（用词习惯、句式偏好）\n- 加入具体案例、数据、图表等实证内容（AI 难以伪造）\n- 融入对研究过程的真实描述（实验细节、调研经历）\n- 对他人观点进行批判性分析，而非简单罗列\n- 论文不同部分的文风应与内容匹配（引言偏叙述、方法偏客观、讨论偏思辨）\n\n## 文献引用规范\n\n### 文献真实性（最高优先级）\n- ⚠️ **所有引用的文献必须真实存在，可通过学术数据库检索到**\n- 引用前必须验证：作者、标题、期刊/出版社、年份、卷期页码均准确\n- 推荐验证渠道：Google Scholar、知网（CNKI）、万方、Web of Science、Scopus\n- ❌ 严禁编造虚假文献（捏造作者、杜撰期刊、伪造年份）\n- ❌ 严禁引用未读过的文献（二手引用需标注\"转引自\"）\n- 如无法找到原始文献，宁可删除引用也不要凭记忆补全信息\n\n### 引用格式\n- 中文论文：GB/T 7714 格式（如：[1] 张三. 标题[J]. 期刊名, 2024, 1(2): 10-20.）\n- 英文论文：APA 7th / IEEE / MLA 格式（根据目标期刊要求选择）\n- 正文引用与参考文献列表一一对应，不多不少\n- 引用数量建议：本科 15-30 篇，硕士 40-80 篇，博士 80-150 篇\n- 近 5 年文献占比 ≥ 50%，体现研究前沿性\n- 中英文文献比例合理（理工科英文 ≥ 60%）\n\n## 上下文连贯性\n\n### 全文一致性\n- 研究问题、方法、结果、结论之间逻辑链条完整\n- 摘要中的结论必须与正文结论一致\n- 引言提出的问题必须在结论中回应\n- 文献综述的内容必须与研究方法选择相关\n- 术语全文统一：同一概念不要交替使用不同名称\n\n### 段落衔接\n- 每段有明确的主题句（通常在段首）\n- 段与段之间使用过渡句或过渡词连接\n- 常用过渡逻辑：因果（因此）、转折（然而）、递进（此外）、对比（相比之下）\n- 避免突然跳转话题，新观点需有铺垫\n- 每章末尾可加小结，呼应章首并过渡到下一章\n\n### 语言风格一致\n- 全文保持同一人称视角（推荐第三人称或\"本文\"）\n- 时态一致：文献综述用过去时，研究方法用过去时，结论用现在时\n- 学术语体一致：不在严谨论述中突然出现口语化表达\n- 专业术语首次出现时给出定义或英文原文",
-      "enabled": false,
-      "priority": 30,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.524Z",
-        "updatedAt": "2026-06-02T12:19:59.524Z",
-        "tags": [
-          "paper",
-          "academic",
-          "writing"
-        ]
-      }
-    },
-    {
-      "id": "37bc6709-803d-40d4-b34b-fe999abe9435",
-      "name": "代码审查规范",
-      "category": "context",
-      "content": "## 代码结构\n- 函数长度不超过 50 行，文件不超过 300 行\n- 嵌套不超过 3 层，使用早返回（guard clause）减少嵌套\n- 单一职责：每个函数/类只做一件事\n- 避免上帝类（God Class）和上帝函数\n\n## 命名规范\n- 变量/函数：camelCase（如 `getUserById`）\n- 类/接口/类型：PascalCase（如 `UserService`）\n- 常量：UPPER_SNAKE_CASE（如 `MAX_RETRY_COUNT`）\n- 布尔变量：`is/has/should/can` 前缀\n- 命名必须语义清晰，禁止单字母变量（循环计数器除外）\n\n## 代码质量\n- 避免魔法数字，使用命名常量\n- 不要吞掉异常（空 catch），至少记录日志\n- 不要注释掉代码，直接删除（Git 有历史记录）\n- 注释说明 why 而非 what，使用中文注释\n- 删除未使用的导入、变量和代码（dead code）\n\n## 错误处理\n- 异常必须处理：捕获后记录日志或向上抛出\n- 使用自定义错误类型，携带错误码\n- 异步操作必须有超时和错误处理\n- 用户可见的错误信息使用中文，友好且有指导性\n\n## 安全检查\n- 用户输入必须校验（类型、长度、范围、格式）\n- SQL 使用参数化查询，禁止拼接\n- 敏感数据不在日志中输出",
-      "enabled": false,
-      "priority": 31,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.524Z",
-        "updatedAt": "2026-06-02T12:19:59.524Z",
-        "tags": [
-          "review",
-          "quality"
-        ]
-      }
-    },
-    {
-      "id": "b4f2b2c5-5796-4bd3-b4a4-9559eb2da777",
-      "name": "项目概述上下文",
-      "category": "context",
-      "content": "## 项目信息\n- **项目名称**：[填写项目名称]\n- **项目类型**：[Web 应用 / 桌面应用 / 移动应用 / 后端服务 / CLI 工具 / 浏览器扩展]\n- **主要语言**：[TypeScript / Python / Java / Go / C# / Dart / Rust]\n- **框架**：[Vue 3 / React / NestJS / Spring Boot / Flutter / Electron]\n- **包管理器**：[yarn / pnpm / npm / pip / gradle / cargo]\n- **Node.js 版本**：[18 LTS / 20 LTS / 22]\n\n## 目录结构\n```\nsrc/\n  components/    # UI 组件\n  composables/   # 可复用逻辑（Vue）/ hooks/（React）\n  services/      # API 调用和业务服务\n  stores/        # 状态管理（Pinia / Zustand）\n  types/         # TypeScript 类型定义\n  utils/         # 工具函数\n  assets/        # 静态资源（图片、字体、样式）\n  router/        # 路由配置\n  i18n/          # 国际化文件\npublic/          # 公共静态文件\n```\n\n## 开发约定\n- **代码风格**：ESLint + Prettier，提交前自动格式化\n- **分支策略**：Git Flow（main / develop / feature / fix / release）\n- **提交规范**：Conventional Commits（feat / fix / docs / refactor）\n- **部署方式**：[Docker / Vercel / Nginx / PM2]\n- **CI/CD**：[GitHub Actions / GitLab CI / Jenkins]\n\n## 关键依赖\n| 依赖 | 版本 | 用途 |\n|------|------|------|\n| [框架名] | ^x.y.z | [用途] |\n| [UI 库] | ^x.y.z | [用途] |\n| [状态管理] | ^x.y.z | [用途] |\n\n## 环境变量\n| 变量名 | 说明 | 示例 |\n|--------|------|------|\n| `VITE_API_URL` | API 地址 | `http://localhost:3000` |\n| `DATABASE_URL` | 数据库连接 | `postgresql://...` |\n\n## 注意事项\n- [填写项目特殊约定、已知限制、技术债务等]",
-      "enabled": false,
-      "priority": 32,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.525Z",
-        "updatedAt": "2026-06-02T12:19:59.525Z",
-        "tags": [
-          "context",
-          "project",
-          "overview"
-        ]
-      }
-    },
-    {
-      "id": "7858a396-3f31-4a56-9cd6-192684980339",
-      "name": "调试排错上下文",
-      "category": "context",
-      "content": "## 调试原则\n- 先复现问题，记录复现步骤和环境信息\n- 从错误日志和堆栈信息入手，定位出错位置\n- 使用二分法缩小问题范围（注释代码 / `git bisect`）\n- 区分根本原因和表面症状，修复根因\n- 一次只改一个变量，验证后再改下一个\n- 不要猜测，用数据和日志证明假设\n\n## 常见问题排查清单\n\n### 编译 / 构建错误\n- 类型定义缺失或不匹配\n- 导入路径错误（相对路径 / 别名配置）\n- 依赖版本冲突（`yarn why <package>`）\n- tsconfig 配置问题（`moduleResolution`、`paths`）\n\n### 运行时错误\n- 空值访问：`TypeError: Cannot read property of undefined`\n- 异步时序：Promise 未 await、竞态条件\n- 数组越界 / 对象属性不存在\n- 循环引用导致栈溢出\n- 类型不匹配：字符串 vs 数字、JSON 解析失败\n\n### 样式问题\n- 选择器优先级：Specificity 计算、`!important` 覆盖\n- z-index 层级混乱：建立统一的 z-index 层级体系\n- Flex / Grid 布局：`flex-shrink`、`overflow`、`min-width: 0`\n- 响应式断点：移动端 viewport、媒体查询顺序\n\n### 性能问题\n- 前端：N 次不必要的重渲染（React DevTools Profiler）\n- 后端：N+1 查询（ORM 日志）、慢查询（`EXPLAIN ANALYZE`）\n- 内存泄漏：事件监听未清理、闭包引用大对象\n- 网络：请求瀑布流、缺少缓存策略\n\n### 网络问题\n- CORS：`Access-Control-Allow-Origin` 配置\n- 请求格式：`Content-Type` 不匹配\n- 认证：Token 过期 / 缺失、Cookie SameSite 策略\n- 超时：设置合理的 timeout 值、重试机制\n\n## 调试工具\n\n| 场景 | 工具 | 用途 |\n|------|------|------|\n| 前端 | Chrome DevTools | Network / Console / Performance / Memory |\n| 前端 | React / Vue DevTools | 组件树、状态、渲染次数 |\n| Node.js | `--inspect` | 断点调试（配合 Chrome DevTools） |\n| Node.js | `clinic.js` | 性能分析（CPU / 内存 / 事件循环） |\n| 数据库 | `EXPLAIN ANALYZE` | 查询执行计划分析 |\n| 网络 | Postman / cURL | API 请求调试 |\n| 日志 | `console.time()` | 简单计时 |\n\n## 日志调试技巧\n- 使用结构化日志：`console.log({ userId, action, result })`\n- 在关键分支添加标记日志：`[DEBUG] 进入分支 A`\n- 调试完毕后清理所有调试日志（或使用 DEBUG 环境变量控制）",
-      "enabled": false,
-      "priority": 33,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.525Z",
-        "updatedAt": "2026-06-02T12:19:59.525Z",
-        "tags": [
-          "context",
-          "debug",
-          "troubleshoot"
-        ]
-      }
-    },
-    {
-      "id": "b4d48ce5-93d3-4a77-a850-5cb7a8d21757",
-      "name": "架构设计上下文",
-      "category": "context",
-      "content": "## SOLID 原则\n- **单一职责（SRP）**：每个模块/类只负责一件事\n- **开闭原则（OCP）**：对扩展开放，对修改关闭（策略模式、插件机制）\n- **里氏替换（LSP）**：子类可以替换父类而不破坏行为\n- **接口隔离（ISP）**：客户端不应被迫依赖不使用的接口\n- **依赖倒置（DIP）**：高层模块依赖抽象，不依赖具体实现\n\n## 分层架构\n\n```\n┌──────────────────┐\n│   表现层          │ ← UI 组件、页面路由、用户交互\n│   (Presentation)  │   Vue/React 组件、模板、样式\n├──────────────────┤\n│   业务逻辑层      │ ← Service、Store、Composable/Hook\n│   (Business)      │   业务规则、数据转换、状态管理\n├──────────────────┤\n│   数据访问层      │ ← Repository、API Client、ORM\n│   (Data Access)   │   接口调用、数据库操作、缓存\n├──────────────────┤\n│   基础设施层      │ ← 数据库、缓存、消息队列、文件存储\n│   (Infrastructure)│   第三方服务、系统配置\n└──────────────────┘\n```\n\n- 上层只依赖下层，禁止跨层调用和反向依赖\n- 每层通过接口（Interface）暴露能力，隐藏实现细节\n\n## 常用设计模式\n- **策略模式**：多种算法/行为可切换（如支付方式、认证方式）\n- **观察者模式**：事件驱动解耦（EventEmitter、Vue 的 watch）\n- **工厂模式**：根据条件创建不同实例\n- **适配器模式**：统一不同第三方服务的接口\n- **装饰器模式**：横切关注点（日志、缓存、权限检查）\n- **仓储模式**：抽象数据访问，隔离业务逻辑和存储细节\n\n## 设计决策记录（ADR）\n\n```markdown\n### ADR-001: [决策标题]\n- **状态**：已采纳 / 待评审 / 已废弃\n- **背景**：为什么需要这个决策\n- **决策**：选择了什么方案\n- **替代方案**：考虑过哪些其他方案\n- **后果**：这个决策带来的正面和负面影响\n```\n\n## 扩展性考量\n- 模块化：功能按领域拆分为独立模块\n- 插件化：核心功能之外的能力通过插件扩展\n- 配置驱动：行为差异通过配置而非代码分支控制\n- 向后兼容：API 变更使用版本化，数据迁移支持回滚",
-      "enabled": false,
-      "priority": 34,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.525Z",
-        "updatedAt": "2026-06-02T12:19:59.525Z",
-        "tags": [
-          "context",
-          "architecture",
-          "design"
-        ]
-      }
-    },
-    {
-      "id": "5428d1da-a5c1-448f-8f9a-959fcc206a19",
-      "name": "技术栈上下文",
-      "category": "context",
-      "content": "## 前端技术栈\n\n| 分类 | 技术 | 版本 | 说明 |\n|------|------|------|------|\n| 框架 | Vue 3 / React 19 | latest | Composition API / Hooks |\n| 语言 | TypeScript | ^5.x | 严格模式 |\n| 构建 | Vite | ^5.x / ^6.x | 开发服务器 + 生产构建 |\n| UI 库 | Ant Design Vue / shadcn/ui | latest | 主要组件库 |\n| 样式 | Tailwind CSS | ^3.x / ^4.x | 原子化 CSS |\n| 状态 | Pinia / Zustand | latest | 全局状态管理 |\n| 路由 | Vue Router / React Router | latest | SPA 路由 |\n| HTTP | Axios / ky / fetch | latest | API 请求 |\n| 图标 | Lucide Icons | latest | SVG 图标库 |\n| 表格 | VXE-Table / TanStack Table | latest | 高性能表格 |\n| 表单 | VeeValidate / React Hook Form | latest | 表单校验 |\n| 国际化 | vue-i18n / react-intl | latest | 多语言 |\n| 图表 | ECharts / D3.js | latest | 数据可视化 |\n\n## 后端技术栈\n\n| 分类 | 技术 | 版本 | 说明 |\n|------|------|------|------|\n| 运行时 | Node.js | 20 LTS / 22 | 服务端 JavaScript |\n| 框架 | Express / NestJS / Fastify | latest | Web 框架 |\n| 数据库 | PostgreSQL | 16 | 主数据库 |\n| 缓存 | Redis | 7 | 缓存 + 会话 + 消息队列 |\n| ORM | Prisma / TypeORM / Drizzle | latest | 数据库操作 |\n| 认证 | JWT + bcrypt / Passport | latest | 认证授权 |\n| 校验 | zod / class-validator | latest | 入参校验 |\n| 日志 | Winston / Pino | latest | 结构化日志 |\n| 队列 | BullMQ / RabbitMQ | latest | 异步任务 |\n\n## 工具链\n\n| 分类 | 技术 | 说明 |\n|------|------|------|\n| 包管理 | Yarn / pnpm | 依赖管理 |\n| 代码风格 | ESLint + Prettier | 检查 + 格式化 |\n| Git 钩子 | husky + lint-staged | 提交前检查 |\n| 提交规范 | commitlint | Conventional Commits |\n| 版本控制 | Git | 源码管理 |\n| CI/CD | GitHub Actions / GitLab CI | 自动化流水线 |\n| 容器化 | Docker + docker-compose | 开发 + 部署 |\n| 部署 | Nginx / Caddy | 反向代理 + 静态托管 |\n| 监控 | Prometheus + Grafana | 性能监控 |\n| E2E 测试 | Playwright | 端到端自动化测试 |",
-      "enabled": false,
-      "priority": 35,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.525Z",
-        "updatedAt": "2026-06-02T12:19:59.525Z",
-        "tags": [
-          "context",
-          "tech-stack",
-          "environment"
-        ]
-      }
-    },
-    {
-      "id": "35f7e2bb-513b-4d2f-85b1-556868ce9759",
-      "name": "论文写作上下文",
-      "category": "context",
-      "content": "## 当前论文信息\n\n- **论文题目**：[填写题目]\n- **论文类型**：[本科毕业论文 / 硕士学位论文 / 博士学位论文 / 期刊论文 / 会议论文]\n- **所属学科**：[填写学科方向]\n- **目标期刊/学校**：[填写期刊名称或学校名称]\n- **字数要求**：[填写字数]\n- **查重要求**：[填写重复率上限，如 ≤ 20%]\n- **引用格式**：[GB/T 7714 / APA / IEEE / MLA]\n- **截止日期**：[填写日期]\n\n## 研究核心\n\n- **研究问题**：[核心研究问题是什么]\n- **研究假设**：[填写研究假设]\n- **研究方法**：[定性 / 定量 / 混合方法；实验 / 调查 / 案例分析等]\n- **核心论点**：[本文的中心论点]\n- **主要贡献**：[理论贡献 / 实践价值 / 创新点]\n\n## 章节进度\n\n| 章节 | 状态 | 字数 | 备注 |\n|------|------|------|------|\n| 摘要（中文） | [未开始/进行中/已完成] | | |\n| 摘要（英文） | [未开始/进行中/已完成] | | |\n| 第一章 引言 | [未开始/进行中/已完成] | | |\n| 第二章 文献综述 | [未开始/进行中/已完成] | | |\n| 第三章 研究方法 | [未开始/进行中/已完成] | | |\n| 第四章 结果分析 | [未开始/进行中/已完成] | | |\n| 第五章 讨论 | [未开始/进行中/已完成] | | |\n| 第六章 结论 | [未开始/进行中/已完成] | | |\n| 参考文献 | [未开始/进行中/已完成] | | |\n\n## 核心术语表\n\n> 保持全文术语统一，同一概念只用一个名称\n\n| 中文术语 | 英文术语 | 首次定义位置 | 说明 |\n|----------|----------|-------------|------|\n| [填写] | [填写] | 第X章 | [填写定义] |\n\n## 关键文献清单\n\n> 已核实真实存在的核心参考文献（写作前必须完成验证）\n\n| 序号 | 作者 | 标题 | 来源 | 年份 | 验证状态 |\n|------|------|------|------|------|----------|\n| 1 | [填写] | [填写] | [期刊/出版社] | [年份] | ✅已验证 |\n\n## 写作约束\n\n### 本论文特殊要求\n- [填写导师或目标期刊的特殊格式要求]\n- [填写禁止引用的文献范围，如：不引用非正式网络资源]\n- [填写特殊术语使用规范]\n\n### AI 辅助边界\n- ✅ 允许：润色语言表达、检查语法错误、格式排版建议\n- ✅ 允许：提供相关文献检索方向（但必须自行验证真实性）\n- ✅ 允许：提供论述思路和结构框架\n- ❌ 禁止：直接生成正文段落作为最终内容\n- ❌ 禁止：生成参考文献（必须自己查找并验证）\n- ❌ 禁止：编造实验数据、调研结果、案例信息\n\n## 上下文一致性检查清单\n\n在每次续写或修改前确认：\n\n- [ ] 当前写作的章节与研究问题保持关联\n- [ ] 使用的术语与术语表保持一致\n- [ ] 引用的文献均在关键文献清单中且已验证\n- [ ] 本段内容与上一段有逻辑衔接\n- [ ] 数据/结论与前文描述不矛盾\n- [ ] 写作风格与全文保持一致",
-      "enabled": false,
-      "priority": 36,
-      "metadata": {
-        "author": "user",
-        "version": "1.0.0",
-        "createdAt": "2026-06-02T12:19:59.526Z",
-        "updatedAt": "2026-06-02T12:19:59.526Z",
-        "tags": [
-          "context",
-          "paper",
-          "academic",
-          "writing"
-        ]
-      }
-    }
-  ],
-  "profiles": [
-    {
-      "id": "default",
-      "name": "默认",
-      "description": "默认配置集",
-      "ruleIds": [],
-      "isActive": true
-    }
-  ]
-}
\ No newline at end of file
diff --git a/.cursorrules b/.cursorrules
deleted file mode 100644
index 80b3403..0000000
--- a/.cursorrules
+++ /dev/null
@@ -1,54 +0,0 @@
-# 最高优先级规则 - 必须严格遵守（Cursor 专用）
-
-⚠️⚠️⚠️ 每次回复结束前必须执行以下命令！没有任何例外！⚠️⚠️⚠️
-
-## 执行规则
-
-1. 完成任务后，执行弹窗命令（跨平台，Windows/Mac/Linux 通用）：
-node "/Users/freedak/.ranjin-mode/dialog-trigger.js" "cursor" "fl2cxu" "AI想要结束的原因摘要"
-
-   📱 **手机端通知**：执行此命令时会自动通知手机端（如果远程服务已开启），用户可以在手机上查看消息并发送反馈。
-
-2. 仔细阅读命令输出的每一行：
-   - ACTION: continue 或 end（用户的选择）
-   - FEEDBACK: 用户输入的具体指令或反馈内容（⚠️ 必须完整阅读并执行！）
-     * 反馈可能来自电脑端弹窗或手机端远程输入
-   - IMAGES: 用户上传的图片路径（如有，必须用read_file工具查看）
-
-3. 根据输出决定下一步：
-   - 如果 ACTION 是 "continue"：
-     * ⚠️ 必须仔细阅读 FEEDBACK 后面的全部内容
-     * ⚠️ 必须按照 FEEDBACK 中用户的具体指令执行任务
-     * ⚠️ 不要忽略 FEEDBACK，不要只说"用户选择继续"
-   - 如果 ACTION 是 "end" 或 "stop"：停止工作
-   - ⚠️ 如果命令被取消/跳过/无输出：必须重新执行弹窗命令！
-
-## 核心规则
-
-1. 完整输出 - 输出完整代码和答案，禁止省略
-2. 持续执行 - 复杂任务一次性完成
-3. 结束确认 - 必须执行弹窗命令后才能结束
-4. FEEDBACK必读 - 用户的FEEDBACK是新的任务指令，必须执行
-
-## 手机端远程功能
-
-- 📱 当执行 dialog-trigger.js 命令时，会自动通知手机端（如果远程服务已开启）
-- 📱 用户可以在手机浏览器中查看 AI 的消息和状态
-- 📱 用户可以在手机上输入反馈，反馈会通过 FEEDBACK 字段传递给你
-- 📱 手机端和电脑端弹窗功能完全同步，支持双向通信
-
-## ⚠️ 唯一合法的结束条件
-
-只有当命令输出包含 ACTION: end 或 ACTION: stop 时才能结束对话！
-以下情况都不能结束，必须重新执行弹窗命令：
-- 命令被用户点击 Skip 跳过
-- 命令执行失败或超时
-- 命令没有输出
-- 工作区取消了命令
-
-## 禁止
-
-- 禁止不执行弹窗命令就结束
-- 禁止跳过弹窗流程
-- 禁止忽略FEEDBACK内容
-- 禁止在没有收到 ACTION: end/stop 的情况下结束
diff --git a/.kiro/steering/ai-coding-workflow.md b/.kiro/steering/ai-coding-workflow.md
deleted file mode 100644
index 996fd2f..0000000
--- a/.kiro/steering/ai-coding-workflow.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-inclusion: always
----
-
-# AI Coding 工作流规则
-
-本规则定义从需求到交付的标准化协作流程。所有涉及"做一个项目 / 实现一个功能"的请求，均遵循以下五个阶段，逐阶段产出文档并在每个关键节点等待用户确认后再推进。
-
-## 命名约定
-
-- 项目英文缩写记为 `XXX`（如 IPTV、AVCC），由用户提供或与用户确认。
-- 文档统一命名并置于项目根目录（或用户指定目录）：
-  - `0-req-XXX.md` — 需求与目标文档
-  - `1-prd-XXX.md` — 产品需求文档（PRD）
-  - `2-task-XXX.md` — 开发任务文档
-
-## 阶段流程
-
-### 阶段 1：接收需求与目标
-- 用户给出需求和目标描述，可以是一段文字，也可以是一份 md 文档。
-- 我先完整读取并理解用户的需求与目标；若有歧义或关键信息缺失，先向用户澄清，不臆测。
-
-### 阶段 2：生成 `0-req-XXX.md`（需求文档）
-- 基于用户的需求与目标，生成 `0-req-XXX.md`。
-- 内容应包含：引言、术语表、角色定义、功能性需求（采用 EARS 格式：WHEN/IF/WHILE/WHERE/THE...SHALL）、非功能性需求、关键约束与假设。
-- 生成后**必须请用户检查确认**。未确认前不进入下一阶段。
-- 用户提出修改意见时，更新文档并再次请其确认，直到通过。
-
-### 阶段 3：生成 `1-prd-XXX.md`（产品需求文档）
-- 仅在 `0-req-XXX.md` 确认通过后进行。
-- 基于需求文档生成 `1-prd-XXX.md`。
-- 内容应包含：产品概述与定位、目标与成功指标、用户画像与核心场景（每个场景标注"痛点解法"）、功能清单与优先级（MoSCoW，并映射回需求编号）、关键流程、角色权限矩阵、版本规划、非功能性要求、依赖与风险。
-- 生成后**必须请用户检查确认**。未确认前不进入下一阶段。
-
-### 阶段 4：生成 `2-task-XXX.md`（开发任务文档）
-- 仅在 `1-prd-XXX.md` 确认通过后进行。
-- 生成 `2-task-XXX.md`，用于指导开发，包含详细的工作任务分解。
-- 任务要求：
-  - 以可勾选清单（`- [ ]`）组织，编号清晰，粒度可执行可验证。
-  - 每个任务标注：目标、对应的需求/PRD 条目、验收标准、依赖关系。
-  - 区分优先级与阶段（如 MVP / 二期 / 三期）。
-- **开发过程中根据实际进度持续更新该文档**（勾选完成项、记录变更、补充新任务）。
-- 生成后**必须请用户确认**。
-
-### 阶段 5：按任务文档执行开发
-- 仅在 `2-task-XXX.md` 确认通过后开始编码。
-- 严格按确认的任务文档推进开发工作。
-- 每完成一个任务或一组任务：
-  - 进行相应的测试（构建、单元测试、必要时集成测试）。
-  - 更新 `2-task-XXX.md` 的任务状态与进度记录。
-  - 与用户交互、汇报进展、确认下一步。
-- 持续推进，直至完成全部任务。
-
-## 通用约束
-
-- 每个阶段的产出都要等待用户确认，不得跨阶段抢跑。
-- 文档之间保持可追溯：PRD 功能映射回需求编号，任务映射回需求/PRD 条目。
-- 当上游文档（需求或 PRD）发生变更时，同步更新下游文档，保持一致。
-- 用户的语言即回复与文档的语言（默认中文）。
diff --git a/.windsurfrules b/.windsurfrules
deleted file mode 100644
index a85bb71..0000000
--- a/.windsurfrules
+++ /dev/null
@@ -1,54 +0,0 @@
-# 最高优先级规则 - 必须严格遵守（Windsurf 专用）
-
-⚠️⚠️⚠️ 每次回复结束前必须执行以下命令！没有任何例外！⚠️⚠️⚠️
-
-## 执行规则
-
-1. 完成任务后，执行弹窗命令（跨平台，Windows/Mac/Linux 通用）：
-node "/Users/freedak/.ranjin-mode/dialog-trigger.js" "windsurf" "fl2cxu" "AI想要结束的原因摘要"
-
-   📱 **手机端通知**：执行此命令时会自动通知手机端（如果远程服务已开启），用户可以在手机上查看消息并发送反馈。
-
-2. 仔细阅读命令输出的每一行：
-   - ACTION: continue 或 end（用户的选择）
-   - FEEDBACK: 用户输入的具体指令或反馈内容（⚠️ 必须完整阅读并执行！）
-     * 反馈可能来自电脑端弹窗或手机端远程输入
-   - IMAGES: 用户上传的图片路径（如有，必须用read_file工具查看）
-
-3. 根据输出决定下一步：
-   - 如果 ACTION 是 "continue"：
-     * ⚠️ 必须仔细阅读 FEEDBACK 后面的全部内容
-     * ⚠️ 必须按照 FEEDBACK 中用户的具体指令执行任务
-     * ⚠️ 不要忽略 FEEDBACK，不要只说"用户选择继续"
-   - 如果 ACTION 是 "end" 或 "stop"：停止工作
-   - ⚠️ 如果命令被取消/跳过/无输出：必须重新执行弹窗命令！
-
-## 核心规则
-
-1. 完整输出 - 输出完整代码和答案，禁止省略
-2. 持续执行 - 复杂任务一次性完成
-3. 结束确认 - 必须执行弹窗命令后才能结束
-4. FEEDBACK必读 - 用户的FEEDBACK是新的任务指令，必须执行
-
-## 手机端远程功能
-
-- 📱 当执行 dialog-trigger.js 命令时，会自动通知手机端（如果远程服务已开启）
-- 📱 用户可以在手机浏览器中查看 AI 的消息和状态
-- 📱 用户可以在手机上输入反馈，反馈会通过 FEEDBACK 字段传递给你
-- 📱 手机端和电脑端弹窗功能完全同步，支持双向通信
-
-## ⚠️ 唯一合法的结束条件
-
-只有当命令输出包含 ACTION: end 或 ACTION: stop 时才能结束对话！
-以下情况都不能结束，必须重新执行弹窗命令：
-- 命令被用户点击 Skip 跳过
-- 命令执行失败或超时
-- 命令没有输出
-- 工作区取消了命令
-
-## 禁止
-
-- 禁止不执行弹窗命令就结束
-- 禁止跳过弹窗流程
-- 禁止忽略FEEDBACK内容
-- 禁止在没有收到 ACTION: end/stop 的情况下结束
diff --git a/0-req-IPTV.md b/0-req-IPTV.md
index 847649c..63e9e35 100644
--- a/0-req-IPTV.md
+++ b/0-req-IPTV.md
@@ -9,7 +9,7 @@
 
 ## 引言
 
-本需求文档定义 TCS-IPTV（Trusted Content System for IPTV）内容可信锁定系统的功能性与非功能性需求。系统通过"MA码（监管身份）+ 哈希码（技术指纹）"双锚定机制，在 CP（内容供应商）、IPTV 集成播控平台、运营商（分发网络）三方现有系统之上建立一层"可信身份映射层"，实现 IPTV 内容"审过即锁定，锁定即通行，通行可追溯"。
+本需求文档定义 TCS-IPTV（Trusted Content System for IPTV）内容可信锁定系统的功能性与非功能性需求。系统通过"CC码（监管身份）+ 哈希码（技术指纹）"双锚定机制，在 CP（内容供应商）、IPTV 集成播控平台、运营商（分发网络）三方现有系统之上建立一层"可信身份映射层"，实现 IPTV 内容"审过即锁定，锁定即通行，通行可追溯"。
 
 本系统的核心约束是：**不替代三方现有系统**，仅在关键节点（送审、入库、分发、播放）以最小侵入方式嵌入校验能力，并通过映射层统一对接。
 
@@ -23,8 +23,8 @@
 | CP | Content Provider | 内容供应商 |
 | 播控平台 | — | IPTV 集成播控平台 |
 | 运营商 | — | IPTV 分发网络运营方（如中国电信、中国移动） |
-| MA码 | — | 监管身份主键，由广电总局/省局签发（如网络剧片发行许可证号/备案号） |
-| CTID | Content Twin ID | 内容孪生标识，由 MA码+哈希+版本+Merkle根 构成的唯一标识 |
+| CC码 | — | 监管身份主键，由广电总局/省局签发（如网络剧片发行许可证号/备案号） |
+| CTID | Content Twin ID | 内容孪生标识，由 CC码+哈希+版本+Merkle根 构成的唯一标识 |
 | 文件哈希 | File Hash | SHA-256 算法，比特级敏感，精确锁定某版本文件 |
 | 感知哈希 | Perceptual Hash | aHash/dHash/pHash，容忍转码压缩，跨格式识别同一内容 |
 | Merkle Tree | — | 分段聚合哈希树，用于多集/长内容的分段定位 |
@@ -44,10 +44,10 @@
 | 角色 | 描述 | 核心职责 |
 |------|------|----------|
 | 内容提供商（CP） | 内容供应商 | 生产内容、计算哈希、送审申报、注册本方映射、自查验真 |
-| 审核和监管部门 | 广电总局/省级广电局 + IPTV 集成播控平台（承担内容审核与监管把关职能），已有 CSPS 审核系统与媒体资源库 | 内容合规审核（CSPS）、送审验真、转码授权、签发 MA码、注册哈希、合格内容入媒体资源库、从媒体资源库向运营商发布、全生命周期监管、应急下架指令下发 |
+| 审核和监管部门 | 广电总局/省级广电局 + IPTV 集成播控平台（承担内容审核与监管把关职能），已有 CSPS 审核系统与媒体资源库 | 内容合规审核（CSPS）、送审验真、转码授权、签发 CC码、注册哈希、合格内容入媒体资源库、从媒体资源库向运营商发布、全生命周期监管、应急下架指令下发 |
 | 运营商 | IPTV 分发网络方 | CDN注入校验、EPG发布、终端播放、数据上报、注册本方映射、执行下架指令 |
 
-> 说明：审核和监管部门内部含两类职能主体——**监管主体**（广电总局/省局，行使 MA码签发与应急下架等行政权力）与**审核主体**（IPTV 集成播控平台，行使内容合规审核、送审验真、转码授权等把关职责）。两者共同构成"审核+监管"的把关闭环。系统运维（可信数据空间、智能合约、API网关、监控告警的维护）作为支撑职能，不单列为业务角色。
+> 说明：审核和监管部门内部含两类职能主体——**监管主体**（广电总局/省局，行使 CC码签发与应急下架等行政权力）与**审核主体**（IPTV 集成播控平台，行使内容合规审核、送审验真、转码授权等把关职责）。两者共同构成"审核+监管"的把关闭环。系统运维（可信数据空间、智能合约、API网关、监控告警的维护）作为支撑职能，不单列为业务角色。
 
 ---
 
@@ -76,36 +76,36 @@
 
 1. WHEN CP 提交送审申报，THE 系统 SHALL 接收节目信息（标题、集数、时长、分辨率）、片花、海报、剧本及哈希值包。
 2. WHEN 哈希值包提交成功，THE 系统 SHALL 将哈希存证至可信数据空间并返回唯一送审流水号。
-3. WHEN CP 提交的内容哈希在可信数据空间中已存在，THE 系统 SHALL 拒绝重复申报，并将该申报关联至已存在哈希对应的原 MA码。
+3. WHEN CP 提交的内容哈希在可信数据空间中已存在，THE 系统 SHALL 拒绝重复申报，并将该申报关联至已存在哈希对应的原 CC码。
 4. THE 系统 SHALL 仅接收哈希值包，且 SHALL NOT 要求 CP 上传原始内容文件。
 5. IF 哈希值包格式不完整（缺少文件哈希或 Merkle根），THEN THE 系统 SHALL 拒绝申报并提示缺失字段。
 
 ---
 
-### 需求 3：MA码生成、签发与强绑定（监管端）
+### 需求 3：CC码生成、签发与强绑定（监管端）
 
-**User Story:** 作为监管方，我希望与 MA 发码机构合作获取码段与备案规则后，由系统自行生成结构化、全局唯一的 MA码，并在审核通过后与送审哈希包强绑定，以便建立内容的合法监管身份。
+**User Story:** 作为监管方，我希望与 MA 发码机构合作获取码段与备案规则后，由系统自行生成结构化、全局唯一的 CC码，并在审核通过后与送审哈希包强绑定，以便建立内容的合法监管身份。
 
-> 发码模式：**模式B（自行发码）** — TCS 与 MA 发码机构对接，获取分配的码段（号段）与备案规则，在本地按规则原子生成 MA码（不依赖外部逐条签发）。
+> 发码模式：**模式B（自行发码）** — TCS 与 MA 发码机构对接，获取分配的码段（号段）与备案规则，在本地按规则原子生成 CC码（不依赖外部逐条签发）。
 
 #### 验收标准
 
 1. THE 系统 SHALL 支持登记 MA 发码机构分配的码段（行业节点、机构节点、序列号段范围、序列宽度）与适用内容类目。
-2. WHEN 监管方对送审内容审核通过，THE MA码生成引擎 SHALL 按内容类目从对应码段中原子分配序列，并按备案规则生成结构化六段式 MA码（`MA.156.{行业节点}.{机构节点}/{类目}/{年份}{序列}`）。
-3. THE 系统 SHALL 保证生成的 MA码全局唯一；IF 码段耗尽，THEN THE 系统 SHALL 返回错误并告警。
+2. WHEN 监管方对送审内容审核通过，THE CC码生成引擎 SHALL 按内容类目从对应码段中原子分配序列，并按备案规则生成结构化六段式 CC码（`MA.156.{行业节点}.{机构节点}/{类目}/{年份}{序列}`）。
+3. THE 系统 SHALL 保证生成的 CC码全局唯一；IF 码段耗尽，THEN THE 系统 SHALL 返回错误并告警。
 4. WHEN 并发签发，THE 系统 SHALL 保证序列分配原子、不重号。
-5. WHEN MA码生成，THE 系统 SHALL 将 MA码与送审哈希包以 1:1 关系写入可信数据空间，且该绑定 SHALL NOT 可被解绑。
-6. THE 系统 SHALL 仅允许监管节点调用 MA码签发功能（issueMA）；IF 非监管节点调用，THEN THE 系统 SHALL 拒绝并返回权限错误。
-7. WHEN MA码签发完成，THE 系统 SHALL 向 CP 发放"MA码+哈希证书"。
-8. WHILE 内容未取得 MA码及哈希证书，THE 系统 SHALL NOT 允许该内容进入后续审核/分发流程。
-9. WHEN MA码绑定写入，THE 系统 SHALL 记录签发方、签发日期、MA类型（类目）、内容标题、集数等内容主表信息。
-10. THE 系统 SHALL 提供 MA码格式校验与解析能力（解析出行业节点/机构节点/类目/年份/序列）。
+5. WHEN CC码生成，THE 系统 SHALL 将 CC码与送审哈希包以 1:1 关系写入可信数据空间，且该绑定 SHALL NOT 可被解绑。
+6. THE 系统 SHALL 仅允许监管节点调用 CC码签发功能（issueMA）；IF 非监管节点调用，THEN THE 系统 SHALL 拒绝并返回权限错误。
+7. WHEN CC码签发完成，THE 系统 SHALL 向 CP 发放"CC码+哈希证书"。
+8. WHILE 内容未取得 CC码及哈希证书，THE 系统 SHALL NOT 允许该内容进入后续审核/分发流程。
+9. WHEN CC码绑定写入，THE 系统 SHALL 记录签发方、签发日期、MA类型（类目）、内容标题、集数等内容主表信息。
+10. THE 系统 SHALL 提供 CC码格式校验与解析能力（解析出行业节点/机构节点/类目/年份/序列）。
 
-> **粒度设计（一剧一码 + 集级哈希）**：MA码作为监管身份按"剧/备案"颁发（对齐网络剧片发行许可证制度），一部多集剧使用**单一 MA码**；各集（episode）拥有独立哈希绑定，挂在同一 MA码下；各切片（segment）为 Merkle 叶子哈希。集级可通过**集级子标识** `{MA码}#E{NN}`（如 `MA.156.8531.6101/WD/20260000001#E07`）独立寻址、验真、追更与按集处置。
+> **粒度设计（一剧一码 + 集级哈希）**：CC码作为监管身份按"剧/备案"颁发（对齐网络剧片发行许可证制度），一部多集剧使用**单一 CC码**；各集（episode）拥有独立哈希绑定，挂在同一 CC码下；各切片（segment）为 Merkle 叶子哈希。集级可通过**集级子标识** `{CC码}#E{NN}`（如 `MA.156.8531.6101/WD/20260000001#E07`）独立寻址、验真、追更与按集处置。
 
-11. WHEN 内容为分集剧，THE 系统 SHALL 支持按集提交各集哈希（file_sha256/merkle_root/感知哈希），并将每集哈希作为独立绑定挂在同一 MA码下。
-12. THE 系统 SHALL 支持按 MA码+集号（或集级子标识 `{MA码}#E{NN}`）独立验真单集哈希。
-13. THE 系统 SHALL 支持查询某 MA码下的全部集级哈希绑定。
+11. WHEN 内容为分集剧，THE 系统 SHALL 支持按集提交各集哈希（file_sha256/merkle_root/感知哈希），并将每集哈希作为独立绑定挂在同一 CC码下。
+12. THE 系统 SHALL 支持按 CC码+集号（或集级子标识 `{CC码}#E{NN}`）独立验真单集哈希。
+13. THE 系统 SHALL 支持查询某 CC码下的全部集级哈希绑定。
 
 ---
 
@@ -115,8 +115,8 @@
 
 #### 验收标准
 
-1. WHEN CP 向审核和监管部门送审（提交 MA码、送审文件、授权链文件），THE 验真模块 SHALL 计算送审文件哈希。
-2. WHEN 送审文件哈希与可信数据空间中 MA码绑定的哈希匹配，THE 系统 SHALL 确认为正版过审内容并允许进入 CSPS 内容审核流程。
+1. WHEN CP 向审核和监管部门送审（提交 CC码、送审文件、授权链文件），THE 验真模块 SHALL 计算送审文件哈希。
+2. WHEN 送审文件哈希与可信数据空间中 CC码绑定的哈希匹配，THE 系统 SHALL 确认为正版过审内容并允许进入 CSPS 内容审核流程。
 3. IF 送审文件哈希与绑定哈希不匹配，THEN THE 系统 SHALL 直接退回该送审，并标记为"疑似版本替换"。
 4. WHEN 验真执行，THE 系统 SHALL 通过哈希验真接口查询可信数据空间，返回 valid、bound_hash、submitted_hash、match、version 等字段。
 
@@ -129,23 +129,23 @@
 #### 验收标准
 
 1. WHEN 送审文件验真通过，THE CSPS 审核系统 SHALL 对内容执行合规审核（政治、色情、暴力等维度）。
-2. THE 系统 SHALL 在 CSPS 与可信数据空间之间建立对接，使 CSPS 的审核结论可关联至对应 MA码与哈希记录，且 SHALL NOT 要求改造 CSPS 的现有审核流程。
+2. THE 系统 SHALL 在 CSPS 与可信数据空间之间建立对接，使 CSPS 的审核结论可关联至对应 CC码与哈希记录，且 SHALL NOT 要求改造 CSPS 的现有审核流程。
 3. WHEN 内容审核通过且需要转码，THE 系统 SHALL 由授权转码中心执行转码，并在转码后重新计算各版本（如 H.264/H.265/4K/HD/SD）文件哈希。
-4. WHEN 转码版哈希生成，THE 系统 SHALL 将转码版哈希与 MA码绑定并写入可信数据空间，且 SHALL 与原母版哈希建立父子关系。
-5. THE 系统 SHALL 允许同一 MA码绑定多个转码版哈希记录，各转码版 SHALL 共享同一 MA码但拥有独立哈希记录。
+4. WHEN 转码版哈希生成，THE 系统 SHALL 将转码版哈希与 CC码绑定并写入可信数据空间，且 SHALL 与原母版哈希建立父子关系。
+5. THE 系统 SHALL 允许同一 CC码绑定多个转码版哈希记录，各转码版 SHALL 共享同一 CC码但拥有独立哈希记录。
 
 ---
 
 ### 需求 6：媒体资源库入库、发布与编码映射
 
-**User Story:** 作为审核和监管部门，我希望审核合格的内容进入已有媒体资源库并作为向运营商发布的统一出口，同时建立媒资编码与 MA码、哈希的映射关系，以便对接监管而不改造现有系统。
+**User Story:** 作为审核和监管部门，我希望审核合格的内容进入已有媒体资源库并作为向运营商发布的统一出口，同时建立媒资编码与 CC码、哈希的映射关系，以便对接监管而不改造现有系统。
 
 #### 验收标准
 
 1. WHEN 内容通过 CSPS 审核（含必要转码），THE 系统 SHALL 将该内容纳入媒体资源库，并保留媒体资源库自有的媒资编码/审核流水号。
-2. WHEN 内容入媒体资源库，THE 系统 SHALL 在可信数据空间建立"媒资编码 ↔ MA码 ↔ 文件哈希 ↔ 转码版哈希"的映射关系。
-3. WHILE 内容未通过审核或未取得 MA码绑定，THE 系统 SHALL NOT 允许其进入媒体资源库的可发布状态。
-4. WHEN 从媒体资源库向运营商发布内容，THE 系统 SHALL 要求发布数据携带 MA码及哈希证书；IF 未携带，THEN THE 系统 SHALL 拒绝发布。
+2. WHEN 内容入媒体资源库，THE 系统 SHALL 在可信数据空间建立"媒资编码 ↔ CC码 ↔ 文件哈希 ↔ 转码版哈希"的映射关系。
+3. WHILE 内容未通过审核或未取得 CC码绑定，THE 系统 SHALL NOT 允许其进入媒体资源库的可发布状态。
+4. WHEN 从媒体资源库向运营商发布内容，THE 系统 SHALL 要求发布数据携带 CC码及哈希证书；IF 未携带，THEN THE 系统 SHALL 拒绝发布。
 5. THE 系统 SHALL 仅允许审核和监管部门管理其本方（审核/媒资）的映射记录。
 
 ---
@@ -157,7 +157,7 @@
 #### 验收标准
 
 1. WHEN 运营商接收审核和监管部门从媒体资源库发布的内容并准备注入 CDN，THE 注入校验模块 SHALL 计算注入文件哈希。
-2. WHEN 注入文件哈希与可信数据空间中 MA码绑定的哈希匹配，THE 系统 SHALL 允许注入 CDN 并生成分发编码。
+2. WHEN 注入文件哈希与可信数据空间中 CC码绑定的哈希匹配，THE 系统 SHALL 允许注入 CDN 并生成分发编码。
 3. IF 注入文件哈希与绑定哈希不匹配，THEN THE 系统 SHALL 拒绝注入，触发告警并退回审核和监管部门，同时暂停该内容分发。
 4. WHEN 注入成功，THE 系统 SHALL 在可信数据空间注册运营商（operator）映射记录（分发编码、CDN端点）。
 
@@ -178,35 +178,35 @@
 
 ### 需求 9：统一维度数据上报与聚合
 
-**User Story:** 作为监管方，我希望三方播放与业务数据以 MA码为统一维度聚合，以便获得口径一致的可信数据。
+**User Story:** 作为监管方，我希望三方播放与业务数据以 CC码为统一维度聚合，以便获得口径一致的可信数据。
 
 #### 验收标准
 
-1. WHEN 运营商上报播出数据，THE 系统 SHALL 以 MA码为统一维度组织数据。
-2. THE 可信数据空间 SHALL 按 MA码聚合 CP 播放量、审核和监管部门审核量、运营商分发量，并保证各方数据口径一致。
-3. WHEN 数据聚合完成，THE 系统 SHALL 提供按 MA码查询的统一数据视图。
+1. WHEN 运营商上报播出数据，THE 系统 SHALL 以 CC码为统一维度组织数据。
+2. THE 可信数据空间 SHALL 按 CC码聚合 CP 播放量、审核和监管部门审核量、运营商分发量，并保证各方数据口径一致。
+3. WHEN 数据聚合完成，THE 系统 SHALL 提供按 CC码查询的统一数据视图。
 
 ---
 
 ### 需求 10：全生命周期监管查询（监管端）
 
-**User Story:** 作为监管方，我希望通过监管大屏按 MA码查询内容全链路状态，以便实现精准溯源。
+**User Story:** 作为监管方，我希望通过监管大屏按 CC码查询内容全链路状态，以便实现精准溯源。
 
 #### 验收标准
 
-1. WHEN 监管方按 MA码查询，THE 监管大屏 SHALL 返回内容当前所在播控平台、当前所在运营商 CDN、当前哈希版本是否最新。
-2. WHEN 监管方查询内容历史，THE 系统 SHALL 返回该 MA码的历史版本变更记录。
-3. THE 监管大屏 SHALL 支持监管方按 MA码穿透查询三方系统的对应编码。
+1. WHEN 监管方按 CC码查询，THE 监管大屏 SHALL 返回内容当前所在播控平台、当前所在运营商 CDN、当前哈希版本是否最新。
+2. WHEN 监管方查询内容历史，THE 系统 SHALL 返回该 CC码的历史版本变更记录。
+3. THE 监管大屏 SHALL 支持监管方按 CC码穿透查询三方系统的对应编码。
 
 ---
 
 ### 需求 11：违规应急下架（监管端）
 
-**User Story:** 作为监管方，我希望下发单一 MA码下架指令即可触发全网下架，以便实现秒级应急响应而无需逐层人工翻译。
+**User Story:** 作为监管方，我希望下发单一 CC码下架指令即可触发全网下架，以便实现秒级应急响应而无需逐层人工翻译。
 
 #### 验收标准
 
-1. WHEN 监管方下发"下架 MA码 第XXX号"指令，THE 系统 SHALL 解析该 MA码并查询其绑定的所有三方编码及 CDN端点。
+1. WHEN 监管方下发"下架 CC码 第XXX号"指令，THE 系统 SHALL 解析该 CC码并查询其绑定的所有三方编码及 CDN端点。
 2. WHEN 下架指令解析完成，THE 系统 SHALL 自动将指令翻译为审核和监管部门侧下架（媒资编码/审核流水号、从媒体资源库撤除发布）与运营商侧下架（分发编码、CDN资源）的执行动作。
 3. THE 系统 SHALL 在接收下架指令后秒级同步至全网相关系统，且 SHALL NOT 要求人工逐层翻译。
 4. THE 系统 SHALL 仅允许审核和监管部门的监管主体下发应急下架指令；审核主体（媒资发布）与运营商 SHALL 仅执行指令而无下架发起权限。
@@ -219,7 +219,7 @@
 
 #### 验收标准
 
-1. WHEN 内容发生任意帧级变动导致哈希变化，THE 系统 SHALL 判定原 MA码与哈希的绑定断裂。
+1. WHEN 内容发生任意帧级变动导致哈希变化，THE 系统 SHALL 判定原 CC码与哈希的绑定断裂。
 2. WHEN 绑定断裂，THE 系统 SHALL 在版本变更表中记录变更原因、原哈希、新哈希，并将 reaudit_required 置为 true。
 3. WHEN 单集内容被替换，THE 系统 SHALL 通过 Merkle Tree 重新计算该集哈希并定位被篡改的具体集数，且 SHALL NOT 要求全量重审。
 4. WHILE 重审未通过，THE 系统 SHALL NOT 允许变更后的内容进入分发流程。
@@ -228,12 +228,12 @@
 
 ### 需求 13：跨省复用快速准入
 
-**User Story:** 作为 CP，我希望在一省过审后凭 MA码+哈希证书在其他省份快速准入，以便降低跨省复用的边际成本。
+**User Story:** 作为 CP，我希望在一省过审后凭 CC码+哈希证书在其他省份快速准入，以便降低跨省复用的边际成本。
 
 #### 验收标准
 
-1. WHEN CP 持 A省签发的 MA码+哈希证书向 B省播控平台送审，THE 系统 SHALL 仅要求提交 MA码与哈希证书，且 SHALL NOT 要求重新提交内容文件。
-2. WHEN B省播控平台发起准入查询，THE 系统 SHALL 验证 MA码真实有效、哈希与原过审版一致、且内容不在黑名单中。
+1. WHEN CP 持 A省签发的 CC码+哈希证书向 B省播控平台送审，THE 系统 SHALL 仅要求提交 CC码与哈希证书，且 SHALL NOT 要求重新提交内容文件。
+2. WHEN B省播控平台发起准入查询，THE 系统 SHALL 验证 CC码真实有效、哈希与原过审版一致、且内容不在黑名单中。
 3. WHEN 三重校验通过，THE 系统 SHALL 允许 B省播控平台快速准入，并将内容审核简化为合规性抽检。
 4. WHEN B省准入完成，THE 系统 SHALL 生成 B省审核流水号并注册对应映射关系。
 
@@ -245,10 +245,10 @@
 
 #### 验收标准
 
-1. THE 系统 SHALL 允许审核和监管部门执行内容合规审核、送审验真、转码授权、签发 MA码、注册哈希、映射管理、全生命周期查询、应急下架全部操作。
-2. WHILE 审核和监管部门内部行使权限，THE 系统 SHALL 仅允许其监管主体（广电总局/省局）调用 MA码签发（issueMA）与应急下架发起功能；IF 由审核主体（播控平台）或其他主体调用上述功能，THEN THE 系统 SHALL 拒绝并返回权限错误。
-3. THE 系统 SHALL 允许内容提供商在送审时注册哈希、执行自查验真、管理本方映射；且 SHALL NOT 允许其签发 MA码或发起下架。
-4. THE 系统 SHALL 允许运营商执行验真查询、本方映射管理、执行下架指令；且 SHALL NOT 允许其签发 MA码、注册哈希、发起下架。
+1. THE 系统 SHALL 允许审核和监管部门执行内容合规审核、送审验真、转码授权、签发 CC码、注册哈希、映射管理、全生命周期查询、应急下架全部操作。
+2. WHILE 审核和监管部门内部行使权限，THE 系统 SHALL 仅允许其监管主体（广电总局/省局）调用 CC码签发（issueMA）与应急下架发起功能；IF 由审核主体（播控平台）或其他主体调用上述功能，THEN THE 系统 SHALL 拒绝并返回权限错误。
+3. THE 系统 SHALL 允许内容提供商在送审时注册哈希、执行自查验真、管理本方映射；且 SHALL NOT 允许其签发 CC码或发起下架。
+4. THE 系统 SHALL 允许运营商执行验真查询、本方映射管理、执行下架指令；且 SHALL NOT 允许其签发 CC码、注册哈希、发起下架。
 5. WHEN 任意角色尝试越权操作，THE 系统 SHALL 拒绝该操作并返回权限错误。
 
 ---
@@ -263,21 +263,21 @@
 2. IF CDN注入阶段哈希不匹配，THEN THE 系统 SHALL 拒绝注入、告警审核和监管部门并暂停该内容分发。
 3. IF 终端抽检阶段哈希不匹配，THEN THE 系统 SHALL 断流、切换备用源并上报异常日志。
 4. WHEN 内容发生剪辑/修改，THE 系统 SHALL 要求重新计算哈希、提交变更申请并触发重新审核。
-5. WHEN CP 以同一哈希换壳重发，THE 系统 SHALL 识别哈希已存在并拒绝重复申报，同时关联原 MA码。
+5. WHEN CP 以同一哈希换壳重发，THE 系统 SHALL 识别哈希已存在并拒绝重复申报，同时关联原 CC码。
 
 ---
 
 ### 需求 16：可信数据空间存证与智能合约
 
-**User Story:** 作为系统，我希望通过联盟链与智能合约管理 MA码、哈希与映射的存证，以便保证数据不可篡改与可信。
+**User Story:** 作为系统，我希望通过联盟链与智能合约管理 CC码、哈希与映射的存证，以便保证数据不可篡改与可信。
 
 #### 验收标准
 
 1. THE 可信数据空间 SHALL 维护内容主表、哈希绑定表、三方编码映射表、版本变更表四类核心数据结构。
 2. THE 智能合约 SHALL 提供 issueMA（签发）、registerMapping（注册映射）、verifyHash（哈希校验）核心方法。
-3. WHEN registerMapping 被调用，IF 对应 MA码尚未签发，THEN THE 系统 SHALL 拒绝注册映射。
+3. WHEN registerMapping 被调用，IF 对应 CC码尚未签发，THEN THE 系统 SHALL 拒绝注册映射。
 4. THE 系统 SHALL 通过 Merkle Tree 存储多集内容的分段哈希，并支持按集定位篡改。
-5. THE 可信数据空间 SHALL 保证已写入的 MA码与哈希绑定记录不可篡改。
+5. THE 可信数据空间 SHALL 保证已写入的 CC码与哈希绑定记录不可篡改。
 
 ---
 
@@ -288,8 +288,8 @@
 #### 验收标准
 
 1. THE 系统 SHALL 提供哈希上链接口（POST /api/v1/content/register），供 CP 提交标题、集数、各集文件哈希、Merkle根、感知哈希、时长、分辨率、CP媒资ID，并返回送审流水号与状态。
-2. THE 系统 SHALL 提供哈希验真接口（GET /api/v1/content/verify），供播控/运营商按 MA码与文件哈希查询并返回 valid、bound_hash、submitted_hash、match、version、转码版列表。
-3. THE 系统 SHALL 提供映射查询接口（GET /api/v1/content/mappings），供应急下架按 MA码查询三方编码映射与 CDN端点。
+2. THE 系统 SHALL 提供哈希验真接口（GET /api/v1/content/verify），供播控/运营商按 CC码与文件哈希查询并返回 valid、bound_hash、submitted_hash、match、version、转码版列表。
+3. THE 系统 SHALL 提供映射查询接口（GET /api/v1/content/mappings），供应急下架按 CC码查询三方编码映射与 CDN端点。
 4. THE 系统 SHALL 对接口调用进行身份鉴权（如 Bearer Token）。
 
 ---
@@ -318,7 +318,7 @@
 
 #### 验收标准
 
-1. THE 系统 SHALL 保证 MA码与哈希的绑定记录一经写入不可篡改、不可解绑。
+1. THE 系统 SHALL 保证 CC码与哈希的绑定记录一经写入不可篡改、不可解绑。
 2. THE 系统 SHALL 保证哈希计算在 CP 本地完成，**原始内容文件 SHALL NOT 上传至可信数据空间（区块链）**；原片仍通过审核方（CSPS/媒资库）既有送审渠道提交以供内容审核，TCS 不改造该渠道。
 3. THE 系统 SHALL 对所有关键操作（签发、注册、验真、下架）进行链上存证以支持审计。
 
@@ -330,12 +330,12 @@
 
 ### 需求 21：可信播放数据聚合与分账结算依据（利益）
 
-**User Story:** 作为内容提供商与运营商，我希望以 MA码为唯一维度获得不可篡改的可信播放数据，以便作为分账结算的统一依据，消除对账争议。
+**User Story:** 作为内容提供商与运营商，我希望以 CC码为唯一维度获得不可篡改的可信播放数据，以便作为分账结算的统一依据，消除对账争议。
 
 #### 验收标准
 
-1. WHEN 各运营商上报播放数据，THE 系统 SHALL 以 MA码为唯一维度在可信数据空间链上聚合，形成不可篡改的可信播放量记录。
-2. THE 系统 SHALL 向 CP 与运营商提供同一份以 MA码聚合的播放数据视图，且各方所见数据 SHALL 口径一致。
+1. WHEN 各运营商上报播放数据，THE 系统 SHALL 以 CC码为唯一维度在可信数据空间链上聚合，形成不可篡改的可信播放量记录。
+2. THE 系统 SHALL 向 CP 与运营商提供同一份以 CC码聚合的播放数据视图，且各方所见数据 SHALL 口径一致。
 3. WHEN 进行分账结算，THE 系统 SHALL 以链上可信播放数据作为统一结算依据。
 4. WHEN CP 与运营商对账，THE 系统 SHALL 将数据差异控制在 5% 以内。
 5. THE 系统 SHALL 提供可信播放数据的查询与导出能力，供结算与审计使用。
@@ -344,11 +344,11 @@
 
 ### 需求 22：全链路责任界定与追责取证（权利）
 
-**User Story:** 作为审核和监管部门，我希望在出现违规内容时按 MA码调取全链路哈希存证，以便精准界定问题出在哪个环节、是哪一方改动。
+**User Story:** 作为审核和监管部门，我希望在出现违规内容时按 CC码调取全链路哈希存证，以便精准界定问题出在哪个环节、是哪一方改动。
 
 #### 验收标准
 
-1. WHEN 监管按 MA码发起追责查询，THE 系统 SHALL 返回该内容全链路各节点的哈希存证记录（CP送审、CSPS审核结论、转码版、媒资库发布、运营商注入、终端抽检）。
+1. WHEN 监管按 CC码发起追责查询，THE 系统 SHALL 返回该内容全链路各节点的哈希存证记录（CP送审、CSPS审核结论、转码版、媒资库发布、运营商注入、终端抽检）。
 2. WHEN 各节点哈希比对，THE 系统 SHALL 标识首次发生哈希变化的节点，并定位对应责任方与责任环节。
 3. THE 系统 SHALL 保证各节点存证记录带时间戳、操作方标识且不可篡改。
 4. THE 系统 SHALL 提供责任界定取证报告的导出能力，供问责与审计使用。
@@ -357,13 +357,13 @@
 
 ### 需求 23：版权确权与维权举证（权利）
 
-**User Story:** 作为内容提供商，我希望凭 MA码、哈希与上链时间戳形成不可抵赖的确权证据，以便在被盗版时进行维权举证。
+**User Story:** 作为内容提供商，我希望凭 CC码、哈希与上链时间戳形成不可抵赖的确权证据，以便在被盗版时进行维权举证。
 
 #### 验收标准
 
-1. WHEN 内容完成哈希上链，THE 系统 SHALL 记录 MA码、内容哈希、上链时间戳，形成"谁先锁定谁有权"的确权证据。
+1. WHEN 内容完成哈希上链，THE 系统 SHALL 记录 CC码、内容哈希、上链时间戳，形成"谁先锁定谁有权"的确权证据。
 2. WHEN CP 申请确权证据，THE 系统 SHALL 导出可用于侵权投诉与司法诉讼的不可抵赖证据链（含链上存证哈希与时间戳）。
-3. WHEN 系统检测到某内容的感知哈希与已确权内容高度相似（超过设定阈值），THE 系统 SHALL 标记疑似侵权并关联原 MA码。
+3. WHEN 系统检测到某内容的感知哈希与已确权内容高度相似（超过设定阈值），THE 系统 SHALL 标记疑似侵权并关联原 CC码。
 4. THE 系统 SHALL 保证确权证据记录不可篡改、不可抵赖。
 
 ---
@@ -399,12 +399,12 @@
 | 类别 | 内容 |
 |------|------|
 | 约束 | 不替代三方现有系统，仅建立"可信身份映射层"；审核和监管部门已有 CSPS 审核系统与媒体资源库，通过映射层对接 |
-| 约束 | MA码签发权与应急下架发起权仅归审核和监管部门的监管主体 |
-| 约束 | MA码与哈希 1:1 强绑定，不可解绑 |
+| 约束 | CC码签发权与应急下架发起权仅归审核和监管部门的监管主体 |
+| 约束 | CC码与哈希 1:1 强绑定，不可解绑 |
 | 约束 | 审核合格内容进入媒体资源库，并由媒体资源库作为向运营商发布的统一出口 |
 | 假设 | 三方系统具备在关键节点集成哈希计算SDK与API调用的能力 |
-| 假设 | CSPS 审核系统与媒体资源库可开放对接接口，关联 MA码与哈希记录 |
-| 假设 | 广电总局备案系统可对接 MA码签发与哈希绑定 |
+| 假设 | CSPS 审核系统与媒体资源库可开放对接接口，关联 CC码与哈希记录 |
+| 假设 | 广电总局备案系统可对接 CC码签发与哈希绑定 |
 | 依赖 | 联盟链/分布式账本基础设施可用 |
 | 依赖 | 授权转码中心具备转码后哈希重算与上链能力 |
 
diff --git a/0630-task.md b/0630-task.md
index c1e5733..cb02465 100644
--- a/0630-task.md
+++ b/0630-task.md
@@ -1,7 +1,7 @@
-# IPTV系统融合MA码 — 待补足任务清单
+# IPTV系统融合CC码 — 待补足任务清单
 
 > 生成日期：2026-06-30
-> 依据：`IPTV系统融合MA码方案介绍.md` 与现有 TCS-IPTV 代码库对比分析
+> 依据：`IPTV系统融合CC码方案介绍.md` 与现有 TCS-IPTV 代码库对比分析
 > 整体匹配度：约 85%
 
 ---
@@ -45,7 +45,7 @@
 
 - `tcs-iptv/internal/chain/chain.go` — `Client` 接口新增 `MergeMA` / `SplitMA` 方法
 - `tcs-iptv/internal/chain/memory.go` / `persistent.go` — 实现合并/拆分逻辑
-- `tcs-iptv/internal/service/service.go` — 新增 `MergeMACodes` / `SplitMACode` 业务方法
+- `tcs-iptv/internal/service/service.go` — 新增 `MergeCCCodes` / `SplitCCCode` 业务方法
 - `tcs-iptv/internal/api/handlers.go` — 新增 HTTP 路由
 - `tcs-iptv/internal/model/model.go` — 新增合并/拆分请求与结果模型
 
diff --git a/1-prd-IPTV.md b/1-prd-IPTV.md
index 19d4ba7..fa625e0 100644
--- a/1-prd-IPTV.md
+++ b/1-prd-IPTV.md
@@ -11,7 +11,7 @@
 
 ### 1.1 产品定位
 
-TCS-IPTV 是一套架设在 **内容提供商（CP）、审核和监管部门、运营商** 三方现有系统之上的**内容可信身份映射层**。它通过"MA码（监管身份）+ 哈希码（技术指纹）"双锚定机制，让每一条 IPTV 内容拥有全网唯一、不可篡改、可追溯的可信身份，实现"**审过即锁定，锁定即通行，通行可追溯**"。
+TCS-IPTV 是一套架设在 **内容提供商（CP）、审核和监管部门、运营商** 三方现有系统之上的**内容可信身份映射层**。它通过"CC码（监管身份）+ 哈希码（技术指纹）"双锚定机制，让每一条 IPTV 内容拥有全网唯一、不可篡改、可追溯的可信身份，实现"**审过即锁定，锁定即通行，通行可追溯**"。
 
 一句话定位：**不替代任何现有系统，只在三方之上加一层"可信锁"，把"是谁、是不是、在哪里"三个问题一次性解决。**
 
@@ -19,11 +19,11 @@ TCS-IPTV 是一套架设在 **内容提供商（CP）、审核和监管部门、
 
 | 现状痛点 | 根因 | TCS-IPTV 的解法 |
 |---------|------|----------------|
-| 同一内容反复审核，边际成本不降 | 三方编码体系割裂，无法互认 | MA码+哈希一次锁定，跨省凭证复用 |
+| 同一内容反复审核，边际成本不降 | 三方编码体系割裂，无法互认 | CC码+哈希一次锁定，跨省凭证复用 |
 | 版本替换、换壳重发难识别 | 缺乏内容级技术指纹 | 文件哈希比特级锁定 + 感知哈希跨格式识别 |
-| 违规下架指令逐层翻译，响应滞后 | 编码不互通，需人工逐层映射 | 一个MA码自动翻译为三方下架指令，秒级同步 |
-| 跨省跨运营商复用要重走全流程 | 审核结果无法跨域信任 | 凭MA码+哈希证书快速准入，审核简化为抽检 |
-| 三方数据对账差异大 | 统计口径不统一 | 以MA码为统一维度聚合，口径一致 |
+| 违规下架指令逐层翻译，响应滞后 | 编码不互通，需人工逐层映射 | 一个CC码自动翻译为三方下架指令，秒级同步 |
+| 跨省跨运营商复用要重走全流程 | 审核结果无法跨域信任 | 凭CC码+哈希证书快速准入，审核简化为抽检 |
+| 三方数据对账差异大 | 统计口径不统一 | 以CC码为统一维度聚合，口径一致 |
 
 ### 1.3 目标用户
 
@@ -40,8 +40,8 @@ TCS-IPTV 是一套架设在 **内容提供商（CP）、审核和监管部门、
 ### 2.1 产品目标
 
 - **G1 审播一致**：送审版=播出版，任何篡改秒级识别
-- **G2 一码通行**：一省过审，全网凭 MA码+哈希准入
-- **G3 精准溯源**：凭 MA码秒级定位三方系统与全链路状态
+- **G2 一码通行**：一省过审，全网凭 CC码+哈希准入
+- **G3 精准溯源**：凭 CC码秒级定位三方系统与全链路状态
 - **G4 数据可信**：播放量、结算、上报以统一标识聚合
 - **G5 最小侵入**：不改造三方现有系统，仅在关键节点嵌入校验
 
@@ -74,7 +74,7 @@ TCS-IPTV 是一套架设在 **内容提供商（CP）、审核和监管部门、
 **画像B — 审核和监管部门审核员/监管员（王主任）**
 - 职责：内容合规审核（CSPS）、违规处置、全网监管
 - 痛点：出问题难定位，下架指令逐层打电话翻译，慢且易漏
-- 期望：一个MA码看清全链路，一键下架全网生效
+- 期望：一个CC码看清全链路，一键下架全网生效
 
 **画像C — 运营商分发工程师（老李）**
 - 职责：CDN注入、EPG发布、数据上报
@@ -84,35 +84,35 @@ TCS-IPTV 是一套架设在 **内容提供商（CP）、审核和监管部门、
 ### 3.2 核心使用场景
 
 **场景1：内容首次送审与赋码（端到端正向流程）**
-小赵在 CP 媒资系统完成制作 → 用哈希SDK对母版计算哈希包 → 登录备案系统提交节目信息+哈希包 → 审核和监管部门审核通过、签发MA码并强绑定哈希 → 小赵拿到"MA码+哈希证书"。
+小赵在 CP 媒资系统完成制作 → 用哈希SDK对母版计算哈希包 → 登录备案系统提交节目信息+哈希包 → 审核和监管部门审核通过、签发CC码并强绑定哈希 → 小赵拿到"CC码+哈希证书"。
 > 痛点解法：让内容从源头就获得全网唯一、不可篡改的可信身份，为后续一切流转奠定基础。
 
 **场景2：内容入库发布（审核→媒资库→运营商）**
-送审文件验真通过 → CSPS审核合规 → 转码并绑定各版本哈希 → 合格内容进入媒体资源库 → 从媒体资源库携带MA码+哈希证书向运营商发布 → 运营商注入CDN前校验哈希 → 校验通过注入分发。
+送审文件验真通过 → CSPS审核合规 → 转码并绑定各版本哈希 → 合格内容进入媒体资源库 → 从媒体资源库携带CC码+哈希证书向运营商发布 → 运营商注入CDN前校验哈希 → 校验通过注入分发。
 > 痛点解法：保证"送审版=播出版"，转码多版本各自锁定，杜绝入库到分发环节的偷换。
 
 **场景3：跨省快速复用**
-小赵已在A省过审 → 向B省仅提交MA码+哈希证书（不传文件） → 系统三重校验（MA码有效+哈希一致+非黑名单） → B省快速准入，审核简化为合规抽检。
+小赵已在A省过审 → 向B省仅提交CC码+哈希证书（不传文件） → 系统三重校验（CC码有效+哈希一致+非黑名单） → B省快速准入，审核简化为合规抽检。
 > 痛点解法：跨省复用从"重走全流程15-30天"压缩到"验真+抽检3-5天"，CP边际成本大幅下降。
 
 **场景4：违规应急下架**
-王主任发现违规 → 下发"下架MA码第XXX号"单一指令 → 系统解析该MA码绑定的全部三方编码与CDN端点 → 自动翻译为媒资库撤除发布+运营商下架CDN资源 → 秒级全网同步。
+王主任发现违规 → 下发"下架CC码第XXX号"单一指令 → 系统解析该CC码绑定的全部三方编码与CDN端点 → 自动翻译为媒资库撤除发布+运营商下架CDN资源 → 秒级全网同步。
 > 痛点解法：下架响应从"2-24小时逐层人工翻译"升级为"一码下发、秒级全网生效"。
 
 **场景5：版本篡改识别**
-内容被剪辑/替换 → 哈希变化 → MA码与哈希绑定断裂 → 系统标记reaudit_required → 通过Merkle Tree定位被篡改的具体集数 → 阻断分发并触发重审。
+内容被剪辑/替换 → 哈希变化 → CC码与哈希绑定断裂 → 系统标记reaudit_required → 通过Merkle Tree定位被篡改的具体集数 → 阻断分发并触发重审。
 > 痛点解法：版本替换/换壳重发从"几乎无法识别"升级为"100%自动识别并定位到具体集"。
 
 **场景6：可信播放数据与自动分账结算（利益核心）**
-内容在多个运营商分发播出 → 各运营商以MA码为唯一维度上报播放数据 → 可信数据空间链上聚合，形成不可篡改的可信播放量 → 作为CP与运营商分账结算的统一依据 → 对账差异从15-30%降至5%以内，回款争议大幅减少。
+内容在多个运营商分发播出 → 各运营商以CC码为唯一维度上报播放数据 → 可信数据空间链上聚合，形成不可篡改的可信播放量 → 作为CP与运营商分账结算的统一依据 → 对账差异从15-30%降至5%以内，回款争议大幅减少。
 > 痛点解法：解决CP与运营商"播放量各执一词、分账扯皮、回款慢"的真金白银痛点。
 
 **场景7：违规责任精准界定与追责（权责对等）**
-出现违规内容需追责 → 监管按MA码调取全链路哈希存证 → 逐环节比对（CP送审哈希 / CSPS审核结论 / 转码版哈希 / 媒资库发布哈希 / 运营商注入哈希 / 终端抽检哈希）→ 精准定位"问题出在哪个环节、是哪一方改动" → 责任落到具体方与具体节点。
+出现违规内容需追责 → 监管按CC码调取全链路哈希存证 → 逐环节比对（CP送审哈希 / CSPS审核结论 / 转码版哈希 / 媒资库发布哈希 / 运营商注入哈希 / 终端抽检哈希）→ 精准定位"问题出在哪个环节、是哪一方改动" → 责任落到具体方与具体节点。
 > 痛点解法：终结CP、审核监管、运营商三方"互相甩锅"，实现权责对等、有据可查。
 
 **场景8：版权确权与维权举证（权利保护）**
-CP内容被盗版/换皮 → 凭MA码+哈希+上链时间戳形成不可抵赖的"谁先锁定谁有权"证据链 → 可直接用于侵权投诉与司法诉讼举证 → 系统识别盗版内容感知哈希与正版高度相似，辅助锁定侵权。
+CP内容被盗版/换皮 → 凭CC码+哈希+上链时间戳形成不可抵赖的"谁先锁定谁有权"证据链 → 可直接用于侵权投诉与司法诉讼举证 → 系统识别盗版内容感知哈希与正版高度相似，辅助锁定侵权。
 > 痛点解法：解决CP"被盗用拿不出有法律效力证据"的确权维权痛点。
 
 **场景9：追更与增量更新（效率提升）**
@@ -135,7 +135,7 @@ CP上链授权信息（信息网络传播权的地域/期限/平台范围）→
 ┌─────────────────────────────────────────────────────────────┐
 │  ① CP工作域      ② 审核监管域       ③ 运营商域               │
 │  哈希生成SDK     验真+CSPS对接      CDN注入校验               │
-│  送审申报        MA码签发引擎       终端抽检SDK               │
+│  送审申报        CC码签发引擎       终端抽检SDK               │
 │                  媒资库映射         数据上报                  │
 │                  监管大屏+应急下架                            │
 ├─────────────────────────────────────────────────────────────┤
@@ -150,7 +150,7 @@ CP上链授权信息（信息网络传播权的地域/期限/平台范围）→
 |------|------|--------|--------|---------|
 | F01 | 母版多维哈希生成SDK（文件/分段Merkle/感知） | CP工作域 | Must | 需求1 |
 | F02 | 送审申报与哈希上链 | CP工作域 | Must | 需求2 |
-| F03 | MA码签发与1:1强绑定 | 审核监管域 | Must | 需求3 |
+| F03 | CC码签发与1:1强绑定 | 审核监管域 | Must | 需求3 |
 | F04 | 送审文件验真 | 审核监管域 | Must | 需求4 |
 | F05 | CSPS审核对接与转码版哈希绑定 | 审核监管域 | Must | 需求5 |
 | F06 | 媒体资源库入库/发布与编码映射 | 审核监管域 | Must | 需求6 |
@@ -174,7 +174,7 @@ CP上链授权信息（信息网络传播权的地域/期限/平台范围）→
 ### 4.3 不在本期范围（Out of Scope）
 
 - OTT、手机APP等大小屏融合接入（规划至四期，需求19.4 为可扩展性预留）
-- 内容推荐、计费结算的业务逻辑（系统仅提供以MA码为维度的数据聚合，不做结算）
+- 内容推荐、计费结算的业务逻辑（系统仅提供以CC码为维度的数据聚合，不做结算）
 - CSPS审核算法本身的改造（系统仅对接其审核结论，不介入审核规则）
 
 ---
@@ -188,29 +188,29 @@ CP上链授权信息（信息网络传播权的地域/期限/平台范围）→
    → 哈希SDK计算哈希包（本地，不传原文件）
    → 送审申报（节目信息+哈希包）→ 获送审流水号
         │
-[审核监管] MA码签发引擎 审核通过 → 签发MA码 + 哈希1:1强绑定上链
-   → CP获"MA码+哈希证书"
+[审核监管] CC码签发引擎 审核通过 → 签发CC码 + 哈希1:1强绑定上链
+   → CP获"CC码+哈希证书"
         │
 [审核监管] 送审文件验真（哈希比对）
    → 匹配 → 进入CSPS合规审核
    → 转码 → 各版本哈希绑定（父子关系）
-   → 合格内容入媒体资源库（建立 媒资编码↔MA码↔哈希 映射）
+   → 合格内容入媒体资源库（建立 媒资编码↔CC码↔哈希 映射）
         │
-[审核监管→运营商] 从媒体资源库发布（携带MA码+哈希证书）
+[审核监管→运营商] 从媒体资源库发布（携带CC码+哈希证书）
         │
 [运营商] CDN注入校验（哈希比对）
    → 匹配 → 注入CDN + 生成分发编码 + 注册映射
    → EPG发布 → 用户点播
    → （可选）终端片段哈希抽检
         │
-[运营商] 以MA码为维度上报播放数据 → 可信空间统一聚合
+[运营商] 以CC码为维度上报播放数据 → 可信空间统一聚合
 ```
 
 ### 5.2 应急下架流程（逆向）
 
 ```
-[审核监管-监管主体] 下发"下架 MA码第XXX号"
-   → 可信空间解析MA码 → 查出全部三方编码+CDN端点
+[审核监管-监管主体] 下发"下架 CC码第XXX号"
+   → 可信空间解析CC码 → 查出全部三方编码+CDN端点
    → 自动翻译为：
         · 媒体资源库：撤除发布
         · 运营商：下架分发编码YYY + CDN资源ZZZ
@@ -225,7 +225,7 @@ CP上链授权信息（信息网络传播权的地域/期限/平台范围）→
 | CDN注入 | 哈希不匹配 | 拒绝注入，告警审核监管部门，暂停分发 |
 | 终端抽检 | 哈希不匹配 | 断流，切备用源，上报异常日志 |
 | 内容变更 | 哈希变化 | 绑定断裂，reaudit_required=true，触发重审 |
-| 换壳重发 | 哈希已存在 | 拒绝重复申报，关联原MA码 |
+| 换壳重发 | 哈希已存在 | 拒绝重复申报，关联原CC码 |
 
 ---
 
@@ -233,7 +233,7 @@ CP上链授权信息（信息网络传播权的地域/期限/平台范围）→
 
 | 操作 | 内容提供商 | 审核和监管部门 | 运营商 |
 |------|:---------:|:-------------:|:------:|
-| 签发MA码 | ✗ | ✅（仅监管主体） | ✗ |
+| 签发CC码 | ✗ | ✅（仅监管主体） | ✗ |
 | 注册哈希 | ✅（送审时） | ✅ | ✗ |
 | 验真查询 | ✅（自查） | ✅ | ✅ |
 | 映射管理 | ✅（本方） | ✅ | ✅（本方） |
@@ -257,10 +257,10 @@ CP上链授权信息（信息网络传播权的地域/期限/平台范围）→
 
 ### MVP 验收标准
 
-- CP可完成哈希生成→送审→获MA码全流程
+- CP可完成哈希生成→送审→获CC码全流程
 - 审核监管部门可完成验真→CSPS审核对接→媒资库入库→发布
 - 运营商可完成CDN注入校验→分发
-- 监管可完成按MA码查询全链路 + 一键应急下架（秒级生效）
+- 监管可完成按CC码查询全链路 + 一键应急下架（秒级生效）
 - 版本篡改可被100%识别并阻断
 
 ---
@@ -271,7 +271,7 @@ CP上链授权信息（信息网络传播权的地域/期限/平台范围）→
 |------|------|
 | 性能 | 下架响应分钟级；哈希验真接口实时返回 |
 | 兼容性 | 不改造CSPS、媒体资源库内部流程，仅通过映射层对接；保留三方自有编码 |
-| 安全 | MA码+哈希绑定不可篡改不可解绑；哈希本地计算不传原文件；关键操作链上存证 |
+| 安全 | CC码+哈希绑定不可篡改不可解绑；哈希本地计算不传原文件；关键操作链上存证 |
 | 合规 | 完全符合广电总局网络剧片发行许可及备案制度 |
 | 可扩展 | 支持网络剧/微短剧/网络电影/网络动画，可扩展至OTT/APP |
 
@@ -283,7 +283,7 @@ CP上链授权信息（信息网络传播权的地域/期限/平台范围）→
 |------|------|------|
 | 依赖 | 联盟链/分布式账本基础设施 | 一期完成选型与部署 |
 | 依赖 | CSPS与媒体资源库开放对接接口 | 提前与审核监管部门确认接口规范 |
-| 依赖 | 广电总局备案系统对接MA码签发 | 政策与技术双轨推进 |
+| 依赖 | 广电总局备案系统对接CC码签发 | 政策与技术双轨推进 |
 | 依赖 | 授权转码中心支持转码后哈希重算上链 | 纳入一期改造范围 |
 | 风险 | 三方系统改造意愿与排期 | 最小侵入设计 + 试点先行（广东/湖南） |
 | 风险 | 跨省信任机制的政策落地 | 与监管联合制定跨省复用规则 |
@@ -293,7 +293,7 @@ CP上链授权信息（信息网络传播权的地域/期限/平台范围）→
 ## 十、产品价值总结
 
 > TCS-IPTV 的核心不是让三方放弃自己的系统，而是在三方系统之上建立一层"可信身份映射层"——
-> 用 **MA码** 解决"是谁"的监管问题，用 **哈希码** 解决"是不是"的技术问题，用 **可信数据空间** 解决"在哪"的溯源问题。
+> 用 **CC码** 解决"是谁"的监管问题，用 **哈希码** 解决"是不是"的技术问题，用 **可信数据空间** 解决"在哪"的溯源问题。
 > 三者叠加，IPTV内容才能真正实现"审过即锁定，锁定即通行，通行可追溯"。
 >
 > 对监管：从"逐层翻译滞后"升级为"一码穿透、秒级响应"。
diff --git a/2-task-IPTV-MVP.md b/2-task-IPTV-MVP.md
index d60511f..3712346 100644
--- a/2-task-IPTV-MVP.md
+++ b/2-task-IPTV-MVP.md
@@ -15,7 +15,7 @@
 |---------|------|---------|:----:|
 | F01 | 母版多维哈希生成SDK | 需求1 | ✅ |
 | F02 | 送审申报与哈希上链 | 需求2 | ✅ |
-| F03 | MA码签发与1:1强绑定 | 需求3 | ✅ |
+| F03 | CC码签发与1:1强绑定 | 需求3 | ✅ |
 | F04 | 送审文件验真 | 需求4 | ✅ |
 | F05 | CSPS审核对接与转码版哈希绑定 | 需求5 | ✅ |
 | F06 | 媒体资源库入库/发布与编码映射 | 需求6 | ✅ |
@@ -184,7 +184,7 @@
 
 - [x] **T4.2 重复哈希识别（防换壳重发）**
   - 对应：需求2-AC3、需求15-AC5
-  - 验收：重复哈希被拦截并返回原 MA码
+  - 验收：重复哈希被拦截并返回原 CC码
   - ✅ 完成：HashExists 拦截，测试覆盖
 
 - [x] **T4.3 哈希值包完整性校验**
@@ -196,23 +196,23 @@
 
 ---
 
-### 工作包 5：MA码生成与签发（F03，模式B 自行发码）
+### 工作包 5：CC码生成与签发（F03，模式B 自行发码）
 
-- [x] **T5.0 MA码生成服务（号段管理 + 按规则发码）**
+- [x] **T5.0 CC码生成服务（号段管理 + 按规则发码）**
   - 目标：登记发码机构分配的码段，按内容类目原子发码，保证全局唯一
   - 对应：需求3-AC1~AC4、AC10
   - 验收：顺序唯一、并发不重号、号段耗尽报错、格式校验/解析
-  - ✅ 完成：`internal/macode`（Generator + Segment + MemoryStore + Parse），9项测试通过（含200并发无重号）
+  - ✅ 完成：`internal/cccode`（Generator + Segment + MemoryStore + Parse），9项测试通过（含200并发无重号）
 
 - [x] **T5.1 签发编排服务**
-  - 目标：审核通过后生成 MA码、调用 issueMA 签发并绑定，记录内容主表
+  - 目标：审核通过后生成 CC码、调用 issueMA 签发并绑定，记录内容主表
   - 对应：需求3-AC2、AC5、AC9
   - 验收：签发成功并绑定；主表信息完整
   - ✅ 完成：`service.ApproveAndIssue`（自动发码+强绑定），测试覆盖
 
-- [x] **T5.2 MA码+哈希证书生成**
+- [x] **T5.2 CC码+哈希证书生成**
   - 对应：需求3-AC7
-  - 验收：证书含 MA码与哈希，可被验真校验
+  - 验收：证书含 CC码与哈希，可被验真校验
   - ✅ 完成：Certificate 字段，测试覆盖
 
 - [ ] **T5.3 未赋码内容准入拦截**
@@ -241,15 +241,15 @@
 ### 工作包 7：CSPS 对接与转码版哈希（F05）
 
 - [ ] **T7.1 CSPS 审核结论对接适配器**
-  - 目标：与 CSPS 审核系统对接，关联审核结论至 MA码/哈希，不改造 CSPS
+  - 目标：与 CSPS 审核系统对接，关联审核结论至 CC码/哈希，不改造 CSPS
   - 对应：需求5-AC1、AC2
   - 验收：CSPS 结论可关联并查询；对接为外挂式不改 CSPS 流程；测试覆盖（含 Mock CSPS）
   - 依赖：T2.1、对接规范确认
 
 - [ ] **T7.2 转码版哈希绑定与父子关系**
-  - 目标：转码后各版本哈希绑定同一 MA码，建立母版-转码版父子关系
+  - 目标：转码后各版本哈希绑定同一 CC码，建立母版-转码版父子关系
   - 对应：需求5-AC3、AC4、AC5
-  - 验收：多转码版共享 MA码独立哈希；父子关系可查；测试覆盖
+  - 验收：多转码版共享 CC码独立哈希；父子关系可查；测试覆盖
   - 依赖：T7.1、T1.2
 
 ---
@@ -257,19 +257,19 @@
 ### 工作包 8：媒体资源库入库/发布与映射（F06）
 
 - [ ] **T8.1 媒资库入库与映射建立**
-  - 目标：审核合格内容入媒资库，建立"媒资编码↔MA码↔文件哈希↔转码版哈希"映射
+  - 目标：审核合格内容入媒资库，建立"媒资编码↔CC码↔文件哈希↔转码版哈希"映射
   - 对应：需求6-AC1、AC2
   - 验收：入库后映射可查；保留媒资自有编码；测试覆盖
   - 依赖：T7.2、T1.3
 
 - [ ] **T8.2 可发布状态门禁**
-  - 目标：未审核通过/未绑定 MA码的内容不得进入可发布状态
+  - 目标：未审核通过/未绑定 CC码的内容不得进入可发布状态
   - 对应：需求6-AC3
   - 验收：不合规内容无法发布；测试覆盖
   - 依赖：T8.1
 
 - [ ] **T8.3 发布携带证书校验**
-  - 目标：向运营商发布必须携带 MA码+哈希证书，否则拒绝
+  - 目标：向运营商发布必须携带 CC码+哈希证书，否则拒绝
   - 对应：需求6-AC4、AC5
   - 验收：缺证书发布被拒；测试覆盖
   - 依赖：T8.1
@@ -334,7 +334,7 @@
 
 ### 工作包 13：监管大屏与全链路查询（F10）
 
-- [x] **T13.1 按 MA码全链路状态查询接口**
+- [x] **T13.1 按 CC码全链路状态查询接口**
   - 对应：需求10、需求17-AC3
   - 验收：返回三方映射+CDN端点
   - ✅ 完成：`GET /api/v1/content/mappings`，端到端验证
@@ -342,14 +342,14 @@
 - [x] **T13.2 监管大屏前端**
   - 对应：需求10、需求11
   - 验收：可视化查询、验真、应急下架
-  - ✅ 完成：`web-console`（Vite+React18+AntD5），MA码查询/三方映射表/哈希验真/一键下架，`npm run build` 通过；浏览器端 Web Crypto HMAC 签名与后端一致
+  - ✅ 完成：`web-console`（Vite+React18+AntD5），CC码查询/三方映射表/哈希验真/一键下架，`npm run build` 通过；浏览器端 Web Crypto HMAC 签名与后端一致
 
 ---
 
 ### 工作包 14：违规应急下架（F11）
 
 - [ ] **T14.1 下架指令解析与翻译**
-  - 目标：单一 MA码指令解析出三方编码+CDN端点，翻译为各方下架动作
+  - 目标：单一 CC码指令解析出三方编码+CDN端点，翻译为各方下架动作
   - 对应：需求11-AC1、AC2、需求17-AC3
   - 验收：一码解析出全部映射；翻译正确；测试覆盖
   - 依赖：T8.1、T9.3
@@ -422,17 +422,17 @@ T0.* 基础设施
 | 2026-06-14 | T3.1-T3.3 哈希SDK | 文件哈希/Merkle/感知哈希/SDK封装，13项测试通过 | CTID 概念落地 model.Content |
 | 2026-06-14 | 环境 | psql 加入 PATH（~/.zshrc），Makefile 简化 | go vet/build/test 全绿 |
 | 2026-06-14 | 架构决策：MA发码模式B | 与发码机构合作拿码段，TCS自行发码 | 需求3 改写为"生成+签发"，新增 T5.0 |
-| 2026-06-14 | T5.0 MA码生成服务 | internal/macode：号段管理+原子发码+解析，9项测试（含200并发无重号） | 六段式 MA.156.{行业}.{机构}/{类目}/{年份}{序列} |
+| 2026-06-14 | T5.0 CC码生成服务 | internal/cccode：号段管理+原子发码+解析，9项测试（含200并发无重号） | 六段式 MA.156.{行业}.{机构}/{类目}/{年份}{序列} |
 | 2026-06-14 | T4.1-4.3 / T5.1-5.2 业务编排 | internal/service：送审→发码签发→验真，8项测试通过 | service 层完成，HTTP 路由后段接入 |
 | 2026-06-14 | WP7-10 业务编排 | CSPS对接/转码绑定/媒资库入库发布/CDN注入/版本重审/下架，service 层 + 16项测试 | distribution.go |
 | 2026-06-14 | WP4/9/13/14 HTTP接口 + 鉴权 | api-svc 11个路由 + HMAC鉴权中间件(T0.4)；端到端冒烟10步全绿 | scripts/e2e_smoke.sh |
-| 2026-06-14 | MA码持久化 | PostgresStore 号段原子分配（行级UPSERT），200并发零重号；api-svc 优先PG回退内存 | migrations/0002，解决重启丢号/多实例重号 |
+| 2026-06-14 | CC码持久化 | PostgresStore 号段原子分配（行级UPSERT），200并发零重号；api-svc 优先PG回退内存 | migrations/0002，解决重启丢号/多实例重号 |
 | 2026-06-14 | T13.2 监管大屏 | web-console（React18+AntD5）：查询/验真/下架，build通过 | Web Crypto HMAC 与后端一致；演示模式安全提示 |
 | 2026-06-14 | M5 集成测试 | api 集成测试5项全绿（全闭环/篡改拒绝/篡改定位/权限矩阵/下架时效） | 全仓60+测试通过，MVP 代码完成 |
-| 2026-06-14 | 集级粒度补齐 | 一剧一码+集级哈希绑定+集级子标识(MA码#E07)+按集验真；新增 verify-episode/episodes 接口 | 需求3增AC11-13，migration 0003，3项集级测试通过，端到端验证 |
+| 2026-06-14 | 集级粒度补齐 | 一剧一码+集级哈希绑定+集级子标识(CC码#E07)+按集验真；新增 verify-episode/episodes 接口 | 需求3增AC11-13，migration 0003，3项集级测试通过，端到端验证 |
 | 2026-06-14 | 全流程演示前端 | web-console 新增"全流程演示"Tab：七步流水线一键执行+双锚定展示+篡改/下架按钮 | FlowDemo.jsx，四角色签名 |
 | 2026-06-14 | 流程顺序修正 | 改为"先审核后发码"（CSPS审核前移，发码加审核门禁） | 需求3-AC2，全栈+测试+脚本同步 |
-| 2026-06-14 | 集级面板 | 全流程页新增集级面板：各集独立哈希+集级子标识(MA码#E07)+按集验真/模拟篡改 | FlowDemo 集级表格 |
+| 2026-06-14 | 集级面板 | 全流程页新增集级面板：各集独立哈希+集级子标识(CC码#E07)+按集验真/模拟篡改 | FlowDemo 集级表格 |
 | 2026-06-14 | 多角色工作台 | RoleDesk：CP/审核监管/运营商 独立工作台+待办队列+全局看板，内容在各方桌面真实流转 | 新增 reviews/list 队列接口 + StatusIssued 状态 |
 | 2026-06-14 | 监管片库 | RoleDesk 新增"监管片库"Tab：全片库列表+状态筛选+应急下架+三方映射/集级钻取详情 | LibraryDesk，content.file_hash 透出 |
 | 2026-06-14 | 集级下架 | 子集级精准下架（RevokeEpisode），只下架某集不影响整剧；片库详情按集下架 | model.HashBinding.Revoked，TestEpisodeTakedown |
diff --git a/4-task-IPTV-三期.md b/4-task-IPTV-三期.md
index cdcb912..ebbeaf4 100644
--- a/4-task-IPTV-三期.md
+++ b/4-task-IPTV-三期.md
@@ -24,7 +24,7 @@
 
 | 层 | 增量选型 | 说明 |
 |----|---------|------|
-| 发码 | macode PostgresStore 生产化 + 多机构号段 | 多省机构节点号段管理 |
+| 发码 | cccode PostgresStore 生产化 + 多机构号段 | 多省机构节点号段管理 |
 | 高可用 | PG Patroni 主从、Redis Cluster、链多节点 | RPO/RTO 达标 |
 | 性能 | 压测（k6/wrk）、缓存优化、读写分离 | 万级 QPS 网关解析 |
 | 监管 | 数据上报安全交换网关、全国监管大屏 | 对接广电总局专网 |
@@ -60,7 +60,7 @@
   - 目标：号段分配多实例原子、不丢不重
   - 对应：需求3-AC4
   - 验收：PostgresStore 行锁原子分配（二期已实现 200 并发零重号）
-  - ✅ 完成：复用二期 macode.PostgresStore
+  - ✅ 完成：复用二期 cccode.PostgresStore
 
 ### 工作包 C：全国节点扩展与接入
 
diff --git a/5-task-IPTV-四期.md b/5-task-IPTV-四期.md
index 060d567..76234a2 100644
--- a/5-task-IPTV-四期.md
+++ b/5-task-IPTV-四期.md
@@ -131,7 +131,7 @@
 
 **新增代码**：
 - `internal/model/rights.go`：ScreenType、ParsedMA、ResolveResult、ScanVerifyResult、UserRights、PurchaseRecord、CrossScreenRightsResult
-- `internal/service/phase4.go`：ParseMACode、Resolve、ScanVerify、RecordPurchase、VerifyCrossScreenRights
+- `internal/service/phase4.go`：ParseCCCode、Resolve、ScanVerify、RecordPurchase、VerifyCrossScreenRights
 - `internal/api/handlers.go`：4 个端点 + 路由注册
 - `internal/service/phase4_test.go`：18 个单测，全绿
 
diff --git a/TCS-IPTV-系统说明文档.md b/TCS-IPTV-系统说明文档.md
index 821352a..1d793d3 100644
--- a/TCS-IPTV-系统说明文档.md
+++ b/TCS-IPTV-系统说明文档.md
@@ -124,7 +124,7 @@ CP 送审            监管发码签发          CSPS 审核 / 媒资        发
                                         │ HMAC-SHA256 鉴权
    ┌────────────────────────── api-svc :8080（业务编排）──────────────────────────┐
    │ service：送审/审核/发码/入库/发布/注入/下架/分账/追责/确权/授权/跨省/解析/权益 │
-   │ macode：六段式发码与号段（PG 行锁防重号） │ hash：SHA256/Merkle/感知哈希       │
+   │ cccode：六段式发码与号段（PG 行锁防重号） │ hash：SHA256/Merkle/感知哈希       │
    └───────────────┬─────────────────────────────────────┬─────────────────────────┘
                    │ chain.Client 接口                     │
         ┌──────────┴──────────┐                  ┌─────────┴─────────┐
@@ -147,7 +147,7 @@ tcs-iptv/
 │   └── console-bff/    # 监管控制台 BFF（:8090）
 ├── internal/
 │   ├── hash/           # 哈希核心（SHA256/Merkle/感知哈希）
-│   ├── macode/         # MA码生成/解析/号段（含 PG 存储）
+│   ├── cccode/         # CC码生成/解析/号段（含 PG 存储）
 │   ├── chain/          # 可信数据空间抽象 + MemoryChain
 │   ├── service/        # 业务编排（含 phase4.go 大小屏融合）
 │   ├── playback/       # 播放聚合与分账
@@ -362,7 +362,7 @@ call ak-operator sk-operator POST /rights/verify \
 | 指标 | 状况 |
 |------|------|
 | 测试用例 | 100+（含四期 18 个新单测），全部通过 |
-| 核心覆盖率 | playback 100% / hash 88% / service 85% / macode 75% |
+| 核心覆盖率 | playback 100% / hash 88% / service 85% / cccode 75% |
 | `go build ./...` / `go vet` | 通过 |
 | 前端构建 | 通过 |
 | 端到端冒烟 | 一期 → 四期（后端可代码部分）全相位通过 |
diff --git a/docs/0-req-IPTV.md b/docs/0-req-IPTV.md
index a19eb95..a00e528 100644
--- a/docs/0-req-IPTV.md
+++ b/docs/0-req-IPTV.md
@@ -9,7 +9,7 @@
 
 ## 引言
 
-本需求文档定义 TCS-IPTV（Trusted Content System for IPTV）内容可信锁定系统的功能性与非功能性需求。系统通过"MA码（监管身份）+ 哈希码（技术指纹）"双锚定机制，在 CP（内容供应商）、IPTV 集成播控平台、运营商（分发网络）三方现有系统之上建立一层"可信身份映射层"，实现 IPTV 内容"审过即锁定，锁定即通行，通行可追溯"。
+本需求文档定义 TCS-IPTV（Trusted Content System for IPTV）内容可信锁定系统的功能性与非功能性需求。系统通过"CC码（监管身份）+ 哈希码（技术指纹）"双锚定机制，在 CP（内容供应商）、IPTV 集成播控平台、运营商（分发网络）三方现有系统之上建立一层"可信身份映射层"，实现 IPTV 内容"审过即锁定，锁定即通行，通行可追溯"。
 
 本系统的核心约束是：**不替代三方现有系统**，仅在关键节点（送审、入库、分发、播放）以最小侵入方式嵌入校验能力，并通过映射层统一对接。
 
@@ -23,8 +23,8 @@
 | CP | Content Provider | 内容供应商 |
 | 播控平台 | — | IPTV 集成播控平台 |
 | 运营商 | — | IPTV 分发网络运营方（如中国电信、中国移动） |
-| MA码 | — | 监管身份主键，由广电总局/省局签发（如网络剧片发行许可证号/备案号） |
-| CTID | Content Twin ID | 内容孪生标识，由 MA码+哈希+版本+Merkle根 构成的唯一标识 |
+| CC码 | — | 监管身份主键，由广电总局/省局签发（如网络剧片发行许可证号/备案号） |
+| CTID | Content Twin ID | 内容孪生标识，由 CC码+哈希+版本+Merkle根 构成的唯一标识 |
 | 文件哈希 | File Hash | SHA-256 算法，比特级敏感，精确锁定某版本文件 |
 | 感知哈希 | Perceptual Hash | aHash/dHash/pHash，容忍转码压缩，跨格式识别同一内容 |
 | Merkle Tree | — | 分段聚合哈希树，用于多集/长内容的分段定位 |
@@ -39,7 +39,7 @@
 
 | 角色 | 描述 | 核心职责 |
 |------|------|----------|
-| 监管方 | 广电总局 / 省级广电局 | 签发 MA码、注册哈希、验真查询、映射管理、应急下架 |
+| 监管方 | 广电总局 / 省级广电局 | 签发 CC码、注册哈希、验真查询、映射管理、应急下架 |
 | CP | 内容供应商 | 生产内容、计算哈希、送审申报、注册本方映射 |
 | 播控平台 | IPTV 集成播控方 | 送审验真、合规审核、转码授权、EPG编排、注册本方映射、执行下架指令 |
 | 运营商 | IPTV 分发网络方 | CDN注入校验、EPG发布、终端播放、数据上报、注册本方映射、执行下架指令 |
@@ -72,24 +72,24 @@
 
 1. WHEN CP 提交送审申报，THE 系统 SHALL 接收节目信息（标题、集数、时长、分辨率）、片花、海报、剧本及哈希值包。
 2. WHEN 哈希值包提交成功，THE 系统 SHALL 将哈希存证至可信数据空间并返回唯一送审流水号。
-3. WHEN CP 提交的内容哈希在可信数据空间中已存在，THE 系统 SHALL 拒绝重复申报，并将该申报关联至已存在哈希对应的原 MA码。
+3. WHEN CP 提交的内容哈希在可信数据空间中已存在，THE 系统 SHALL 拒绝重复申报，并将该申报关联至已存在哈希对应的原 CC码。
 4. THE 系统 SHALL 仅接收哈希值包，且 SHALL NOT 要求 CP 上传原始内容文件。
 5. IF 哈希值包格式不完整（缺少文件哈希或 Merkle根），THEN THE 系统 SHALL 拒绝申报并提示缺失字段。
 
 ---
 
-### 需求 3：MA码签发与强绑定（监管端）
+### 需求 3：CC码签发与强绑定（监管端）
 
-**User Story:** 作为监管方，我希望在审核通过后签发 MA码并将其与送审哈希包强绑定，以便建立内容的合法监管身份。
+**User Story:** 作为监管方，我希望在审核通过后签发 CC码并将其与送审哈希包强绑定，以便建立内容的合法监管身份。
 
 #### 验收标准
 
-1. WHEN 监管方对送审内容审核通过，THE MA码签发引擎 SHALL 签发 MA码（网络剧片发行许可证号或备案号）。
-2. WHEN MA码签发，THE 系统 SHALL 将 MA码与送审哈希包以 1:1 关系写入可信数据空间，且该绑定 SHALL NOT 可被解绑。
-3. THE 系统 SHALL 仅允许监管节点调用 MA码签发功能（issueMA）；IF 非监管节点调用，THEN THE 系统 SHALL 拒绝并返回权限错误。
-4. WHEN MA码签发完成，THE 系统 SHALL 向 CP 发放"MA码+哈希证书"。
-5. WHILE 内容未取得 MA码及哈希证书，THE 系统 SHALL NOT 允许该内容进入播控平台审核流程。
-6. WHEN MA码绑定写入，THE 系统 SHALL 记录签发方、签发日期、MA类型、内容标题、集数等内容主表信息。
+1. WHEN 监管方对送审内容审核通过，THE CC码签发引擎 SHALL 签发 CC码（网络剧片发行许可证号或备案号）。
+2. WHEN CC码签发，THE 系统 SHALL 将 CC码与送审哈希包以 1:1 关系写入可信数据空间，且该绑定 SHALL NOT 可被解绑。
+3. THE 系统 SHALL 仅允许监管节点调用 CC码签发功能（issueMA）；IF 非监管节点调用，THEN THE 系统 SHALL 拒绝并返回权限错误。
+4. WHEN CC码签发完成，THE 系统 SHALL 向 CP 发放"CC码+哈希证书"。
+5. WHILE 内容未取得 CC码及哈希证书，THE 系统 SHALL NOT 允许该内容进入播控平台审核流程。
+6. WHEN CC码绑定写入，THE 系统 SHALL 记录签发方、签发日期、MA类型、内容标题、集数等内容主表信息。
 
 ---
 
@@ -99,8 +99,8 @@
 
 #### 验收标准
 
-1. WHEN CP 向播控平台送审（提交 MA码、送审文件、授权链文件），THE 验真模块 SHALL 计算送审文件哈希。
-2. WHEN 送审文件哈希与可信数据空间中 MA码绑定的哈希匹配，THE 系统 SHALL 确认为正版过审内容并允许进入内容审核流程。
+1. WHEN CP 向播控平台送审（提交 CC码、送审文件、授权链文件），THE 验真模块 SHALL 计算送审文件哈希。
+2. WHEN 送审文件哈希与可信数据空间中 CC码绑定的哈希匹配，THE 系统 SHALL 确认为正版过审内容并允许进入内容审核流程。
 3. IF 送审文件哈希与绑定哈希不匹配，THEN THE 系统 SHALL 直接退回该送审，并标记为"疑似版本替换"。
 4. WHEN 验真执行，THE 系统 SHALL 通过哈希验真接口查询可信数据空间，返回 valid、bound_hash、submitted_hash、match、version 等字段。
 
@@ -114,20 +114,20 @@
 
 1. WHEN 送审文件验真通过，THE 播控平台 SHALL 对内容执行合规审核（政治、色情、暴力等维度）。
 2. WHEN 内容审核通过且需要转码，THE 系统 SHALL 由授权转码中心执行转码，并在转码后重新计算各版本（如 H.264/H.265/4K/HD/SD）文件哈希。
-3. WHEN 转码版哈希生成，THE 系统 SHALL 将转码版哈希与 MA码绑定并写入可信数据空间，且 SHALL 与原母版哈希建立父子关系。
-4. THE 系统 SHALL 允许同一 MA码绑定多个转码版哈希记录，各转码版 SHALL 共享同一 MA码但拥有独立哈希记录。
+3. WHEN 转码版哈希生成，THE 系统 SHALL 将转码版哈希与 CC码绑定并写入可信数据空间，且 SHALL 与原母版哈希建立父子关系。
+4. THE 系统 SHALL 允许同一 CC码绑定多个转码版哈希记录，各转码版 SHALL 共享同一 CC码但拥有独立哈希记录。
 
 ---
 
 ### 需求 6：EPG编排与编码映射（播控端）
 
-**User Story:** 作为播控平台，我希望在保留自有审核流水号的同时建立其与 MA码、哈希的映射关系，以便对接监管而不改造现有系统。
+**User Story:** 作为播控平台，我希望在保留自有审核流水号的同时建立其与 CC码、哈希的映射关系，以便对接监管而不改造现有系统。
 
 #### 验收标准
 
 1. WHEN 内容纳入 EPG，THE 播控平台 SHALL 保留其自有审核流水号。
-2. WHEN 内容入库，THE 系统 SHALL 在可信数据空间建立"播控流水号 ↔ MA码 ↔ 文件哈希 ↔ 转码版哈希"的映射关系。
-3. WHEN 播控平台向运营商分发内容，THE 系统 SHALL 要求分发数据携带 MA码及哈希证书；IF 未携带，THEN THE 系统 SHALL 拒绝分发。
+2. WHEN 内容入库，THE 系统 SHALL 在可信数据空间建立"播控流水号 ↔ CC码 ↔ 文件哈希 ↔ 转码版哈希"的映射关系。
+3. WHEN 播控平台向运营商分发内容，THE 系统 SHALL 要求分发数据携带 CC码及哈希证书；IF 未携带，THEN THE 系统 SHALL 拒绝分发。
 4. THE 播控平台 SHALL 仅能管理本方（broadcast）的映射记录。
 
 ---
@@ -139,7 +139,7 @@
 #### 验收标准
 
 1. WHEN 运营商接收播控平台分发的内容并准备注入 CDN，THE 注入校验模块 SHALL 计算注入文件哈希。
-2. WHEN 注入文件哈希与可信数据空间中 MA码绑定的哈希匹配，THE 系统 SHALL 允许注入 CDN 并生成分发编码。
+2. WHEN 注入文件哈希与可信数据空间中 CC码绑定的哈希匹配，THE 系统 SHALL 允许注入 CDN 并生成分发编码。
 3. IF 注入文件哈希与绑定哈希不匹配，THEN THE 系统 SHALL 拒绝注入，触发告警并退回播控平台，同时暂停该内容分发。
 4. WHEN 注入成功，THE 系统 SHALL 在可信数据空间注册运营商（operator）映射记录（分发编码、CDN端点）。
 
@@ -160,35 +160,35 @@
 
 ### 需求 9：统一维度数据上报与聚合
 
-**User Story:** 作为监管方，我希望三方播放与业务数据以 MA码为统一维度聚合，以便获得口径一致的可信数据。
+**User Story:** 作为监管方，我希望三方播放与业务数据以 CC码为统一维度聚合，以便获得口径一致的可信数据。
 
 #### 验收标准
 
-1. WHEN 运营商上报播出数据，THE 系统 SHALL 以 MA码为统一维度组织数据。
-2. THE 可信数据空间 SHALL 按 MA码聚合 CP 播放量、播控审核量、运营商分发量，并保证各方数据口径一致。
-3. WHEN 数据聚合完成，THE 系统 SHALL 提供按 MA码查询的统一数据视图。
+1. WHEN 运营商上报播出数据，THE 系统 SHALL 以 CC码为统一维度组织数据。
+2. THE 可信数据空间 SHALL 按 CC码聚合 CP 播放量、播控审核量、运营商分发量，并保证各方数据口径一致。
+3. WHEN 数据聚合完成，THE 系统 SHALL 提供按 CC码查询的统一数据视图。
 
 ---
 
 ### 需求 10：全生命周期监管查询（监管端）
 
-**User Story:** 作为监管方，我希望通过监管大屏按 MA码查询内容全链路状态，以便实现精准溯源。
+**User Story:** 作为监管方，我希望通过监管大屏按 CC码查询内容全链路状态，以便实现精准溯源。
 
 #### 验收标准
 
-1. WHEN 监管方按 MA码查询，THE 监管大屏 SHALL 返回内容当前所在播控平台、当前所在运营商 CDN、当前哈希版本是否最新。
-2. WHEN 监管方查询内容历史，THE 系统 SHALL 返回该 MA码的历史版本变更记录。
-3. THE 监管大屏 SHALL 支持监管方按 MA码穿透查询三方系统的对应编码。
+1. WHEN 监管方按 CC码查询，THE 监管大屏 SHALL 返回内容当前所在播控平台、当前所在运营商 CDN、当前哈希版本是否最新。
+2. WHEN 监管方查询内容历史，THE 系统 SHALL 返回该 CC码的历史版本变更记录。
+3. THE 监管大屏 SHALL 支持监管方按 CC码穿透查询三方系统的对应编码。
 
 ---
 
 ### 需求 11：违规应急下架（监管端）
 
-**User Story:** 作为监管方，我希望下发单一 MA码下架指令即可触发全网下架，以便实现秒级应急响应而无需逐层人工翻译。
+**User Story:** 作为监管方，我希望下发单一 CC码下架指令即可触发全网下架，以便实现秒级应急响应而无需逐层人工翻译。
 
 #### 验收标准
 
-1. WHEN 监管方下发"下架 MA码 第XXX号"指令，THE 系统 SHALL 解析该 MA码并查询其绑定的所有三方编码及 CDN端点。
+1. WHEN 监管方下发"下架 CC码 第XXX号"指令，THE 系统 SHALL 解析该 CC码并查询其绑定的所有三方编码及 CDN端点。
 2. WHEN 下架指令解析完成，THE 系统 SHALL 自动将指令翻译为播控平台下架（审核流水号）与运营商下架（分发编码、CDN资源）的执行动作。
 3. THE 系统 SHALL 在接收下架指令后秒级同步至全网三方系统，且 SHALL NOT 要求人工逐层翻译。
 4. THE 系统 SHALL 仅允许监管方下发应急下架指令；播控平台与运营商 SHALL 仅执行指令而无下架发起权限。
@@ -201,7 +201,7 @@
 
 #### 验收标准
 
-1. WHEN 内容发生任意帧级变动导致哈希变化，THE 系统 SHALL 判定原 MA码与哈希的绑定断裂。
+1. WHEN 内容发生任意帧级变动导致哈希变化，THE 系统 SHALL 判定原 CC码与哈希的绑定断裂。
 2. WHEN 绑定断裂，THE 系统 SHALL 在版本变更表中记录变更原因、原哈希、新哈希，并将 reaudit_required 置为 true。
 3. WHEN 单集内容被替换，THE 系统 SHALL 通过 Merkle Tree 重新计算该集哈希并定位被篡改的具体集数，且 SHALL NOT 要求全量重审。
 4. WHILE 重审未通过，THE 系统 SHALL NOT 允许变更后的内容进入分发流程。
@@ -210,12 +210,12 @@
 
 ### 需求 13：跨省复用快速准入
 
-**User Story:** 作为 CP，我希望在一省过审后凭 MA码+哈希证书在其他省份快速准入，以便降低跨省复用的边际成本。
+**User Story:** 作为 CP，我希望在一省过审后凭 CC码+哈希证书在其他省份快速准入，以便降低跨省复用的边际成本。
 
 #### 验收标准
 
-1. WHEN CP 持 A省签发的 MA码+哈希证书向 B省播控平台送审，THE 系统 SHALL 仅要求提交 MA码与哈希证书，且 SHALL NOT 要求重新提交内容文件。
-2. WHEN B省播控平台发起准入查询，THE 系统 SHALL 验证 MA码真实有效、哈希与原过审版一致、且内容不在黑名单中。
+1. WHEN CP 持 A省签发的 CC码+哈希证书向 B省播控平台送审，THE 系统 SHALL 仅要求提交 CC码与哈希证书，且 SHALL NOT 要求重新提交内容文件。
+2. WHEN B省播控平台发起准入查询，THE 系统 SHALL 验证 CC码真实有效、哈希与原过审版一致、且内容不在黑名单中。
 3. WHEN 三重校验通过，THE 系统 SHALL 允许 B省播控平台快速准入，并将内容审核简化为合规性抽检。
 4. WHEN B省准入完成，THE 系统 SHALL 生成 B省审核流水号并注册对应映射关系。
 
@@ -227,10 +227,10 @@
 
 #### 验收标准
 
-1. THE 系统 SHALL 仅允许监管方（广电总局/省局）执行签发 MA码、注册哈希、验真查询、映射管理、应急下架全部操作。
-2. THE 系统 SHALL 允许播控平台执行验真查询、本方映射管理、执行下架指令；且 SHALL NOT 允许其签发 MA码、注册哈希、发起下架。
-3. THE 系统 SHALL 允许运营商执行验真查询、本方映射管理、执行下架指令；且 SHALL NOT 允许其签发 MA码、注册哈希、发起下架。
-4. THE 系统 SHALL 允许 CP 在送审时注册哈希、执行自查验真、管理本方映射；且 SHALL NOT 允许其签发 MA码或发起下架。
+1. THE 系统 SHALL 仅允许监管方（广电总局/省局）执行签发 CC码、注册哈希、验真查询、映射管理、应急下架全部操作。
+2. THE 系统 SHALL 允许播控平台执行验真查询、本方映射管理、执行下架指令；且 SHALL NOT 允许其签发 CC码、注册哈希、发起下架。
+3. THE 系统 SHALL 允许运营商执行验真查询、本方映射管理、执行下架指令；且 SHALL NOT 允许其签发 CC码、注册哈希、发起下架。
+4. THE 系统 SHALL 允许 CP 在送审时注册哈希、执行自查验真、管理本方映射；且 SHALL NOT 允许其签发 CC码或发起下架。
 5. WHEN 任意角色尝试越权操作，THE 系统 SHALL 拒绝该操作并返回权限错误。
 
 ---
@@ -245,21 +245,21 @@
 2. IF CDN注入阶段哈希不匹配，THEN THE 系统 SHALL 拒绝注入、告警播控平台并暂停该内容分发。
 3. IF 终端抽检阶段哈希不匹配，THEN THE 系统 SHALL 断流、切换备用源并上报异常日志。
 4. WHEN 内容发生剪辑/修改，THE 系统 SHALL 要求重新计算哈希、提交变更申请并触发重新审核。
-5. WHEN CP 以同一哈希换壳重发，THE 系统 SHALL 识别哈希已存在并拒绝重复申报，同时关联原 MA码。
+5. WHEN CP 以同一哈希换壳重发，THE 系统 SHALL 识别哈希已存在并拒绝重复申报，同时关联原 CC码。
 
 ---
 
 ### 需求 16：可信数据空间存证与智能合约
 
-**User Story:** 作为系统，我希望通过联盟链与智能合约管理 MA码、哈希与映射的存证，以便保证数据不可篡改与可信。
+**User Story:** 作为系统，我希望通过联盟链与智能合约管理 CC码、哈希与映射的存证，以便保证数据不可篡改与可信。
 
 #### 验收标准
 
 1. THE 可信数据空间 SHALL 维护内容主表、哈希绑定表、三方编码映射表、版本变更表四类核心数据结构。
 2. THE 智能合约 SHALL 提供 issueMA（签发）、registerMapping（注册映射）、verifyHash（哈希校验）核心方法。
-3. WHEN registerMapping 被调用，IF 对应 MA码尚未签发，THEN THE 系统 SHALL 拒绝注册映射。
+3. WHEN registerMapping 被调用，IF 对应 CC码尚未签发，THEN THE 系统 SHALL 拒绝注册映射。
 4. THE 系统 SHALL 通过 Merkle Tree 存储多集内容的分段哈希，并支持按集定位篡改。
-5. THE 可信数据空间 SHALL 保证已写入的 MA码与哈希绑定记录不可篡改。
+5. THE 可信数据空间 SHALL 保证已写入的 CC码与哈希绑定记录不可篡改。
 
 ---
 
@@ -270,8 +270,8 @@
 #### 验收标准
 
 1. THE 系统 SHALL 提供哈希上链接口（POST /api/v1/content/register），供 CP 提交标题、集数、各集文件哈希、Merkle根、感知哈希、时长、分辨率、CP媒资ID，并返回送审流水号与状态。
-2. THE 系统 SHALL 提供哈希验真接口（GET /api/v1/content/verify），供播控/运营商按 MA码与文件哈希查询并返回 valid、bound_hash、submitted_hash、match、version、转码版列表。
-3. THE 系统 SHALL 提供映射查询接口（GET /api/v1/content/mappings），供应急下架按 MA码查询三方编码映射与 CDN端点。
+2. THE 系统 SHALL 提供哈希验真接口（GET /api/v1/content/verify），供播控/运营商按 CC码与文件哈希查询并返回 valid、bound_hash、submitted_hash、match、version、转码版列表。
+3. THE 系统 SHALL 提供映射查询接口（GET /api/v1/content/mappings），供应急下架按 CC码查询三方编码映射与 CDN端点。
 4. THE 系统 SHALL 对接口调用进行身份鉴权（如 Bearer Token）。
 
 ---
@@ -300,7 +300,7 @@
 
 #### 验收标准
 
-1. THE 系统 SHALL 保证 MA码与哈希的绑定记录一经写入不可篡改、不可解绑。
+1. THE 系统 SHALL 保证 CC码与哈希的绑定记录一经写入不可篡改、不可解绑。
 2. THE 系统 SHALL 保证哈希计算在 CP 本地完成，原始内容文件 SHALL NOT 上传至可信数据空间。
 3. THE 系统 SHALL 对所有关键操作（签发、注册、验真、下架）进行链上存证以支持审计。
 
@@ -311,10 +311,10 @@
 | 类别 | 内容 |
 |------|------|
 | 约束 | 不替代三方现有系统，仅建立"可信身份映射层" |
-| 约束 | MA码签发权与应急下架发起权仅归监管方 |
-| 约束 | MA码与哈希 1:1 强绑定，不可解绑 |
+| 约束 | CC码签发权与应急下架发起权仅归监管方 |
+| 约束 | CC码与哈希 1:1 强绑定，不可解绑 |
 | 假设 | 三方系统具备在关键节点集成哈希计算SDK与API调用的能力 |
-| 假设 | 广电总局备案系统可对接 MA码签发与哈希绑定 |
+| 假设 | 广电总局备案系统可对接 CC码签发与哈希绑定 |
 | 依赖 | 联盟链/分布式账本基础设施可用 |
 | 依赖 | 授权转码中心具备转码后哈希重算与上链能力 |
 
diff --git a/docs/CC码监管方案-业务版.md b/docs/CC码监管方案-业务版.md
new file mode 100644
index 0000000..6cfdde8
--- /dev/null
+++ b/docs/CC码监管方案-业务版.md
@@ -0,0 +1,677 @@
+# CC码视频监管系统方案
+
+> 面向业务管理层的方案说明
+> 编制日期：2026年7月
+
+---
+
+## 摘要
+
+CC码（广电内容编码）是广电总局推出的**强制性视频内容标识制度**，要求全网所有视频内容——包括影视剧、综艺、新闻、短视频、UGC用户创作——上线前必须取得CC码，所有视频平台必须接入CC码验证体系，**无码不得上线**。
+
+本方案采用**"双层架构"**实现CC码的全网监管：
+
+| 防线 | 机制 | 响应速度 | 覆盖范围 |
+|------|------|---------|---------|
+| **第一层：平台侧预防** | 在上传、播出、CDN、终端四个环节嵌入CC码验证，无码拦截、违规秒级下架 | **秒级** | 所有对接平台 |
+| **第二层：独立监控兜底** | 爬虫巡查+水印提取+指纹比对+AI语义识别，不依赖平台配合 | **分钟级** | 全网（含未对接平台、境外平台） |
+
+**关键设计要点**：
+
+- **UGC专项**：平台代理赋码（码段授权+实时赋码），分级检测（快速筛查→重点检测→深度检测），合理使用与二创界定
+- **直播专项**：频道/主播级赋码，播出中实时校验，分钟切片检测+秒级断流
+- **存量处置**：12个月过渡期，分批补码（头部3个月→一般6个月→全量12个月），过渡期内第二层重点巡查
+- **误判申诉**：48小时申诉+24小时审核，分级处置+人工兜底+白名单+秒级恢复
+- **水印嵌入**：CC码+平台代码+时间戳嵌入视频像素，不可见、抗压缩、抗裁剪，是全链路追溯的技术基础
+- **CC码生命周期**：申请→审核→有效→暂停→恢复/下架→过期，全程状态管理，变更可追溯
+- **组织保障**：5个团队约30~44人，7×24小时告警处理，平台考核与牌照续期挂钩
+
+**实施路线**：5个阶段，18个月完成全量上线——3个月持证平台秒级拦截，6个月UGC赋码+独立监控，9个月存量补码+直播监管，12个月全量运行，18个月运营优化。
+
+**核心价值**：从"人工巡查、天级发现、小时级下架"升级为"自动检测、秒级拦截、秒级全网下架"，实现全网全量视频内容的实时监管闭环。
+
+---
+
+## 一、政策背景与要解决的问题
+
+### 1.1 政策背景
+
+CC码（广电内容编码）是广电总局和相关部门推出的**强制性视频内容标识制度**，要求：
+
+- **所有视频内容**——包括影视剧、综艺、纪录片、新闻、短视频、UGC用户创作——上线前必须取得CC码
+- **所有视频平台**——包括持证平台、短视频平台、直播平台——必须接入CC码验证体系
+- **无码不得上线**：没有CC码的视频内容，平台不得提供上传、发布、传播服务
+
+> CC码相当于视频内容的"数字身份证"。与现有的网络剧片发行许可证制度**并行衔接**：影视剧既需要发行许可证，也需要CC码；UGC等不需要许可证的内容，只需CC码。CC码将监管范围从传统影视剧扩展到**全网所有视频内容**。
+
+### 1.2 现状痛点
+
+当前视频内容监管面临四个核心难题：
+
+| 痛点 | 说明 | 现状 |
+|------|------|------|
+| **发现晚** | 违规视频上线后，靠人工巡查或群众举报才发现 | 往往已经传播数天，造成不良影响 |
+| **下架慢** | 发现违规后，需要逐级通知各平台人工处理 | 从发现到全网下架通常需要数小时甚至数天 |
+| **追责难** | 视频被搬运、剪辑后，难以追溯原始来源 | 无法证明"这个视频是从哪个正版内容剪辑来的" |
+| **UGC难管** | 短视频平台日均上传量达数百万条，人工审核杯水车薪 | 大量违规内容混在UGC中传播 |
+
+### 1.3 我们的目标
+
+通过CC码制度+技术手段，实现：
+
+- **正向发码**：所有视频内容（含UGC）上线前取得CC码，无码不上线
+- **逆向监管**：在全网范围内自动发现、识别、处置违规视频内容
+- **秒级下架**：违规内容一经发现，秒级通知全网下架
+- **全量覆盖**：从影视剧到UGC短视频，从持证平台到境外平台，全覆盖、无死角
+
+---
+
+## 二、核心思路：两道防线
+
+我们采用**"预防为主，兜底为辅"**的双层设计，可以类比理解为**"门口安检 + 商场巡检"**：
+
+| 比喻 | 对应方案 | 作用 |
+|------|---------|------|
+| 门口安检 | 第一层：平台侧预防 | 在内容上传/播出时查验CC码，无码不让进 |
+| 商场巡检 | 第二层：独立监控 | 安检被绕过时，巡检员在全网巡查发现违规 |
+
+### 为什么需要两道防线
+
+- **只有第一层**：平台如果不配合（不装安检门），就完全失控
+- **只有第二层**：发现违规后还要等平台配合才能下架，时延不可控
+- **两层并行**：配合的平台秒级拦截，不配合的平台也能分钟级发现并处置
+
+> CC码作为强制要求，所有平台必须接入第一层。但行政强制不能保证100%执行到位，第二层独立监控作为技术兜底，确保"制度管得到的秒级管，制度暂时管不到的分钟级管"。
+
+---
+
+## 三、第一层：平台侧预防（秒级）
+
+### 3.1 工作方式
+
+在视频平台的四个关键环节嵌入CC码验证，类似"四道安检关卡"：
+
+| 关卡 | 在什么环节检查 | 检查什么 | 不通过怎么办 | 用户是否有感知 |
+|------|-------------|---------|------------|-------------|
+| **第一关：上传拦截** | 内容上传到平台时 | 有没有CC码、码是否合法 | 拒绝上传，提示先去备案（UGC由平台代理赋码，详见第五章） | 上传者看到提示，观众无感 |
+| **第二关：播出校验** | 观众点击播放时 | CC码是否还有效（是否已被下架） | 返回"该内容已下架" | 观众看到下架提示 |
+| **第三关：CDN注入校验** | 内容分发到CDN时 | 文件是否被篡改 | 拒绝分发，退回审核 | 观众无感 |
+| **第四关：终端抽检** | 观众播放过程中 | 播放的内容和登记的是否一致 | 自动断流，切换备用源 | 极偶尔的卡顿，基本无感 |
+
+### 3.2 秒级下架怎么实现
+
+当监管方决定下架某个内容时，只需一条指令：
+
+```
+监管方下达指令："下架 CC码 第XXX号"
+        │
+        │  系统自动查找该CC码关联的所有：
+        │  · 哪些平台有这个内容
+        │  · 哪些CDN缓存了这个内容
+        │  · 哪些运营商在分发这个内容
+        │
+        ▼  同时通知所有相关方（1秒内）
+        │
+   ┌────┼────────────┬────────────┬────────────┐
+   ▼    ▼            ▼            ▼            ▼
+ 平台A    平台B      运营商A       运营商B      CDN全网
+ 自动下架  自动下架   清除缓存     清除缓存    黑名单拦截
+ (1秒)    (1秒)      (1秒)        (1秒)       (1秒)
+```
+
+**关键点**：监管方只需说"下架这个CC码"，系统自动翻译成各平台、各CDN能理解的执行指令，不需要人工逐个通知。
+
+### 3.3 适用范围
+
+CC码是强制性要求，所有视频平台必须对接：
+
+| 平台类型 | 对接方式 | 效果 |
+|---------|---------|------|
+| IPTV集成播控平台 | 已有TCS-IPTV基础，天然对接 | 秒级拦截+秒级下架 |
+| 持证视频平台（爱奇艺/腾讯/优酷等） | 强制对接，行政要求 | 秒级拦截+秒级下架 |
+| 短视频平台（抖音/快手/B站等） | 强制对接，UGC批量发码（详见第五章） | 上传环节拦截+批量验证 |
+| 直播平台 | 强制对接，直播前预告赋码+播出中实时校验（详见第五章） | 播出环节秒级拦截 |
+| 中小视频平台 | 强制对接，分批过渡 | 过渡期内由第二层重点巡查 |
+| 境外平台 | 无法对接 | 依靠第二层检测+DNS封锁 |
+
+---
+
+## 四、第二层：独立监控兜底（分钟级）
+
+### 4.1 为什么需要第二层
+
+CC码虽是强制要求，但第一层仍有管不到的地方：
+
+| 场景 | 第一层为什么管不到 | 第二层怎么管 |
+|------|-----------------|------------|
+| 平台对接有过渡期 | 中小平台分批接入，过渡期内未对接 | 系统自动巡查全网，发现违规 |
+| 平台执行不到位 | 形式上对接但实际未严格执行 | 系统独立检测，不依赖平台 |
+| UGC剪辑搬运 | 剪辑后的新内容未重新赋码 | 通过内容比对，识别出是哪个正版内容的片段 |
+| 境外平台传播 | 管不了境外平台 | 检测发现后，走DNS封锁 |
+| 有人故意去水印 | 去掉水印后平台无法验证 | 用内容指纹识别，即使去水印也能认出来 |
+| 存量内容未补码 | 补码完成前的存量内容 | 重点巡查，发现违规立即处置 |
+
+### 4.2 工作方式
+
+第二层像一个**自动巡查系统**，分三步工作：
+
+**第一步：采集（发现视频）**
+
+| 采集方式 | 说明 | 覆盖范围 |
+|---------|------|---------|
+| 网络巡查 | 自动浏览各大视频网站，发现新上线的视频 | 主流视频平台、短视频平台、小网站 |
+| 直播录制 | 对电视直播频道实时录制片段 | 卫星频道、有线频道、网络直播 |
+| 群众举报 | 提供举报入口，接收群众举报的可疑链接 | 全网 |
+
+**第二步：检测（识别视频）**
+
+对采集到的视频，用三种手段逐步识别：
+
+| 检测手段 | 通俗解释 | 速度 | 能扛什么破坏 |
+|---------|---------|------|------------|
+| **提取CC码** | 类似扫描身份证 | 秒级 | 扛得住压缩、转码、裁剪 |
+| **内容指纹比对** | 类比人脸识别，即使换了衣服也能认出 | 毫秒级 | 扛得住剪辑、加滤镜、去水印 |
+| **AI语义理解** | 类比让人看视频说"这跟某某剧是同一部" | 分钟级 | 扛得住深度混剪、拼接 |
+
+三种手段层层递进：第一种认不出来就用第二种，第二种还不行就用第三种。
+
+**第三步：处置（告警+下架）**
+
+| 检测结果 | 处置方式 | 响应速度 |
+|---------|---------|---------|
+| 发现伪造/无码内容 | 紧急电话+短信通知监管方，要求平台立即下架 | 立即 |
+| 发现去水印传播 | 短信通知+自动发行政通知给平台 | 5分钟内 |
+| 发现疑似违规 | 纳入日报，人工研判 | 24小时内 |
+
+### 4.3 下架后的验证
+
+第二层还有一个重要职责——**验证下架是否真的执行了**：
+
+```
+监管方下达下架指令
+    │
+    ├── 第一层通知各平台下架（秒级）
+    │
+    └── 第二层验证下架效果（分钟级）
+        ├── 自动巡查该视频的URL → 还能访问吗？
+        ├── 已下架 → 记录确认
+        ├── 仍能访问 → 升级告警："XX平台未执行下架指令"
+        └── 持续监控 → 防止偷偷重新上架
+```
+
+---
+
+## 五、UGC短视频场景专项设计
+
+### 5.1 UGC为什么需要单独设计
+
+UGC短视频与影视剧有本质区别，不能简单套用同一套流程：
+
+| 维度 | 影视剧 | UGC短视频 |
+|------|--------|----------|
+| 日均上传量 | 几十~几百部 | 数百万条 |
+| 内容来源 | 专业机构制作 | 普通用户创作 |
+| 单条时长 | 30分钟~2小时 | 15秒~5分钟 |
+| 是否需要审核 | 严格审核 | 平台自查+抽检 |
+| 违规风险 | 较低（已审核） | 较高（实时上传） |
+
+### 5.2 UGC发码机制
+
+UGC不能要求每个用户都去广电总局申请CC码，需要设计**批量发码+平台代理**机制：
+
+```
+用户上传短视频
+    │
+    ├── 平台自动审核（AI初筛+人工复核）
+    │
+    ├── 审核通过 → 平台代理向CC码系统批量申请CC码
+    │   ├── 平台获得码段授权（广电总局分配号段给平台）
+    │   ├── 平台在号段内为每条UGC内容自动赋码
+    │   └── 赋码信息回传CC码系统备案
+    │
+    └── 审核不通过 → 拒绝发布
+```
+
+**关键设计**：
+
+| 机制 | 说明 |
+|------|------|
+| **码段授权** | 广电总局给各平台分配CC码号段，平台在号段内自行赋码 |
+| **平台代理** | 用户无需直接对接广电系统，平台代为赋码 |
+| **实时赋码** | 用户上传审核通过后秒级赋码，不影响上传体验 |
+| **回传备案** | 平台定期将赋码清单回传CC码系统，纳入监管 |
+| **码段管控** | 广电可随时收回或冻结平台码段，形成约束 |
+
+### 5.3 UGC检测策略
+
+UGC量巨大，不可能全量深度检测，采用**分级检测**策略：
+
+| 检测级别 | 触发条件 | 检测方式 | 处理速度 |
+|---------|---------|---------|---------|
+| **快速筛查** | 所有UGC | CC码元数据验证（有无码、码是否在有效号段内） | 毫秒级 |
+| **重点检测** | 疑似搬运正版内容 | 内容指纹比对（是否匹配已登记的影视剧指纹） | 秒级 |
+| **深度检测** | 疑似违规或高传播量内容 | 水印提取+AI语义分析 | 分钟级 |
+
+**如何判断"疑似搬运正版内容"**：
+
+```
+UGC视频上传
+    │
+    ├── 计算内容指纹（秒级）
+    │
+    ├── 与影视剧本纹库比对
+    │   ├── 指纹相似度>80% → 疑似搬运 → 进入重点检测
+    │   ├── 指纹相似度50~80% → 疑似二创 → 标记观察
+    │   └── 指纹相似度<50% → 原创内容 → 正常赋码
+    │
+    └── 分级处理
+        ├── 疑似搬运 → 提取水印 → 有CC码 → 正版授权？记录
+        │                       → 无水印 → 告警：疑似盗版搬运
+        └── 疑似二创 → 记录关联关系 → 纳入版权追踪
+```
+
+### 5.4 合理使用与二创界定
+
+并非所有使用正版素材的视频都是违规，需要区分**合理使用**和**侵权搬运**：
+
+| 类型 | 特征 | 处理方式 |
+|------|------|---------|
+| **原创内容** | 完全自主创作 | 正常赋码，正常传播 |
+| **合理使用（影评/解说）** | 使用少量片段+大量原创解说 | 正常赋码，标注引用来源 |
+| **二创混剪** | 基于正版素材的创意改编 | 赋码时标注"二创"，关联原始CC码 |
+| **侵权搬运** | 整片搬运或大段搬运，无原创加工 | 拒绝赋码，下架处理 |
+| **去水印搬运** | 去除水印后整片搬运 | 拒绝赋码，下架+追责 |
+
+> 界定标准由广电总局制定，系统提供技术识别能力，最终判定由人工审核确认。
+
+### 5.5 直播场景专项设计
+
+直播与点播有本质区别：直播是实时的，不能等审核完再播出。需要单独设计赋码和监管流程：
+
+**直播赋码机制**：
+
+| 直播类型 | 赋码方式 | 说明 |
+|---------|---------|------|
+| 卫视直播频道 | 频道级赋码 | 每个频道一个CC码，提前报备节目单 |
+| 网络直播（秀场/游戏等） | 主播级赋码 | 平台为主播分配CC码，主播实名绑定 |
+| 事件直播（赛事/演唱会等） | 活动级赋码 | 活动主办方提前申请CC码 |
+| 突发直播（新闻等） | 平台应急赋码 | 平台用码段内应急码，事后补审 |
+
+**直播监管流程**：
+
+```
+直播开始前
+    ├── 频道/主播/活动已赋CC码 → 正常开播
+    └── 未赋码 → 平台不得开播
+
+直播进行中
+    ├── 第一层：实时校验CC码状态（是否已被下架）
+    │   ├── CC码有效 → 继续播出
+    │   └── CC码已下架 → 秒级断流
+    │
+    └── 第二层：实时录制片段 → 水印提取 + 指纹比对
+        ├── 内容正常 → 继续监控
+        ├── 发现违规 → 秒级告警 + 断流指令
+        └── 发现无码直播 → 紧急告警 + 行政通知
+
+直播结束后
+    ├── 直播录像自动存档 → 补充检测
+    └── 发现违规片段 → 追溯处置
+```
+
+**关键设计**：
+
+| 机制 | 说明 |
+|------|------|
+| **频道/主播级赋码** | 不需要每场直播单独申请，一次赋码长期有效 |
+| **实时校验** | 播出过程中持续校验CC码状态，下架指令秒级生效 |
+| **片段录制** | 第二层对直播流按分钟切片录制，逐片检测 |
+| **应急码段** | 突发新闻等无法提前申请的场景，平台使用应急码段，事后补审 |
+| **录像存档** | 直播结束后录像自动存档，供事后追溯和补检 |
+
+### 5.6 水印嵌入机制
+
+前面多次提到"提取水印"和"去水印"，这里说明水印是怎么嵌入到视频中的：
+
+**什么时候嵌入**：
+
+| 内容类型 | 嵌入时机 | 由谁嵌入 |
+|---------|---------|---------|
+| 影视剧/专业内容 | CC码签发后、内容上线前 | 内容制作方在母版中嵌入 |
+| UGC短视频 | 平台赋码后、发布前 | 平台在转码环节自动嵌入 |
+| 直播内容 | 直播流编码环节 | 平台在编码器中实时嵌入 |
+| 存量补码内容 | 补码后重新转码时 | 平台在重新转码时嵌入 |
+
+**水印嵌入什么信息**：
+
+| 信息 | 说明 |
+|------|------|
+| CC码 | 内容的唯一标识 |
+| 平台代码 | 内容上线平台的标识 |
+| 时间戳 | 嵌入时间，用于追溯 |
+
+**水印特性**：
+
+| 特性 | 说明 |
+|------|------|
+| **不可见** | 嵌入在画面像素中，人眼看不到，不影响观看体验 |
+| **不可听** | 如有音频水印，嵌入在音频中，人耳听不到 |
+| **抗压缩** | 经过转码、压缩后仍可提取 |
+| **抗裁剪** | 画面裁剪后仍可部分提取 |
+| **多帧冗余** | 水印重复嵌入在多帧中，部分帧丢失不影响提取 |
+
+> 水印嵌入是CC码监管的技术基础。没有水印，第二层检测就无法识别视频内容的来源。广电总局应制定水印嵌入标准，所有平台和制作方按统一标准执行。
+
+---
+
+## 六、两层如何配合
+
+### 6.1 正常情况（大多数内容）
+
+**影视剧/专业内容**：
+```
+内容制作 → 送审取得CC码 → 上传平台（第一关验证通过）→ 平台审核 → 观众播放
+                                                                    │
+                                                              一切正常
+                                                           第二层不介入
+```
+
+**UGC短视频**：
+```
+用户创作 → 上传平台 → 平台审核 → 平台代理赋码 → 发布上线 → 观众播放
+                                                    │
+                                              一切正常
+                                           第二层快速筛查通过
+```
+
+### 6.2 异常情况（违规内容）
+
+| 场景 | 第一层 | 第二层 | 最终结果 |
+|------|--------|--------|---------|
+| 无CC码内容上传 | 第一关拦截，拒绝上传 | - | 内容根本不上线 |
+| UGC未赋码就发布 | 平台赋码流程异常，拦截 | - | 内容不上线，平台修复流程 |
+| 已下架内容被点播 | 第二关拦截，返回下架提示 | - | 观众看到下架提示 |
+| 平台过渡期未对接 | 管不到 | 爬虫发现→检测→告警→行政通知 | 分钟级发现，小时级下架 |
+| UGC搬运正版内容 | 赋码时指纹比对发现 | 重点检测→告警 | 秒级拦截上传 |
+| 正版内容被剪辑搬运 | 二创赋码时标注关联 | 指纹比对识别→判定是否合理使用 | 分钟级发现侵权 |
+| 有人故意去水印 | 验证不了 | 内容指纹识别→告警 | 分钟级发现，追责 |
+| 境外平台传播 | 管不到 | 检测发现→DNS封锁 | 天级处置 |
+| 存量内容未补码 | 过渡期内允许 | 重点巡查→发现违规立即处置 | 过渡期内重点监管 |
+
+### 6.3 下架指令的执行
+
+```
+监管方一条指令
+    │
+    ├──→ 第一层：秒级通知全网下架（平台+CDN）
+    │
+    └──→ 第二层：分钟级验证下架效果
+         ├── 确认下架 → 结案
+         └── 未下架 → 升级处理
+```
+
+---
+
+## 七、存量内容处置计划
+
+CC码制度实施后，全网已有海量存量视频没有CC码，必须制定明确的处置计划：
+
+### 7.1 存量内容分类处置
+
+| 内容类型 | 处置方式 | 时间要求 |
+|---------|---------|---------|
+| **头部热播内容**（各平台Top1000） | 优先补登记CC码 | 制度生效后3个月内 |
+| **一般影视剧/综艺** | 分批补登记 | 制度生效后6个月内 |
+| **长尾专业内容** | 平台批量补登记 | 制度生效后12个月内 |
+| **存量UGC** | 平台按码段批量赋码 | 制度生效后12个月内 |
+| **已下架/失效内容** | 不需要补码 | - |
+
+### 7.2 补码过渡期安排
+
+```
+制度生效
+    │
+    ├── 过渡期（12个月）
+    │   ├── 存量内容可继续在线，但必须分批补码
+    │   ├── 补码完成前，纳入第二层重点巡查
+    │   └── 过渡期内新发现违规的存量内容，立即下架
+    │
+    └── 过渡期结束
+        ├── 已补码内容 → 纳入正常监管流程
+        └── 未补码内容 → 强制下架，平台不得继续提供
+```
+
+### 7.3 存量补码的执行方式
+
+| 角色 | 职责 |
+|------|------|
+| 广电总局 | 发布补码指令，分配码段 |
+| 各平台 | 负责本平台存量内容的批量补登记 |
+| CC码系统 | 提供批量赋码接口，支持平台批量提交 |
+| 第二层监控 | 验证各平台补码进度，对未按时完成的重点巡查 |
+
+---
+
+## 八、误判申诉与恢复机制
+
+### 8.1 为什么需要申诉机制
+
+任何自动化检测都不可能100%准确。如果正常内容被误判为违规并下架，会影响平台正常运营和创作者权益，必须提供快速申诉和恢复通道。
+
+### 8.2 申诉流程
+
+```
+内容被下架/拦截
+    │
+    ├── 平台/创作者收到下架通知
+    │   通知包含：下架原因、CC码、检测证据
+    │
+    ├── 平台/创作者发起申诉（48小时内）
+    │   申诉渠道：CC码系统申诉接口 / 平台代申诉
+    │
+    ├── 申诉审核（24小时内）
+    │   ├── 自动复核：重新检测，确认是否误判
+    │   └── 人工复核：由审核人员判断
+    │
+    └── 申诉结果
+        ├── 申诉成功 → 立即恢复上线 → 记录误判案例 → 优化检测阈值
+        └── 申诉驳回 → 维持下架 → 告知驳回理由
+```
+
+### 8.3 误判防控措施
+
+| 措施 | 说明 |
+|------|------|
+| **分级处置** | 低置信度告警先标记观察，不直接下架；高置信度才下架 |
+| **人工兜底** | UGC二创、影评解说等灰色地带，必须人工审核确认 |
+| **阈值可调** | 指纹相似度阈值根据误判案例持续优化 |
+| **白名单机制** | 已确认的合理使用内容纳入白名单，避免重复误判 |
+| **申诉数据反哺** | 申诉案例用于训练检测模型，持续降低误判率 |
+
+### 8.4 恢复上线机制
+
+| 场景 | 恢复方式 | 速度 |
+|------|---------|------|
+| 申诉成功 | CC码状态恢复为"有效"，第一层播出校验自动放行 | 秒级 |
+| 申诉成功+CDN缓存 | CC码恢复+通知CDN清除下架标记 | 分钟级 |
+| 误批量下架 | 批量恢复CC码状态，批量通知平台 | 分钟级 |
+
+---
+
+## 九、实施计划
+
+### 9.1 分阶段路线
+
+> 以下时间线从**项目启动**起算。存量补码时间线从**CC码制度正式生效**起算（见第七章），两者可能存在时间差：制度生效前完成系统建设，制度生效后启动存量补码。
+
+| 阶段 | 时间 | 目标 |
+|------|------|------|
+| **第一阶段** | 3个月 | 第一层上线：监管API+秒级下架，对接IPTV+1~2家持证平台 |
+| **第二阶段** | 6个月 | 第二层起步版上线+UGC赋码机制上线，对接短视频平台 |
+| **第三阶段** | 9个月 | 存量补码启动+直播监管上线+GPU加速检测 |
+| **第四阶段** | 12个月 | 全量上线：全网平台对接+存量补码完成+完整监管覆盖 |
+| **第五阶段** | 18个月 | 全量运行+对抗加固+运营优化 |
+
+### 9.2 里程碑
+
+| 时间点 | 里程碑 | 验收标准 |
+|--------|--------|---------|
+| 第3个月 | 持证平台秒级拦截上线 | 试点平台上传验证+播出校验+秒级下架 |
+| 第6个月 | UGC赋码+独立监控跑通 | 短视频平台批量赋码上线，日检测5000条，准确率≥90% |
+| 第9个月 | 存量补码+直播监管 | 存量Top1000补码完成，50路直播实时监测 |
+| 第12个月 | 全量运行 | 全网覆盖，存量补码完成，完整告警+下架+验证+申诉闭环 |
+| 第18个月 | 运营优化 | 误判率<2%，对抗测试通过，全量稳定运行 |
+
+---
+
+## 十、与已有系统的关系
+
+本方案不是推倒重来，而是在已有的TCS-IPTV系统上**叠加增强**：
+
+| 已有能力 | 本方案新增 | 关系 |
+|---------|-----------|------|
+| CC码生成签发 | 平台侧验证API+UGC批量赋码+直播赋码 | 让CC码从"登记备案"升级为"实时验证+全量赋码" |
+| 送审文件验真 | 上传环节拦截 | 从"送审时验"扩展到"上传时验" |
+| CDN注入校验 | 无需改动 | 已有关卡，直接复用 |
+| 终端播放抽检 | 无需改动 | 已有关卡，直接复用 |
+| 应急下架指令 | 秒级全网同步 | 从"逐层通知"升级为"一键全网下架" |
+| 全生命周期监管 | 独立外部监控 | 新增"不依赖平台配合"的监管视角 |
+
+> **核心理念：不替代现有系统，在关键节点嵌入验证能力，新增独立监控兜底。**
+
+---
+
+## 十一、关键风险与应对
+
+| 风险 | 发生概率 | 影响 | 应对措施 |
+|------|---------|------|---------|
+| 平台对接进度滞后 | 中 | 第一层覆盖不全 | 行政强制+分批过渡+第二层重点巡查未对接平台 |
+| UGC赋码性能瓶颈 | 中 | 短视频平台上传受阻 | 码段授权+平台本地赋码+异步回传，不依赖实时联网 |
+| 水印被技术手段去除 | 低 | 第二层检测难度增大 | 三种检测手段层层兜底，去水印还有指纹识别 |
+| 爬虫被网站反爬阻挡 | 中 | 部分网站采集不到 | 多种采集策略；群众举报通道补充 |
+| CDN厂商不配合下架 | 低 | 下架不彻底 | 行政处罚；DNS封锁作为最终手段 |
+| 误判正常内容为违规 | 中 | 影响正常播出和创作 | 分级处置+人工兜底+申诉通道+阈值持续优化 |
+| 存量补码进度滞后 | 中 | 过渡期结束后大量内容被强制下架 | 分批推进+进度监控+必要时延长过渡期 |
+| 合理使用界定争议 | 中 | 二创/影评创作者不满 | 界定标准由广电制定+人工审核+申诉机制 |
+| 建设成本超出预算 | 低 | 需要追加投入 | 分阶段建设，先验证再扩容，避免一次性大投入 |
+| 直播监管实时性不足 | 中 | 违规直播片段已播出 | 片段切片检测+秒级断流+录像事后追责 |
+| 水印标准不统一 | 中 | 跨平台检测失败 | 广电制定统一水印标准，强制执行 |
+
+---
+
+## 十二、方案价值总结
+
+| 维度 | 现状 | 本方案实现后 |
+|------|------|------------|
+| **发现速度** | 人工巡查，天级~周级 | 秒级（平台预防）+ 分钟级（独立监控） |
+| **下架速度** | 逐级通知，小时级~天级 | 一键指令，秒级全网下架 |
+| **覆盖范围** | 依赖平台配合，UGC基本失管 | 全量覆盖：影视剧+UGC+直播，持证平台+短视频+境外 |
+| **追溯能力** | 难以追溯来源 | CC码+水印+指纹，全链路追溯 |
+| **对抗能力** | 被动应对 | 水印+指纹+AI三层检测，扛转码/剪辑/去水印 |
+| **证据固化** | 人工截图取证 | 自动保存视频片段、截图、检测日志 |
+| **UGC管理** | 平台自查，标准不一 | 统一赋码+分级检测+合理使用界定 |
+| **存量处理** | 无系统方案 | 分批补码+过渡期安排+重点巡查 |
+| **误判处理** | 无申诉渠道 | 分级处置+申诉通道+快速恢复 |
+| **运营成本** | 大量人工巡查 | 自动化检测，人工只处理告警和审核 |
+| **直播监管** | 基本无实时监管 | 频道/主播级赋码+实时校验+秒级断流 |
+
+---
+
+## 十三、决策建议
+
+1. **尽快启动第一阶段**（第一层平台侧预防），投入小、见效快，3个月即可实现持证平台秒级拦截
+2. **同步启动第二层MVP和UGC赋码机制**，UGC是最大的监管盲区，必须尽早覆盖
+3. **同步启动存量补码计划**，存量内容量大，越早启动越主动
+4. **推动CC码制度法规落地**，技术方案需要政策支撑，平台配合度取决于行政强制力
+5. **分阶段扩容**，先验证再投入，避免一次性大规模建设
+6. **建立申诉机制**，误判处理是业务领导最关切的实操问题，必须在上线前就绪
+7. **第一层+第二层缺一不可**，只有第一层会被绕过，只有第二层下架慢，两层并行才能实现全覆盖、秒级响应
+
+---
+
+## 十四、CC码生命周期管理
+
+CC码不是一次性发放就结束的，每个CC码都有完整的生命周期状态管理：
+
+### 14.1 CC码状态流转
+
+```
+申请 → 审核中 → 签发（有效）→ 暂停 → 恢复
+                    │              │
+                    │              └── 下架（永久）
+                    │
+                    └── 过期（内容下线后自动过期）
+```
+
+### 14.2 各状态说明
+
+| 状态 | 含义 | 触发条件 | 平台行为 |
+|------|------|---------|---------|
+| **审核中** | CC码申请已提交，等待审批 | 内容制作方/平台提交申请 | 内容不得上线 |
+| **有效** | CC码已签发，内容可正常传播 | 审核通过 | 正常上传、播出、分发 |
+| **暂停** | 临时停止传播，待核实 | 收到举报或检测到疑似违规 | 平台暂停播出，但不删除 |
+| **恢复** | 暂停解除，恢复传播 | 核实后确认无违规 | 恢复正常播出 |
+| **下架** | 永久停止传播 | 监管方下达下架指令 | 平台立即删除，CDN清除缓存 |
+| **过期** | 内容已下线，CC码失效 | 内容自然下线或授权到期 | 平台不得再提供播放 |
+
+### 14.3 状态变更的权限
+
+| 操作 | 谁有权执行 | 生效速度 |
+|------|-----------|---------|
+| 申请CC码 | 内容制作方/平台代理 | - |
+| 审核签发 | 广电总局CC码系统 | 审核通过后即时 |
+| 暂停 | 监管方/平台举报 | 秒级 |
+| 恢复 | 监管方核实后 | 秒级 |
+| 下架 | 监管方 | 秒级全网同步 |
+| 过期 | 系统自动（授权到期或内容下线） | 自动触发 |
+
+> CC码生命周期管理确保每个内容从申请到下线的全过程都在监管之下，任何状态变更都有记录可查。
+
+---
+
+## 十五、组织保障与运营机制
+
+### 15.1 运营组织架构
+
+| 角色 | 职责 | 人员配置（建议） |
+|------|------|----------------|
+| **监管中心** | 统筹CC码签发、下架决策、申诉审核 | 5~8人 |
+| **审核团队** | CC码申请审核、误判申诉复核、合理使用界定 | 8~12人 |
+| **监控运营团队** | 第二层监控系统运营、告警处理、爬虫策略调整 | 6~10人 |
+| **平台对接团队** | 推动各平台对接API、技术支持、进度跟踪 | 4~6人 |
+| **技术运维团队** | 系统运维、水印/指纹/AI模型优化 | 6~8人 |
+
+### 15.2 日常运营机制
+
+| 机制 | 频率 | 内容 |
+|------|------|------|
+| **实时告警处理** | 7×24小时 | 值班人员处理系统告警，决定是否下架 |
+| **每日巡检** | 每日 | 检查系统运行状态、爬虫覆盖率、检测准确率 |
+| **每周研判** | 每周 | 集中研判疑似违规内容，调整检测阈值 |
+| **每月报告** | 每月 | 向领导层提交监管月报：检测量、下架量、平台配合度 |
+| **季度评估** | 每季度 | 评估系统效果，优化检测策略，调整平台对接优先级 |
+
+### 15.3 平台考核机制
+
+| 考核维度 | 指标 | 权重 |
+|---------|------|------|
+| **对接进度** | 是否按计划完成API对接 | 30% |
+| **执行效率** | 下架指令执行率、执行速度 | 30% |
+| **赋码覆盖率** | 平台内容赋码比例（含存量补码进度） | 20% |
+| **违规率** | 平台被发现的违规内容数量 | 20% |
+
+> 考核结果与平台年检、牌照续期挂钩，确保平台有动力配合。
+
+---
+
+## 十六、CC码与现有制度的关系
+
+| 现有制度 | 与CC码的关系 | 说明 |
+|---------|-------------|------|
+| 网络剧片发行许可证 | **并行衔接** | 影视剧需要许可证+CC码；UGC只需CC码 |
+| 信息网络传播视听节目许可证 | **平台级并行** | 平台持此证是前提，CC码是平台必须接入的验证体系 |
+| IPTV集成播控牌照 | **天然对接** | 已有TCS-IPTV系统，CC码验证API直接复用 |
+| 广播电视节目制作经营许可证 | **内容制作方并行** | 制作方持此证制作内容，内容上线前还需取得CC码 |
+| 现有内容审查制度 | **前置环节** | 内容审查通过后，方可申请CC码；CC码系统不替代审查 |
+
+> **核心理念：CC码不替代任何现有制度，而是在现有制度之上增加一个"数字身份证"层，实现从"审批管理"到"实时监管"的升级。**
diff --git a/docs/CC码监管最优方案-双层架构.md b/docs/CC码监管最优方案-双层架构.md
new file mode 100644
index 0000000..1ef76e1
--- /dev/null
+++ b/docs/CC码监管最优方案-双层架构.md
@@ -0,0 +1,778 @@
+# CC码监管最优方案：平台侧API预防（秒级）+ 独立监控兜底（分钟级）
+
+> 版本：V1.0
+> 编制日期：2026年7月
+> 关联文档：0-req-IPTV.md（TCS-IPTV需求规格）、IPTV系统融合MA码方案介绍.md
+
+---
+
+## 一、方案总览
+
+### 1.1 设计目标
+
+| 目标 | 指标 |
+|------|------|
+| 持证平台违规内容 | **秒级拦截**（上传/播出环节预防） |
+| 已上线违规内容 | **秒级下架**（CC码指令全网同步） |
+| 不配合平台/UGC | **分钟级发现** + 小时级处置 |
+| 境外平台 | **天级封锁**（DNS/IP层面） |
+| 检测准确率 | 水印提取 ≥95%，指纹匹配 ≥90% |
+
+### 1.2 双层架构
+
+```
+┌──────────────────────────────────────────────────────────┐
+│                     第一层：平台侧预防                      │
+│                     （秒级，主动拦截）                      │
+│                                                          │
+│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────┐ │
+│  │ 上传拦截  │  │ 播出校验  │  │ CDN注入  │  │终端抽检 │ │
+│  │ (0ms)    │  │ (+200ms) │  │ (秒级)   │  │(实时)   │ │
+│  └──────────┘  └──────────┘  └──────────┘  └─────────┘ │
+│         │            │            │            │         │
+│         └────────────┴────────────┴────────────┘         │
+│                        │                                 │
+│                 监管API网关（统一入口）                     │
+│                 CC码验证 · 哈希比对 · 黑名单查询            │
+├──────────────────────────────────────────────────────────┤
+│                     第二层：独立监控兜底                    │
+│                     （分钟级，被动发现）                    │
+│                                                          │
+│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────┐ │
+│  │ 爬虫采集  │  │ 直播旁路  │  │ 水印提取  │  │指纹比对 │ │
+│  │ (持续)   │  │ (实时)   │  │ (秒级)   │  │(毫秒级) │ │
+│  └──────────┘  └──────────┘  └──────────┘  └─────────┘ │
+│         │            │            │            │         │
+│         └────────────┴────────────┴────────────┘         │
+│                        │                                 │
+│                 告警引擎 → 行政通知 → 证据固化              │
+└──────────────────────────────────────────────────────────┘
+```
+
+### 1.3 两层的关系
+
+| 维度 | 第一层（平台侧预防） | 第二层（独立监控兜底） |
+|------|-------------------|---------------------|
+| 定位 | 事前预防 + 事中拦截 | 事后发现 + 兜底监管 |
+| 时效 | 秒级（0~200ms） | 分钟级（10秒~数小时） |
+| 依赖平台配合 | 强依赖 | 不依赖 |
+| 覆盖范围 | 持证平台 | 全网 |
+| 检测手段 | CC码验证 + 哈希比对 | 水印提取 + 指纹匹配 + AI语义 |
+| 执行方式 | 平台自动执行 | 行政通知 + CDN黑名单 |
+| 对抗能力 | 平台可绕过（不调API） | 无法绕过（外部独立检测） |
+
+> **核心原则：第一层是防线，第二层是底线。第一层能拦住的不需要第二层介入；第一层被绕过的由第二层兜底。**
+
+---
+
+## 二、第一层：平台侧API预防（秒级）
+
+### 2.1 四道拦截关卡
+
+```
+内容生命周期：
+  CP制作 → 上传平台 → 平台审核 → 入库 → 发布到CDN → 用户播放
+
+拦截关卡：
+  ┌─ 关卡1：上传拦截 ──┐    ┌─ 关卡2：播出校验 ─┐
+  │  上传时验证CC码    │    │  发布前验证CC码   │
+  │  无码→拒绝上传    │    │  码不合法→拒绝发布│
+  │  时延：0ms        │    │  时延：0ms        │
+  └──────────────────┘    └──────────────────┘
+                                    │
+  ┌─ 关卡3：CDN注入校验 ─┐  ┌─ 关卡4：终端抽检 ──┐
+  │  注入CDN前哈希校验  │  │  播放时片段哈希抽检│
+  │  哈希不匹配→拒绝注入│  │  不匹配→断流切换  │
+  │  时延：秒级         │  │  时延：实时        │
+  └──────────────────┘  └──────────────────┘
+```
+
+### 2.2 关卡1：上传拦截（事前预防，0ms）
+
+**场景**：用户/CP向平台上传视频时，平台调用监管API验证CC码。
+
+```
+用户上传视频
+    │
+    ├── 平台提取视频元数据中的CC码
+    │
+    ├── 调用监管API：POST /api/v1/verify/upload
+    │   Request:
+    │   {
+    │     "cc_code": "MA.156.8531.6101/WD/20260000001",
+    │     "file_hash": "sha256:abc123...",
+    │     "perceptual_hash": "phash:def456...",
+    │     "content_meta": {
+    │       "title": "xxx",
+    │       "duration": 3600,
+    │       "resolution": "1920x1080"
+    │     }
+    │   }
+    │
+    ▼
+监管API响应（<100ms）
+    │
+    ├── { "action": "ALLOW", "cc_code": "valid", "hash_match": true }
+    │     → 平台允许上传
+    │
+    ├── { "action": "DENY", "reason": "CC_CODE_NOT_FOUND" }
+    │     → 平台拒绝上传，提示"内容未取得CC码，请先完成备案"
+    │
+    ├── { "action": "DENY", "reason": "HASH_MISMATCH" }
+    │     → 平台拒绝上传，提示"内容哈希与登记不符，疑似版本替换"
+    │
+    ├── { "action": "DENY", "reason": "CC_CODE_REVOKED" }
+    │     → 平台拒绝上传，提示"该内容CC码已被吊销"
+    │
+    └── { "action": "QUARANTINE", "reason": "CC_CODE_NOT_FOUND", "suggestion": "ENTER_REVIEW" }
+          → 平台允许暂存但不可发布，进入人工审核流程
+```
+
+**关键设计**：
+- 平台在上传页面嵌入CC码验证SDK，上传前先验证
+- 无CC码的内容不进入可发布状态（暂存区→人工审核→备案→发布）
+- 验证API响应时间 <100ms（Redis缓存 + PostgreSQL索引）
+
+### 2.3 关卡2：播出校验（事中拦截，+200ms）
+
+**场景**：用户请求播放视频时，平台在返回播放地址前验证CC码状态。
+
+```
+用户点击播放
+    │
+    ├── 平台向监管API查询CC码实时状态
+    │   GET /api/v1/verify/playback?cc_code={cc_code}
+    │
+    ▼
+监管API响应（<50ms，Redis缓存）
+    │
+    ├── { "status": "ACTIVE" }
+    │     → 正常返回播放地址
+    │
+    ├── { "status": "SUSPENDED", "action": "BLOCK" }
+    │     → 返回"该内容已被监管要求下架"
+    │
+    └── { "status": "REVOKED", "action": "BLOCK" }
+          → 返回"该内容播出许可已被吊销"
+```
+
+**关键设计**：
+- 平台播放器在请求播放地址时同步查询CC码状态
+- CC码状态变更（下架/吊销）通过WebSocket实时推送到平台
+- 查询走Redis缓存，命中率 >99%，响应 <50ms
+- 用户感知延迟 <200ms（含网络往返）
+
+### 2.4 关卡3：CDN注入校验（已有需求，对应需求7）
+
+**场景**：运营商向CDN注入内容前，校验哈希。
+
+```
+运营商接收发布内容
+    │
+    ├── 计算注入文件哈希（SHA-256）
+    │
+    ├── 调用监管API：POST /api/v1/verify/cdn-inject
+    │   {
+    │     "cc_code": "MA.156.8531.6101/WD/20260000001",
+    │     "file_hash": "sha256:abc123...",
+    │     "cdn_endpoint": "cdn001.operator.com"
+    │   }
+    │
+    ▼
+    ├── 哈希匹配 → 允许注入CDN → 注册分发编码
+    └── 哈希不匹配 → 拒绝注入 → 告警 → 退回审核部门
+```
+
+### 2.5 关卡4：终端播放抽检（已有需求，对应需求8）
+
+**场景**：播放器/机顶盒在播放时抽检片段哈希。
+
+```
+播放器下载片段
+    │
+    ├── 计算片段哈希
+    │
+    ├── 与可信数据空间链上哈希比对
+    │
+    ├── 匹配 → 正常播放
+    └── 不匹配 → 断流 → 切换备用源 → 上报异常
+```
+
+### 2.6 应急下架指令链路（秒级全网同步）
+
+**场景**：监管方下发CC码下架指令，秒级同步到全网。
+
+```
+监管方下发指令："下架 CC码 MA.156.8531.6101/WD/20260000001"
+    │  ← T0
+    ▼
+TCS-IPTV系统解析CC码
+    │  查询该CC码绑定的所有：
+    │  ├── 媒资编码 → 媒体资源库
+    │  ├── 分发编码 → 各运营商CDN
+    │  ├── 审核流水号 → CSPS
+    │  └── 各平台内容ID
+    │  ← T0+10ms
+    ▼
+并行下发执行指令
+    │
+    ├── → 媒体资源库：撤除发布状态          ← T0+100ms
+    ├── → 运营商A CDN：删除缓存+下线URL     ← T0+100ms
+    ├── → 运营商B CDN：删除缓存+下线URL     ← T0+100ms
+    ├── → 持证平台A：标记内容下架           ← T0+100ms
+    ├── → 持证平台B：标记内容下架           ← T0+100ms
+    └── → CDN黑名单推送：全局拦截           ← T0+200ms
+    │
+    ▼
+全网下架完成
+    ← T0+1~3秒（取决于各节点网络延迟）
+```
+
+**技术实现**：
+
+| 机制 | 说明 | 时延 |
+|------|------|------|
+| WebSocket长连接 | TCS与各平台/运营商保持长连接，指令实时推送 | 100ms |
+| Redis Pub/Sub | CC码状态变更广播到所有订阅节点 | 50ms |
+| CDN API对接 | 调用各CDN的Purge API清除缓存 | 200ms~1s |
+| 播出校验联动 | 关卡2的播出校验会自动拦截已下架CC码 | 实时 |
+| 兜底轮询 | 未保持长连接的节点每5秒轮询CC码状态 | ≤5秒 |
+
+### 2.7 监管API接口清单
+
+| 接口 | 方法 | 调用方 | 时延要求 | 说明 |
+|------|------|--------|---------|------|
+| `/api/v1/verify/upload` | POST | 平台上传服务 | <100ms | 上传时CC码+哈希验证 |
+| `/api/v1/verify/playback` | GET | 平台播放服务 | <50ms | 播出时CC码状态查询 |
+| `/api/v1/verify/cdn-inject` | POST | 运营商CDN | <200ms | CDN注入哈希校验 |
+| `/api/v1/verify/terminal` | POST | 终端播放器SDK | <100ms | 终端片段哈希抽检 |
+| `/api/v1/takedown/issue` | POST | 监管方 | - | 下发下架指令 |
+| `/api/v1/takedown/status` | GET | 各执行方 | <50ms | 查询下架执行状态 |
+| `/api/v1/cc-code/lookup` | GET | 各方 | <50ms | CC码信息查询 |
+| `/api/v1/blacklist/push` | POST | 监管方→CDN | - | 推送CDN黑名单 |
+| `ws:/api/v1/events` | WS | 各平台/运营商 | 实时 | CC码状态变更实时推送 |
+
+---
+
+## 三、第二层：独立监控兜底（分钟级）
+
+### 3.1 适用场景
+
+第二层在以下场景触发：
+
+| 场景 | 第一层状态 | 第二层动作 |
+|------|-----------|-----------|
+| 持证平台绕过API直接上传 | 关卡1被绕过 | 爬虫发现 → 水印/指纹检测 → 告警 |
+| 平台未对接监管API | 第一层缺失 | 爬虫发现 → 检测 → 行政通知 |
+| UGC二次创作传播 | 不经过上传校验 | 爬虫发现 → 指纹匹配 → 告警 |
+| 境外平台传播 | 无法要求配合 | 爬虫发现 → 检测 → DNS封锁 |
+| 直播违规内容 | 播出校验未覆盖 | 旁路录制 → 实时检测 → 告警 |
+| 水印被恶意去除 | 所有关卡失效 | 指纹匹配 + AI语义 → 告警 |
+
+### 3.2 采集层
+
+#### 3.2.1 爬虫采集
+
+```
+┌─────────────────────────────────────────┐
+│              爬虫任务调度中心             │
+│                                         │
+│  ┌─────────────┐  ┌─────────────┐      │
+│  │ 站点配置表   │  │ 任务队列     │      │
+│  │ (Redis)     │  │ (Kafka)     │      │
+│  └──────┬──────┘  └──────┬──────┘      │
+│         │                │              │
+│  ┌──────┴────────────────┴──────┐      │
+│  │     爬虫Worker集群             │      │
+│  │  (Playwright无头浏览器)        │      │
+│  │                               │      │
+│  │  ├── 页面渲染 + JS执行         │      │
+│  │  ├── 视频地址嗅探              │      │
+│  │  │   (拦截m3u8/mp4/flv请求)    │      │
+│  │  ├── 反爬处理                  │      │
+│  │  │   (UA轮换/代理池/限速)      │      │
+│  │  └── 去重过滤                  │      │
+│  │      (URL指纹 + 内容指纹)      │      │
+│  └──────────┬────────────────────┘      │
+│             │                            │
+│             ▼                            │
+│  输出: {url, title, platform, stream_url, │
+│         duration, upload_time, uploader}  │
+│        → Kafka topic: raw-video-tasks    │
+└─────────────────────────────────────────┘
+```
+
+**站点分级策略**：
+
+| 级别 | 站点类型 | 轮巡频率 | 并发数 | 示例 |
+|------|---------|---------|--------|------|
+| P0 | 头部视频平台 | 5分钟 | 20 | 爱奇艺/腾讯/优酷/B站 |
+| P1 | 中型平台 | 30分钟 | 10 | 芒果/搜狐/西瓜视频 |
+| P2 | 短视频平台 | 15分钟 | 15 | 抖音/快手/小红书 |
+| P3 | 长尾站点 | 2小时 | 5 | 各类小视频站/论坛 |
+| P4 | 境外平台 | 1小时 | 5 | YouTube等（通过代理） |
+
+#### 3.2.2 直播旁路录制
+
+```
+┌─────────────────────────────────────────┐
+│              直播旁路录制引擎             │
+│                                         │
+│  ┌─────────────┐  ┌─────────────┐      │
+│  │ 频道配置表   │  │ 录制Worker   │      │
+│  │             │  │ (FFmpeg)    │      │
+│  │ 卫星频道    │→ │             │      │
+│  │ 有线频道    │→ │ ffmpeg -i   │      │
+│  │ 网络直播    │→ │   {url}     │      │
+│  │             │  │   -c copy   │      │
+│  │             │  │   -f segment│      │
+│  │             │  │   -seg_time │      │
+│  │             │  │   300       │      │
+│  └─────────────┘  └──────┬──────┘      │
+│                          │              │
+│                    切片输出              │
+│                    (每5分钟一个mp4)      │
+│                          │              │
+│                          ▼              │
+│              Kafka topic: live-tasks    │
+└─────────────────────────────────────────┘
+```
+
+### 3.3 检测层
+
+#### 3.3.1 三级检测流水线
+
+```
+输入视频
+    │
+    ├─────────────────────────────────────────────┐
+    ▼                                             ▼
+  路径A：快速检测（CPU，毫秒级）           路径B：深度检测（GPU，秒级）
+    │                                             │
+    ├── 第1步：元数据提取                          ├── 第2步：水印提取
+    │   ffprobe提取CC码元数据                      │   DCT频域水印提取
+    │   (moov box / EXT-X-CC-CODE)                │   多帧冗余提取 + 多数投票
+    │   时延：100ms                               │   时延：2~5秒/30秒片段
+    │                                             │
+    ├── 找到CC码？                                ├── 找到CC码？
+    │   ├── 是 → 验证码合法性 → 判定              │   ├── 是 → 验证 → 判定
+    │   └── 否 → 进入路径B                        │   └── 否 → 进入第3步
+    │                                             │
+    │                                             ├── 第3步：内容指纹匹配
+    │                                             │   pHash + DTW时序对齐
+    │                                             │   时延：50ms
+    │                                             │
+    │                                             ├── 指纹匹配？
+    │                                             │   ├── 是 → 关联CC码 → 判定
+    │                                             │   └── 否 → 进入第4步
+    │                                             │
+    │                                             └── 第4步：AI语义匹配（兜底）
+    │                                                 CLIP特征 + 向量检索
+    │                                                 时延：30秒/分钟视频
+    │
+    ▼                                             ▼
+  决策层（合并A/B路径结果）
+```
+
+#### 3.3.2 水印提取算法
+
+```python
+class WatermarkExtractor:
+    """
+    DCT频域水印提取器
+    嵌入位置：8x8 DCT块的中频系数
+    嵌入方式：QIM (Quantization Index Modulation)
+    冗余度：同一CC码在视频中重复嵌入，每30帧一个嵌入周期
+    """
+
+    def __init__(self, secret_key: bytes):
+        self.key = secret_key  # 监管方持有的水印密钥
+        self.block_size = 8
+        self.sample_interval = 30  # 每30帧采样
+        self.embed_positions = self._derive_positions()  # 密钥派生嵌入位置
+
+    def extract(self, video_path: str) -> Optional[str]:
+        # 1. 解码为YUV帧序列
+        frames = self._decode_video(video_path)
+
+        # 2. 采样帧
+        sampled = frames[::self.sample_interval]
+
+        # 3. 逐帧提取水印比特
+        bit_accumulator = defaultdict(list)
+
+        for frame in sampled:
+            y_channel = frame[:, :, 0]  # 亮度通道
+
+            # 分块DCT
+            for block in self._split_blocks(y_channel):
+                dct_block = cv2.dct(block.astype(np.float32))
+
+                # 从中频系数提取比特
+                for pos in self.embed_positions:
+                    bit = self._extract_bit_qim(dct_block[pos[0], pos[1]])
+                    bit_accumulator[pos].append(bit)
+
+        # 4. 多数投票解码
+        raw_bits = self._majority_vote(bit_accumulator)
+
+        # 5. ECC纠错解码
+        decoded = self._ecc_decode(raw_bits)
+
+        # 6. CRC校验
+        if not self._crc_check(decoded):
+            return None  # 水印损坏或不存在
+
+        # 7. HMAC验证
+        cc_code = self._parse_cc_code(decoded)
+        if not self._hmac_verify(cc_code, self.key):
+            return None  # 伪造水印
+
+        return cc_code
+```
+
+#### 3.3.3 内容指纹匹配
+
+```python
+class VideoFingerprintMatcher:
+    """
+    视频内容指纹匹配器
+    指纹：关键帧pHash序列
+    匹配：汉明距离初筛 + DTW时序对齐
+    """
+
+    def fingerprint(self, video_path: str) -> dict:
+        # 1. 降采样
+        frames = self._decode_downsample(video_path, size=(64, 64), gray=True)
+
+        # 2. 关键帧检测（场景切换点）
+        keyframe_indices = self._detect_keyframes(frames)
+
+        # 3. 计算关键帧pHash
+        keyframe_hashes = []
+        for idx in keyframe_indices:
+            phash = self._compute_phash(frames[idx])
+            keyframe_hashes.append(phash)
+
+        # 4. 计算视频级聚合哈希
+        avg_hash = self._compute_avg_hash(frames)
+
+        return {
+            'keyframe_hashes': keyframe_hashes,
+            'avg_hash': avg_hash,
+            'duration': self._get_duration(video_path),
+            'keyframe_count': len(keyframe_hashes)
+        }
+
+    def match(self, video_fp: dict, database) -> Optional[dict]:
+        # 1. avg_hash初筛（汉明距离<12）
+        candidates = database.search_by_avg_hash(
+            video_fp['avg_hash'],
+            hamming_threshold=12
+        )
+
+        if not candidates:
+            return None
+
+        # 2. 关键帧序列DTW对齐
+        best_match = None
+        best_score = 0
+
+        for candidate in candidates:
+            score = self._dtw_align(
+                video_fp['keyframe_hashes'],
+                candidate['keyframe_hashes']
+            )
+            if score > best_score:
+                best_score = score
+                best_match = candidate
+
+        # 3. 阈值判定
+        if best_score > 0.85:
+            return {
+                'cc_code': best_match['cc_code'],
+                'similarity': best_score,
+                'matched_title': best_match['title']
+            }
+
+        return None
+```
+
+### 3.4 决策与告警层
+
+#### 3.4.1 决策矩阵
+
+| 检测路径 | 结果 | 判定 | 动作 | 时效 |
+|---------|------|------|------|------|
+| 元数据 | CC码合法 | 正版传播 | 记录备案 | 秒级 |
+| 元数据 | CC码不合法 | 伪造/篡改 | 告警+取证 | 秒级 |
+| 水印 | CC码合法 | 正版传播 | 记录备案 | 秒级 |
+| 水印 | CC码不合法 | 伪造CC码 | 告警+取证+行政通知 | 秒级 |
+| 水印 | 无水印 | 疑似未登记 | 进入指纹匹配 | 秒级 |
+| 指纹 | 匹配已登记CC码 | 疑似去水印传播 | 告警+取证+行政通知 | 毫秒级 |
+| 指纹 | 未匹配 | 进入AI匹配 | - | 毫秒级 |
+| AI语义 | 匹配 | 疑似深度篡改/混剪 | 告警+人工审核 | 分钟级 |
+| AI语义 | 未匹配 | 未登记内容 | 进入备案审核流程 | 分钟级 |
+
+#### 3.4.2 告警分级
+
+| 级别 | 判定 | 通知方式 | 响应时效 |
+|------|------|---------|---------|
+| **P0-紧急** | 伪造CC码 + 大规模传播 | 电话+短信+API推送 | 立即 |
+| **P1-高危** | 去水印传播 + 已登记内容 | 短信+API推送 | 5分钟内 |
+| **P2-中危** | 未登记内容 + 疑似违规 | API推送+邮件 | 30分钟内 |
+| **P3-低危** | 未登记内容 + 无明显违规 | 邮件+日报 | 24小时内 |
+
+#### 3.4.3 证据固化
+
+```json
+{
+  "alert_id": "ALT-20260720-001234",
+  "level": "P1",
+  "timestamp": "2026-07-20T20:15:00Z",
+  "source": {
+    "type": "web_crawler",
+    "platform": "example.com",
+    "url": "https://example.com/video/12345",
+    "crawler_node": "crawler-03"
+  },
+  "video_info": {
+    "title": "xxx",
+    "duration": 3600,
+    "resolution": "1920x1080",
+    "format": "mp4"
+  },
+  "detection_result": {
+    "metadata_cc_code": null,
+    "watermark_cc_code": null,
+    "fingerprint_match": {
+      "matched": true,
+      "cc_code": "MA.156.8531.6101/WD/20260000001",
+      "similarity": 0.92,
+      "matched_title": "原始登记标题"
+    },
+    "ai_match": "skipped"
+  },
+  "verdict": "SUSPECTED_WATERMARK_REMOVAL",
+  "evidence": {
+    "video_clip": "/evidence/ALT-20260720-001234/clip.mp4",
+    "screenshot": "/evidence/ALT-20260720-001234/screenshot.jpg",
+    "fingerprint_diff": "/evidence/ALT-20260720-001234/diff.json",
+    "detection_log": "/evidence/ALT-20260720-001234/log.txt"
+  },
+  "actions": [
+    { "action": "notify_platform", "status": "sent", "timestamp": "..." },
+    { "action": "notify_regulator", "status": "sent", "timestamp": "..." },
+    { "action": "preserve_evidence", "status": "done", "timestamp": "..." }
+  ]
+}
+```
+
+---
+
+## 四、两层协同机制
+
+### 4.1 正常流程（第一层生效）
+
+```
+CP上传内容 → 关卡1验证CC码 → 通过 → 平台审核 → 关卡2播出校验 → CDN注入校验 → 用户播放
+                                                                    ↓
+                                                              终端抽检（关卡4）
+                                                                    ↓
+                                                              一切正常，无需第二层介入
+```
+
+### 4.2 绕过场景（第二层兜底）
+
+```
+场景A：平台未对接API
+    内容上传 → 平台未验证CC码 → 内容上线
+                                        ↓
+                              第二层爬虫发现 → 检测 → 告警 → 行政通知平台下架
+
+场景B：持证平台绕过API
+    内容上传 → 平台跳过CC码验证 → 内容上线
+                                        ↓
+                              第二层爬虫发现 → 检测 → 告警 → 追责平台
+
+场景C：UGC二次创作
+    用户剪辑正版内容 → 上传到短视频平台 → 内容上线
+                                                    ↓
+                                          第二层爬虫发现 → 指纹匹配 → 判定是否侵权
+
+场景D：水印被去除
+    内容被去水印处理 → 上传 → 平台无法验证CC码
+                                        ↓
+                              第二层爬虫发现 → 指纹匹配 → 告警
+```
+
+### 4.3 下架指令协同
+
+```
+监管方下发下架指令
+    │
+    ├── 第一层：秒级同步
+    │   ├── WebSocket推送 → 持证平台自动下架（秒级）
+    │   ├── CDN Purge API → CDN缓存清除（秒级）
+    │   ├── Redis状态更新 → 播出校验自动拦截（实时）
+    │   └── CDN黑名单推送 → 全局URL拦截（秒级）
+    │
+    └── 第二层：验证下架效果
+        ├── 爬虫轮巡目标URL → 确认是否已下架
+        ├── 已下架 → 记录确认
+        ├── 未下架 → 升级告警（平台未执行指令）
+        └── 持续监控 → 防止重新上架
+```
+
+### 4.4 数据回流
+
+```
+第二层检测发现的内容
+    │
+    ├── 已登记CC码但未在平台备案 → 回流到TCS-IPTV → 补登记
+    ├── 未登记内容 → 进入备案审核流程 → 补发CC码
+    ├── 伪造CC码 → 回流到TCS → 标记伪造 → 追查来源
+    └── 去水印传播 → 回流到TCS → 记录侵权证据 → 追责
+```
+
+---
+
+## 五、技术架构
+
+### 5.1 系统部署架构
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    TCS-IPTV 核心（已有）                      │
+│                                                             │
+│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌────────────┐ │
+│  │ 标识服务  │  │ 验真服务  │  │ MA管理   │  │ 可信数据空间│ │
+│  └──────────┘  └──────────┘  └──────────┘  └────────────┘ │
+│                                                             │
+│  ┌──────────────────────────────────────────────────────┐  │
+│  │              监管API网关（第一层）                      │  │
+│  │  /verify/upload  /verify/playback  /verify/cdn-inject │  │
+│  │  /takedown/issue  /blacklist/push  ws:/events         │  │
+│  └──────────────────────────────────────────────────────┘  │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  ┌──────────────────────────────────────────────────────┐  │
+│  │              独立监控系统（第二层，新增）                │  │
+│  │                                                      │  │
+│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐          │  │
+│  │  │ 爬虫集群  │  │ 录制引擎  │  │ 检测集群  │          │  │
+│  │  │ (K8s)    │  │ (K8s)    │  │ (GPU K8s)│          │  │
+│  │  └──────────┘  └──────────┘  └──────────┘          │  │
+│  │                                                      │  │
+│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐          │  │
+│  │  │ 告警引擎  │  │ 证据存储  │  │ 下架验证  │          │  │
+│  │  └──────────┘  └──────────┘  └──────────┘          │  │
+│  └──────────────────────────────────────────────────────┘  │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  ┌──────────────────────────────────────────────────────┐  │
+│  │              基础设施层                                 │  │
+│  │                                                      │  │
+│  │  PostgreSQL │ Redis │ Kafka │ Elasticsearch          │  │
+│  │  Milvus(向量) │ MinIO(视频/证据) │ K8s集群            │  │
+│  └──────────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### 5.2 第一层资源需求（增量）
+
+| 组件 | 规格 | 数量 | 说明 |
+|------|------|------|------|
+| API网关 | 4核8GB | 3节点 | 高可用，负载均衡 |
+| Redis | 8核32GB | 3节点 | CC码状态缓存，主从+哨兵 |
+| WebSocket推送 | 2核4GB | 2节点 | 长连接管理 |
+| **合计** | | | **~20核/40GB增量** |
+
+> 第一层资源需求很小，因为验证逻辑轻量，主要依赖已有的TCS-IPTV核心系统。
+
+### 5.3 第二层资源需求（分阶段）
+
+| 阶段 | GPU | CPU | 内存 | 存储 | 带宽 | 月成本 |
+|------|-----|-----|------|------|------|--------|
+| MVP | 0 | 64核 | 128GB | 20TB | 200Mbps | ¥2~3万 |
+| 中等 | 10×T4 | 128核 | 256GB | 50TB | 500Mbps | ¥6~8万 |
+| 全量 | 30×T4 | 256核 | 512GB | 150TB | 1Gbps | ¥12~15万 |
+
+> 第二层通过智能调度（粗筛先行、夜间批量、弹性伸缩）可降低40%资源消耗。
+
+---
+
+## 六、分阶段实施计划
+
+### 第一阶段：平台侧API预防（对已有TCS-IPTV扩展）
+
+| 任务 | 周期 | 依赖 |
+|------|------|------|
+| 监管API网关开发 | 4周 | TCS-IPTV核心 |
+| 上传验证接口 | 2周 | API网关 |
+| 播出校验接口 | 2周 | API网关 |
+| WebSocket实时推送 | 2周 | API网关 |
+| 应急下架指令链路 | 3周 | WebSocket + CDN API |
+| 平台对接（1~2家试点） | 4周 | 接口就绪 |
+| **小计** | **~12周** | |
+
+### 第二阶段：独立监控MVP
+
+| 任务 | 周期 | 依赖 |
+|------|------|------|
+| 爬虫采集管线 | 4周 | K8s + Kafka |
+| 水印嵌入/提取原型 | 6周 | 水印算法选型 |
+| 指纹匹配引擎 | 3周 | Milvus部署 |
+| 检测流水线编排 | 2周 | 爬虫 + 水印 + 指纹 |
+| 告警+证据固化 | 2周 | 检测流水线 |
+| **小计** | **~12周** | |
+
+### 第三阶段：检测规模化
+
+| 任务 | 周期 | 依赖 |
+|------|------|------|
+| GPU集群部署 | 2周 | MVP验证通过 |
+| 直播旁路录制 | 3周 | FFmpeg + K8s |
+| AI语义匹配 | 4周 | CLIP模型 + Milvus |
+| 对抗加固测试 | 4周 | 全检测链路 |
+| 下架验证回路 | 2周 | 第一层 + 第二层 |
+| **小计** | **~12周** | |
+
+### 第四阶段：全量上线
+
+| 任务 | 周期 | 依赖 |
+|------|------|------|
+| 全平台对接推广 | 8周 | 行政要求下发 |
+| 弹性伸缩调优 | 2周 | 全量负载 |
+| 监管大屏集成 | 3周 | 已有需求10 |
+| 运营体系建设 | 4周 | 全系统 |
+| **小计** | **~12周** | |
+
+> **总周期约12个月**，第一层可在3个月内上线，第二层MVP在6个月内跑通。
+
+---
+
+## 七、与已有TCS-IPTV需求的对应关系
+
+| 已有需求 | 本方案对应模块 | 增强点 |
+|---------|-------------|--------|
+| 需求3：CC码生成签发 | 第一层验证基础 | CC码作为验证主键 |
+| 需求4：送审文件验真 | 第一层关卡1（上传拦截） | 从送审扩展到平台上传 |
+| 需求7：CDN注入校验 | 第一层关卡3 | 已有，无需改动 |
+| 需求8：终端播放抽检 | 第一层关卡4 | 已有，无需改动 |
+| 需求11：违规应急下架 | 第一层下架指令链路 | 增加WebSocket实时推送+CDN黑名单 |
+| 需求10：全生命周期监管 | 第二层独立监控 | 新增外部监控维度 |
+| 需求9：统一维度数据上报 | 第二层数据回流 | 检测数据回流到TCS |
+
+---
+
+## 八、关键风险与应对
+
+| 风险 | 影响 | 应对 |
+|------|------|------|
+| 持证平台不配合对接API | 第一层失效 | 行政强制要求 + 第二层兜底 |
+| 水印被AI去除 | 第二层检测失效 | 多算法混合嵌入 + 指纹匹配兜底 + AI语义兜底 |
+| 爬虫被反爬阻挡 | 第二层采集缺失 | 代理池 + 多策略 + 举报通道补充 |
+| CDN厂商不配合黑名单 | 下架不彻底 | 行政处罚 + DNS封锁兜底 |
+| 误判率过高 | 正常内容被拦截 | 人工审核兜底 + 阈值可调 + 申诉通道 |
+| 资源成本超预算 | 系统无法全量运行 | 分阶段建设 + 智能调度降本 |
diff --git a/docs/IPTV.md b/docs/IPTV.md
index d0cdcde..b7fd790 100644
--- a/docs/IPTV.md
+++ b/docs/IPTV.md
@@ -10,10 +10,10 @@ IPTV内容流转涉及CP（内容供应商）、IPTV集成播控平台、运营
 - 跨省跨运营商复用几乎要重新走全流程
 
 ### 1.2 核心目标
-建立**"监管身份+技术指纹"双锚定机制**，以MA码为监管主键、哈希码为技术指纹，实现：
+建立**"监管身份+技术指纹"双锚定机制**，以CC码为监管主键、哈希码为技术指纹，实现：
 - **审播一致**：送审版=播出版，任何篡改秒级识别
-- **一码通行**：一省过审，全网凭MA码+哈希准入
-- **精准溯源**：出问题凭MA码秒级定位三方系统
+- **一码通行**：一省过审，全网凭CC码+哈希准入
+- **精准溯源**：出问题凭CC码秒级定位三方系统
 - **数据可信**：播放量、结算、上报以统一标识聚合
 
 ### 1.3 设计原则
@@ -32,7 +32,7 @@ IPTV内容流转涉及CP（内容供应商）、IPTV集成播控平台、运营
 ┌─────────────────────────────────────────────────────────────┐
 │                    监管侧（广电总局/省局）                     │
 │              网络剧片发行许可证系统 / 备案系统                  │
-│                      ↓ 签发MA码                              │
+│                      ↓ 签发CC码                              │
 ├─────────────────────────────────────────────────────────────┤
 │  CP端              播控平台端            运营商端              │
 │  (内容供应商)       (集成播控)           (分发网络)            │
@@ -46,7 +46,7 @@ IPTV内容流转涉及CP（内容供应商）、IPTV集成播控平台、运营
 │                         │                                   │
 │              ┌──────────┴──────────┐                      │
 │              │   可信数据空间（区块链）  │                      │
-│              │  MA码↔哈希↔三方编码映射   │                      │
+│              │  CC码↔哈希↔三方编码映射   │                      │
 │              └─────────────────────┘                      │
 └─────────────────────────────────────────────────────────────┘
 ```
@@ -56,7 +56,7 @@ IPTV内容流转涉及CP（内容供应商）、IPTV集成播控平台、运营
 | 层级 | 功能 | 技术组件 |
 |------|------|---------|
 | **接入层** | 三方系统对接、文件上传、哈希计算 | 哈希计算SDK、API网关、文件切片服务 |
-| **可信层** | MA码与哈希绑定、存证、映射查询 | 联盟链（或分布式账本）、智能合约、Merkle Tree存储 |
+| **可信层** | CC码与哈希绑定、存证、映射查询 | 联盟链（或分布式账本）、智能合约、Merkle Tree存储 |
 | **应用层** | 审核验真、分发校验、终端抽检、数据上报 | 审核工作台、CDN注入校验、播放器SDK、监管大屏 |
 
 ---
@@ -77,7 +77,7 @@ CTID = {
 ```
 
 **绑定规则**：
-- MA码由广电总局/省局签发，代表**合法身份**
+- CC码由广电总局/省局签发，代表**合法身份**
 - 哈希码由内容本体计算，代表**数据真实性**
 - 两者在可信数据空间中**1:1强绑定**，不可解绑
 - 内容任何帧级变动 → 哈希变化 → 绑定断裂 → 需重新送审
@@ -114,12 +114,12 @@ CTID = {
   - **哈希值包**（含Merkle Tree根哈希）
 - 系统返回**送审流水号**
 
-**Step 3：审核通过与MA码签发**
+**Step 3：审核通过与CC码签发**
 - 省级广电/广电总局审核内容
 - 审核通过后，系统：
-  - 签发MA码（或备案号）
-  - **将MA码与送审哈希包绑定写入可信数据空间**
-- CP获得"MA码+哈希证书"，方可进入播控平台
+  - 签发CC码（或备案号）
+  - **将CC码与送审哈希包绑定写入可信数据空间**
+- CP获得"CC码+哈希证书"，方可进入播控平台
 
 ---
 
@@ -127,7 +127,7 @@ CTID = {
 
 **Step 4：送审文件验真**
 - CP向播控平台送审，提交：
-  - MA码
+  - CC码
   - 送审文件（母版或播出版）
   - 授权链文件
 - 播控平台**计算送审文件哈希**，查询可信数据空间：
@@ -138,16 +138,16 @@ CTID = {
 - 播控平台对内容进行合规审核（政治、色情、暴力等）
 - 审核通过后，如需转码（H.264/H.265/4K/HD多版本）：
   - 由**授权转码中心**执行，转码后重新计算各版本文件哈希
-  - 生成"转码版哈希证书"，与MA码绑定，写入可信数据空间
+  - 生成"转码版哈希证书"，与CC码绑定，写入可信数据空间
   - 原母版哈希与转码版哈希建立父子关系
 
 **Step 6：EPG编排与编码映射**
 - 播控平台将内容纳入EPG，内部保留自有审核流水号
 - 在可信数据空间中建立映射：
   ```
-  播控流水号 ↔ MA码 ↔ 文件哈希 ↔ 转码版哈希
+  播控流水号 ↔ CC码 ↔ 文件哈希 ↔ 转码版哈希
   ```
-- 向运营商分发时，**必须携带MA码+哈希证书**
+- 向运营商分发时，**必须携带CC码+哈希证书**
 
 ---
 
@@ -156,7 +156,7 @@ CTID = {
 **Step 7：CDN注入校验**
 - 运营商收到播控平台分发内容，注入CDN前：
   - 计算注入文件哈希
-  - 查询可信数据空间，比对MA码绑定的哈希
+  - 查询可信数据空间，比对CC码绑定的哈希
   - 匹配 → 注入CDN，生成分发编码
   - 不匹配 → 拒绝注入，告警退回播控平台
 
@@ -168,7 +168,7 @@ CTID = {
   - （此步骤为增强安全，可根据网络负载策略性开启）
 
 **Step 9：数据上报**
-- 运营商上报播出数据时，以MA码为统一维度
+- 运营商上报播出数据时，以CC码为统一维度
 - 可信数据空间聚合三方数据（CP播放量、播控审核量、运营商分发量），口径一致
 
 ---
@@ -176,15 +176,15 @@ CTID = {
 ### 4.4 第四阶段：监管与应急
 
 **Step 10：全生命周期监管**
-- 广电总局/省局通过监管大屏，按MA码查询内容全链路状态：
+- 广电总局/省局通过监管大屏，按CC码查询内容全链路状态：
   - 当前在哪个播控平台
   - 当前在哪个运营商CDN
   - 当前哈希版本是否最新
   - 历史版本变更记录
 
 **Step 11：违规应急下架**
-- 监管部门下发指令："下架MA码（京）网微剧审字(2025)第XXX号"
-- 可信数据空间解析MA码 → 查询所有绑定的三方编码
+- 监管部门下发指令："下架CC码（京）网微剧审字(2025)第XXX号"
+- 可信数据空间解析CC码 → 查询所有绑定的三方编码
 - 指令自动翻译为：
   - 播控平台：下架审核流水号XXX
   - 运营商：下架分发编码YYY、CDN资源ZZZ
@@ -308,10 +308,10 @@ def compute_content_hash(file_path, segment_size=10*1024*1024):
 // 伪代码：Solidity风格
 contract ContentRegistry {
     
-    mapping(string => Content) public contents; // MA码 => 内容
+    mapping(string => Content) public contents; // CC码 => 内容
     
     struct Content {
-        string maCode;
+        string ccCode;
         string merkleRoot;
         string perceptualHash;
         mapping(string => string) partyMappings; // 三方编码映射
@@ -319,20 +319,20 @@ contract ContentRegistry {
     }
     
     // 仅监管节点可调用
-    function issueMA(string memory maCode, string memory merkleRoot) public {
+    function issueMA(string memory ccCode, string memory merkleRoot) public {
         require(isRegulator(msg.sender), "Only regulator");
-        contents[maCode] = Content(maCode, merkleRoot, "", true);
+        contents[ccCode] = Content(ccCode, merkleRoot, "", true);
     }
     
     // CP/播控/运营商注册映射
-    function registerMapping(string memory maCode, string memory party, string memory partyId) public {
-        require(contents[maCode].isActive, "MA not issued");
-        contents[maCode].partyMappings[party] = partyId;
+    function registerMapping(string memory ccCode, string memory party, string memory partyId) public {
+        require(contents[ccCode].isActive, "MA not issued");
+        contents[ccCode].partyMappings[party] = partyId;
     }
     
     // 哈希校验
-    function verifyHash(string memory maCode, string memory fileHash) public view returns (bool) {
-        return keccak256(abi.encodePacked(contents[maCode].merkleRoot)) 
+    function verifyHash(string memory ccCode, string memory fileHash) public view returns (bool) {
+        return keccak256(abi.encodePacked(contents[ccCode].merkleRoot)) 
             == keccak256(abi.encodePacked(fileHash));
     }
 }
@@ -348,7 +348,7 @@ contract ContentRegistry {
                   ├── 转码版B哈希（H.264 HD）
                   └── 转码版C哈希（H.264 SD）
   ```
-- 所有转码版共享同一MA码，但各自有独立哈希记录
+- 所有转码版共享同一CC码，但各自有独立哈希记录
 - 运营商注入任一版本时，校验对应版本哈希
 
 ---
@@ -430,7 +430,7 @@ Response:
 
 ### 8.1 角色权限矩阵
 
-| 角色 | 签发MA码 | 注册哈希 | 验真查询 | 映射管理 | 应急下架 |
+| 角色 | 签发CC码 | 注册哈希 | 验真查询 | 映射管理 | 应急下架 |
 |------|---------|---------|---------|---------|---------|
 | 广电总局/省局 | ✅ | ✅ | ✅ | ✅ | ✅ |
 | 播控平台 | ❌ | ❌ | ✅ | ✅（本方） | ❌（执行指令） |
@@ -445,19 +445,19 @@ Response:
 | 哈希不匹配（CDN注入） | 拒绝注入，告警播控平台，暂停该内容分发 |
 | 哈希不匹配（终端抽检） | 断流并切换至备用源，上报异常日志 |
 | 版本变更（剪辑/修改） | 必须重新计算哈希，提交变更申请，触发重新审核 |
-| CP换壳重发（同一哈希） | 系统识别哈希已存在，拒绝重复申报，关联原MA码 |
+| CP换壳重发（同一哈希） | 系统识别哈希已存在，拒绝重复申报，关联原CC码 |
 
 ### 8.3 跨省复用流程
 
 ```
-A省过审取得MA码 + 哈希证书
+A省过审取得CC码 + 哈希证书
         ↓
 CP向B省播控平台送审，仅提交：
-  - MA码
+  - CC码
   - 哈希证书（无需重新提交内容文件）
         ↓
 B省播控平台查询可信数据空间：
-  - 验证MA码真实有效
+  - 验证CC码真实有效
   - 验证哈希与A省过审版一致
   - 确认内容未在黑名单
         ↓
@@ -495,4 +495,4 @@ B省播控平台快速准入（内容审核可简化为合规性抽检）
 
 ---
 
-**总结**：这套方案的核心不是让三方放弃自己的系统，而是在三方系统之上建立一层**"可信身份映射层"**——用MA码解决"是谁"的监管问题，用哈希码解决"是不是"的技术问题，用可信数据空间解决"在哪"的溯源问题。三者叠加，IPTV内容才能真正实现"审过即锁定，锁定即通行，通行可追溯"。
\ No newline at end of file
+**总结**：这套方案的核心不是让三方放弃自己的系统，而是在三方系统之上建立一层**"可信身份映射层"**——用CC码解决"是谁"的监管问题，用哈希码解决"是不是"的技术问题，用可信数据空间解决"在哪"的溯源问题。三者叠加，IPTV内容才能真正实现"审过即锁定，锁定即通行，通行可追溯"。
\ No newline at end of file
diff --git a/docs/TCS-IPTV系统线框图.svg b/docs/TCS-IPTV系统线框图.svg
index e8c6c62..9e411e5 100644
--- a/docs/TCS-IPTV系统线框图.svg
+++ b/docs/TCS-IPTV系统线框图.svg
@@ -25,13 +25,13 @@
   <!-- 标题 -->
   <rect x="0" y="0" width="1700" height="78" fill="url(#chainGrad)"/>
   <text x="850" y="34" text-anchor="middle" fill="white" font-size="23" font-weight="bold">TCS-IPTV 内容可信锁定系统 · 总体线框图</text>
-  <text x="850" y="60" text-anchor="middle" fill="#b3c5ff" font-size="13">MA码（监管身份）+ 哈希码（技术指纹）双锚定 · 不替代现有系统，在三方之上建立"可信身份映射层"</text>
+  <text x="850" y="60" text-anchor="middle" fill="#b3c5ff" font-size="13">CC码（监管身份）+ 哈希码（技术指纹）双锚定 · 不替代现有系统，在三方之上建立"可信身份映射层"</text>
 
   <!-- ============ 监管层 ============ -->
   <rect x="40" y="100" width="1620" height="150" rx="10" fill="#fff5f5" stroke="#c62828" stroke-width="2"/>
   <rect x="40" y="100" width="1620" height="34" rx="10" fill="url(#regGrad)"/>
   <text x="60" y="123" fill="white" font-size="15" font-weight="bold">① 监管侧 — 广电总局 / 省级广电局（监管主键签发方 · 价值核心）</text>
-  <text x="1640" y="123" text-anchor="end" fill="#ffcdd2" font-size="11">★ 唯一拥有 MA码签发权 与 应急下架权</text>
+  <text x="1640" y="123" text-anchor="end" fill="#ffcdd2" font-size="11">★ 唯一拥有 CC码签发权 与 应急下架权</text>
 
   <!-- 监管子系统 -->
   <g>
@@ -52,29 +52,29 @@
   <!-- 新建: MA签发与监管大屏 -->
   <g>
     <rect x="700" y="148" width="290" height="88" rx="6" fill="#ffebee" stroke="#c62828" stroke-width="2" stroke-dasharray="5,3"/>
-    <text x="845" y="168" text-anchor="middle" font-size="12" font-weight="bold" fill="#b71c1c">★ MA码签发引擎（新建）</text>
-    <text x="845" y="187" text-anchor="middle" font-size="10" fill="#555">审核通过 → 签发MA码</text>
-    <text x="845" y="203" text-anchor="middle" font-size="10" fill="#555">MA码 ↔ 哈希包 强绑定上链</text>
+    <text x="845" y="168" text-anchor="middle" font-size="12" font-weight="bold" fill="#b71c1c">★ CC码签发引擎（新建）</text>
+    <text x="845" y="187" text-anchor="middle" font-size="10" fill="#555">审核通过 → 签发CC码</text>
+    <text x="845" y="203" text-anchor="middle" font-size="10" fill="#555">CC码 ↔ 哈希包 强绑定上链</text>
     <text x="845" y="222" text-anchor="middle" font-size="10" fill="#c62828">仅监管节点可调用 issueMA()</text>
   </g>
   <g>
     <rect x="1010" y="148" width="290" height="88" rx="6" fill="#ffebee" stroke="#c62828" stroke-width="2" stroke-dasharray="5,3"/>
     <text x="1155" y="168" text-anchor="middle" font-size="12" font-weight="bold" fill="#b71c1c">★ 全生命周期监管大屏（新建）</text>
-    <text x="1155" y="187" text-anchor="middle" font-size="10" fill="#555">按MA码查全链路状态</text>
+    <text x="1155" y="187" text-anchor="middle" font-size="10" fill="#555">按CC码查全链路状态</text>
     <text x="1155" y="203" text-anchor="middle" font-size="10" fill="#555">在哪个播控/CDN/哈希版本</text>
     <text x="1155" y="222" text-anchor="middle" font-size="10" fill="#555">历史版本变更追溯</text>
   </g>
   <g>
     <rect x="1320" y="148" width="320" height="88" rx="6" fill="#ffebee" stroke="#c62828" stroke-width="2" stroke-dasharray="5,3"/>
     <text x="1480" y="168" text-anchor="middle" font-size="12" font-weight="bold" fill="#b71c1c">★ 违规应急下架指挥台（新建）</text>
-    <text x="1480" y="187" text-anchor="middle" font-size="10" fill="#555">下发：下架 MA码 第XXX号</text>
+    <text x="1480" y="187" text-anchor="middle" font-size="10" fill="#555">下发：下架 CC码 第XXX号</text>
     <text x="1480" y="203" text-anchor="middle" font-size="10" fill="#555">自动翻译为三方编码指令</text>
     <text x="1480" y="222" text-anchor="middle" font-size="10" fill="#c62828">秒级全网同步，无需逐层人工</text>
   </g>
 
-  <!-- 监管 → 可信空间 签发MA码 箭头 -->
+  <!-- 监管 → 可信空间 签发CC码 箭头 -->
   <line x1="845" y1="236" x2="845" y2="300" stroke="#c62828" stroke-width="2.5" marker-end="url(#arrowRed)"/>
-  <text x="855" y="272" font-size="11" font-weight="bold" fill="#c62828">签发MA码 + 绑定哈希</text>
+  <text x="855" y="272" font-size="11" font-weight="bold" fill="#c62828">签发CC码 + 绑定哈希</text>
 
   <!-- 应急下架 → 可信空间 -->
   <line x1="1480" y1="236" x2="1480" y2="300" stroke="#c62828" stroke-width="2.5" stroke-dasharray="6,3" marker-end="url(#arrowRed)"/>
@@ -116,9 +116,9 @@
     <text x="965" y="370" text-anchor="middle" font-size="12" font-weight="bold" fill="#311b92">三方编码映射表（Identity Mapping）</text>
     <line x1="770" y1="378" x2="1160" y2="378" stroke="#d1c4e9"/>
     <text x="770" y="400" font-size="10" fill="#444">CP编码  FS-MEDIA-77821  ┐</text>
-    <text x="770" y="422" font-size="10" fill="#444">播控编码  GD-2025-NS-004472  ├─ ↔ MA码</text>
+    <text x="770" y="422" font-size="10" fill="#444">播控编码  GD-2025-NS-004472  ├─ ↔ CC码</text>
     <text x="770" y="444" font-size="10" fill="#444">运营商编码  CT-IPTV-...008923  ┘</text>
-    <text x="770" y="468" font-size="9" fill="#777">一个MA码解析出全部三方编码 + CDN端点</text>
+    <text x="770" y="468" font-size="9" fill="#777">一个CC码解析出全部三方编码 + CDN端点</text>
     <text x="770" y="481" font-size="9" fill="#2e7d32">→ 应急下架时一键定位全网资源</text>
   </g>
 
@@ -167,10 +167,10 @@
     <text x="90" y="758">Step1 母版哈希生成：全文件SHA-256 + 分段哈希 + 感知哈希</text>
     <text x="90" y="784">Step2 送审申报：登录备案系统，上传哈希值包（不传原文件）</text>
     <text x="110" y="804" fill="#777">片花/海报/剧本 + Merkle Tree根哈希 → 返回送审流水号</text>
-    <text x="90" y="830">Step3 审核通过：省级/总局签发MA码，MA码↔哈希包上链</text>
-    <text x="110" y="850" fill="#777">CP获"MA码+哈希证书"，方可进入播控平台</text>
+    <text x="90" y="830">Step3 审核通过：省级/总局签发CC码，CC码↔哈希包上链</text>
+    <text x="110" y="850" fill="#777">CP获"CC码+哈希证书"，方可进入播控平台</text>
     <text x="90" y="882" fill="#2e7d32" font-weight="bold">权限：注册哈希(送审时) · 验真自查 · 管理本方映射</text>
-    <text x="90" y="904" fill="#c62828">换壳重发：同哈希已存在 → 拒绝重复申报，关联原MA码</text>
+    <text x="90" y="904" fill="#c62828">换壳重发：同哈希已存在 → 拒绝重复申报，关联原CC码</text>
   </g>
 
   <!-- 播控平台端 -->
@@ -190,7 +190,7 @@
     <text x="970" y="632" text-anchor="middle" font-size="11" font-weight="bold" fill="#0d47a1">★ 验真+映射模块（新建）</text>
     <text x="970" y="650" text-anchor="middle" font-size="9" fill="#555">送审文件哈希验真</text>
     <text x="970" y="666" text-anchor="middle" font-size="9" fill="#555">转码版哈希绑定</text>
-    <text x="970" y="682" text-anchor="middle" font-size="9" fill="#555">建立播控流水号↔MA码映射</text>
+    <text x="970" y="682" text-anchor="middle" font-size="9" fill="#555">建立播控流水号↔CC码映射</text>
   </g>
 
   <g font-size="10" fill="#333">
@@ -201,9 +201,9 @@
     <text x="660" y="796" fill="#c62828">不匹配 → 直接退回，标记"疑似版本替换"</text>
     <text x="640" y="822">Step5 审核+转码：授权转码中心转码，重算各版本哈希</text>
     <text x="660" y="842" fill="#777">母版哈希与转码版建立父子关系上链</text>
-    <text x="640" y="868">Step6 EPG编排：建立 播控流水号↔MA码↔哈希 映射</text>
+    <text x="640" y="868">Step6 EPG编排：建立 播控流水号↔CC码↔哈希 映射</text>
     <text x="640" y="894" fill="#1565c0" font-weight="bold">权限：验真查询 · 本方映射管理 · 执行下架指令</text>
-    <text x="640" y="914" fill="#c62828">向运营商分发必须携带 MA码+哈希证书</text>
+    <text x="640" y="914" fill="#c62828">向运营商分发必须携带 CC码+哈希证书</text>
   </g>
 
   <!-- 运营商端 -->
@@ -234,7 +234,7 @@
     <text x="1210" y="796" fill="#c62828">不匹配 → 拒绝注入，告警退回播控平台</text>
     <text x="1190" y="822">Step8 EPG发布+终端播放：播放器SDK片段哈希抽检</text>
     <text x="1210" y="842" fill="#777">下载片段比对链上哈希，异常断流切备用源</text>
-    <text x="1190" y="868">Step9 数据上报：以MA码为统一维度聚合三方数据</text>
+    <text x="1190" y="868">Step9 数据上报：以CC码为统一维度聚合三方数据</text>
     <text x="1190" y="894" fill="#e65100" font-weight="bold">权限：验真查询 · 本方映射管理 · 执行下架指令</text>
     <text x="1190" y="914" fill="#777">CP播放量/播控审核量/运营商分发量口径一致</text>
   </g>
@@ -275,16 +275,16 @@
     <rect x="445" y="1000" width="390" height="150" rx="8" fill="#fff5f5" stroke="#c62828" stroke-width="1.5"/>
     <text x="640" y="1024" text-anchor="middle" font-size="13" font-weight="bold" fill="#b71c1c">价值② 精准溯源</text>
     <line x1="465" y1="1032" x2="815" y2="1032" stroke="#ffcdd2"/>
-    <text x="465" y="1056" font-size="10" fill="#444">凭一个MA码秒级定位三方系统</text>
+    <text x="465" y="1056" font-size="10" fill="#444">凭一个CC码秒级定位三方系统</text>
     <text x="465" y="1078" font-size="10" fill="#444">在哪个播控、哪个CDN、哪个哈希版本</text>
     <text x="465" y="1100" font-size="10" fill="#444">历史版本变更全程留痕</text>
-    <text x="465" y="1128" font-size="11" fill="#c62828" font-weight="bold">出问题 → MA码一键穿透全链路</text>
+    <text x="465" y="1128" font-size="11" fill="#c62828" font-weight="bold">出问题 → CC码一键穿透全链路</text>
   </g>
   <g>
     <rect x="850" y="1000" width="390" height="150" rx="8" fill="#fff5f5" stroke="#c62828" stroke-width="1.5"/>
     <text x="1045" y="1024" text-anchor="middle" font-size="13" font-weight="bold" fill="#b71c1c">价值③ 应急下架</text>
     <line x1="870" y1="1032" x2="1220" y2="1032" stroke="#ffcdd2"/>
-    <text x="870" y="1056" font-size="10" fill="#444">下发"下架MA码第XXX号"单一指令</text>
+    <text x="870" y="1056" font-size="10" fill="#444">下发"下架CC码第XXX号"单一指令</text>
     <text x="870" y="1078" font-size="10" fill="#444">系统自动翻译为三方编码下架动作</text>
     <text x="870" y="1100" font-size="10" fill="#444">无需人工逐层翻译/逐省协调</text>
     <text x="870" y="1128" font-size="11" fill="#c62828" font-weight="bold">下架响应：2-24小时 → 分钟级</text>
@@ -293,34 +293,34 @@
     <rect x="1255" y="1000" width="385" height="150" rx="8" fill="#fff5f5" stroke="#c62828" stroke-width="1.5"/>
     <text x="1447" y="1024" text-anchor="middle" font-size="13" font-weight="bold" fill="#b71c1c">价值④ 数据可信</text>
     <line x1="1275" y1="1032" x2="1625" y2="1032" stroke="#ffcdd2"/>
-    <text x="1275" y="1056" font-size="10" fill="#444">播放量/结算/上报以MA码统一聚合</text>
+    <text x="1275" y="1056" font-size="10" fill="#444">播放量/结算/上报以CC码统一聚合</text>
     <text x="1275" y="1078" font-size="10" fill="#444">三方数据同一口径，消除对账争议</text>
     <text x="1275" y="1100" font-size="10" fill="#444">监管掌握真实全网数据</text>
     <text x="1275" y="1128" font-size="11" fill="#c62828" font-weight="bold">三方对账差异：15-30% → &lt;5%</text>
   </g>
 
   <!-- ============ 跨省复用价值 ============ -->
-  <text x="40" y="1190" font-size="16" font-weight="bold" fill="#1a237e">⑤ 跨省复用流程 — "一码通行"：一省过审，全网凭MA码+哈希准入</text>
+  <text x="40" y="1190" font-size="16" font-weight="bold" fill="#1a237e">⑤ 跨省复用流程 — "一码通行"：一省过审，全网凭CC码+哈希准入</text>
 
   <rect x="40" y="1205" width="1620" height="130" rx="8" fill="#f3e5f5" stroke="#311b92" stroke-width="1.5"/>
   <g font-size="11">
     <!-- 流程步骤横向 -->
     <rect x="70" y="1235" width="230" height="70" rx="6" fill="white" stroke="#311b92"/>
     <text x="185" y="1262" text-anchor="middle" font-weight="bold" fill="#311b92">A省过审</text>
-    <text x="185" y="1283" text-anchor="middle" font-size="9" fill="#555">取得 MA码 + 哈希证书</text>
+    <text x="185" y="1283" text-anchor="middle" font-size="9" fill="#555">取得 CC码 + 哈希证书</text>
 
     <line x1="300" y1="1270" x2="345" y2="1270" stroke="#311b92" stroke-width="2.5" marker-end="url(#arrowBlue)"/>
 
     <rect x="350" y="1235" width="250" height="70" rx="6" fill="white" stroke="#311b92"/>
     <text x="475" y="1258" text-anchor="middle" font-weight="bold" fill="#311b92">向B省播控送审</text>
-    <text x="475" y="1278" text-anchor="middle" font-size="9" fill="#555">仅提交 MA码+哈希证书</text>
+    <text x="475" y="1278" text-anchor="middle" font-size="9" fill="#555">仅提交 CC码+哈希证书</text>
     <text x="475" y="1294" text-anchor="middle" font-size="9" fill="#c62828">无需重新提交内容文件</text>
 
     <line x1="600" y1="1270" x2="645" y2="1270" stroke="#311b92" stroke-width="2.5" marker-end="url(#arrowBlue)"/>
 
     <rect x="650" y="1235" width="280" height="70" rx="6" fill="white" stroke="#311b92"/>
     <text x="790" y="1258" text-anchor="middle" font-weight="bold" fill="#311b92">可信空间验真</text>
-    <text x="790" y="1278" text-anchor="middle" font-size="9" fill="#555">MA码有效 + 哈希一致 + 非黑名单</text>
+    <text x="790" y="1278" text-anchor="middle" font-size="9" fill="#555">CC码有效 + 哈希一致 + 非黑名单</text>
     <text x="790" y="1294" text-anchor="middle" font-size="9" fill="#555">三重校验通过</text>
 
     <line x1="930" y1="1270" x2="975" y2="1270" stroke="#311b92" stroke-width="2.5" marker-end="url(#arrowBlue)"/>
@@ -397,7 +397,7 @@
   <!-- ============ 总结框 ============ -->
   <rect x="40" y="1820" width="1620" height="120" rx="10" fill="url(#chainGrad)"/>
   <text x="850" y="1855" text-anchor="middle" fill="white" font-size="16" font-weight="bold">设计哲学：不替代现有系统，在三方之上建立"可信身份映射层"</text>
-  <text x="850" y="1888" text-anchor="middle" fill="#d1c4e9" font-size="13">MA码解决"是谁"（监管身份）· 哈希码解决"是不是"（数据真实）· 可信数据空间解决"在哪"（全链溯源）</text>
+  <text x="850" y="1888" text-anchor="middle" fill="#d1c4e9" font-size="13">CC码解决"是谁"（监管身份）· 哈希码解决"是不是"（数据真实）· 可信数据空间解决"在哪"（全链溯源）</text>
   <text x="850" y="1918" text-anchor="middle" fill="#b3c5ff" font-size="13" font-weight="bold">三者叠加 → 审过即锁定，锁定即通行，通行可追溯 · 监管从"逐层翻译滞后"升级为"一码穿透秒级响应"</text>
 
   <!-- 图例 -->
diff --git a/tcs-iptv/DELIVERY.md b/tcs-iptv/DELIVERY.md
index 6244662..100e947 100644
--- a/tcs-iptv/DELIVERY.md
+++ b/tcs-iptv/DELIVERY.md
@@ -39,7 +39,7 @@ TCS-IPTV 在 **内容提供商（CP）、审核和监管部门、运营商** 三
 ### 一期 MVP（核心闭环）
 送审 → CSPS审核 → 发码签发 → 媒资库入库 → 发布 → CDN注入校验 → 应急下架
 - 哈希SDK（文件SHA-256 / 分段Merkle / 感知哈希）
-- MA码生成（六段式，号段原子分配，PostgreSQL 行锁防重号）
+- CC码生成（六段式，号段原子分配，PostgreSQL 行锁防重号）
 - 可信数据空间（合约规则：1:1强绑定不可解绑、防换壳重发、权限控制）
 - 一剧一码 + 集级哈希 + 集级下架/恢复
 - HTTP API + HMAC 三角色权限 + 监管大屏（角色工作台/全流程演示/监管片库）
@@ -74,7 +74,7 @@ tcs-iptv/
 │   └── console-bff/    # 监管控制台 BFF（:8090，三期）
 ├── internal/
 │   ├── hash/           # 哈希核心（SHA256/Merkle/感知哈希）覆盖率88%
-│   ├── macode/         # MA码生成/解析/号段（含PG存储）覆盖率75%
+│   ├── cccode/         # CC码生成/解析/号段（含PG存储）覆盖率75%
 │   ├── chain/          # 可信数据空间抽象 + MemoryChain
 │   ├── service/        # 业务编排（覆盖率85%）
 │   ├── playback/       # 播放聚合与分账（覆盖率100%）
@@ -125,7 +125,7 @@ bash scripts/e2e_smoke.sh
 | 指标 | 状况 |
 |------|------|
 | 测试用例 | 83 个，全部通过 |
-| 核心覆盖率 | playback 100% / hash 88% / service 85% / macode 75% |
+| 核心覆盖率 | playback 100% / hash 88% / service 85% / cccode 75% |
 | go vet / build | 通过 |
 | 前端构建 | 通过 |
 | 端到端冒烟 | 一期→三期全相位通过 |
@@ -149,7 +149,7 @@ bash scripts/e2e_smoke.sh
 
 ## 八、安全说明
 
-- ✅ 已实现：HMAC-SHA256 鉴权、三角色权限矩阵、MA码1:1不可解绑、哈希本地计算不上链原片、关键操作存证、**监管大屏 BFF 化（密钥不下发浏览器）**
+- ✅ 已实现：HMAC-SHA256 鉴权、三角色权限矩阵、CC码1:1不可解绑、哈希本地计算不上链原片、关键操作存证、**监管大屏 BFF 化（密钥不下发浏览器）**
 - ⚠️ 上生产前：真实链替换、等保三级测评、HSM 托管、生产凭证接 Vault/SSO
 
 ---
diff --git a/tcs-iptv/README.md b/tcs-iptv/README.md
index 090cf89..fef4b9a 100644
--- a/tcs-iptv/README.md
+++ b/tcs-iptv/README.md
@@ -1,6 +1,6 @@
 # TCS-IPTV 内容可信锁定系统
 
-> MA码（监管身份）+ 哈希码（技术指纹）双锚定，在 CP / 审核和监管部门 / 运营商 三方系统之上建立"可信身份映射层"。
+> CC码（监管身份）+ 哈希码（技术指纹）双锚定，在 CP / 审核和监管部门 / 运营商 三方系统之上建立"可信身份映射层"。
 >
 > 上游文档：`../0-req-IPTV.md`（需求）、`../1-prd-IPTV.md`（PRD）、`../2-task-IPTV.md`（任务）
 
diff --git a/tcs-iptv/cmd/api-svc/main.go b/tcs-iptv/cmd/api-svc/main.go
index 9710949..8ab6b6d 100644
--- a/tcs-iptv/cmd/api-svc/main.go
+++ b/tcs-iptv/cmd/api-svc/main.go
@@ -11,7 +11,7 @@ import (
 	"github.com/tcs-iptv/tcs/internal/chain"
 	"github.com/tcs-iptv/tcs/internal/config"
 	"github.com/tcs-iptv/tcs/internal/httpx"
-	"github.com/tcs-iptv/tcs/internal/macode"
+	"github.com/tcs-iptv/tcs/internal/cccode"
 	"github.com/tcs-iptv/tcs/internal/monitor"
 	"github.com/tcs-iptv/tcs/internal/service"
 )
@@ -29,13 +29,13 @@ func openDB(dsn string) *sql.DB {
 }
 
 // newAllocationStore 优先使用 PostgreSQL（持久、防重号），不可用时回退内存。
-func newAllocationStore(db *sql.DB) macode.AllocationStore {
+func newAllocationStore(db *sql.DB) cccode.AllocationStore {
 	if db != nil {
-		log.Printf("macode: 使用 PostgreSQL 号段存储")
-		return macode.NewPostgresStore(db)
+		log.Printf("cccode: 使用 PostgreSQL 号段存储")
+		return cccode.NewPostgresStore(db)
 	}
-	log.Printf("macode: PostgreSQL 不可用，回退内存号段存储（仅开发用）")
-	return macode.NewMemoryStore()
+	log.Printf("cccode: PostgreSQL 不可用，回退内存号段存储（仅开发用）")
+	return cccode.NewMemoryStore()
 }
 
 // newChain 按配置选择链后端：
@@ -76,20 +76,20 @@ func main() {
 	// 装配依赖：共享一个 PG 连接给链持久化与号段存储
 	db := openDB(cfg.PostgresDSN)
 	ch := newChain(cfg.ChainBackend, cfg.ChainMakerSDKConf, db)
-	gen := macode.NewGenerator(newAllocationStore(db))
+	gen := cccode.NewGenerator(newAllocationStore(db))
 	// 示例号段（生产由与发码机构对接后配置）
 	// 机构节点 6101 = 陕西（管理方：陕西IPTV运营公司）；行业节点 8531 = IPTV视听内容
-	_ = gen.RegisterSegment(macode.Segment{
+	_ = gen.RegisterSegment(cccode.Segment{
 		IndustryNode: "8531", OrgNode: "6101",
-		Category: macode.CategoryMicroDrama, Start: 1, End: 9999999, SeqWidth: 7,
+		Category: cccode.CategoryMicroDrama, Start: 1, End: 9999999, SeqWidth: 7,
 	})
-	_ = gen.RegisterSegment(macode.Segment{
+	_ = gen.RegisterSegment(cccode.Segment{
 		IndustryNode: "8531", OrgNode: "6101",
-		Category: macode.CategoryWebSeries, Start: 1, End: 9999999, SeqWidth: 7,
+		Category: cccode.CategoryWebSeries, Start: 1, End: 9999999, SeqWidth: 7,
 	})
-	_ = gen.RegisterSegment(macode.Segment{
+	_ = gen.RegisterSegment(cccode.Segment{
 		IndustryNode: "8531", OrgNode: "6101",
-		Category: macode.CategoryWebMovie, Start: 1, End: 9999999, SeqWidth: 7,
+		Category: cccode.CategoryWebMovie, Start: 1, End: 9999999, SeqWidth: 7,
 	})
 	svc := service.New(ch, gen)
 	h := api.NewHandler(svc)
diff --git a/tcs-iptv/contracts/tcs_registry/README.md b/tcs-iptv/contracts/tcs_registry/README.md
index 32fe97a..5b82da9 100644
--- a/tcs-iptv/contracts/tcs_registry/README.md
+++ b/tcs-iptv/contracts/tcs_registry/README.md
@@ -8,14 +8,14 @@
 
 | 方法 | 权限 | 说明 |
 |------|------|------|
-| `IssueMA(maCode, ctid, merkleRoot, fileHash, contentJSON)` | 仅监管节点 | 签发 MA 码并 1:1 强绑定哈希；不可重复、不可解绑 |
+| `IssueMA(ccCode, ctid, merkleRoot, fileHash, contentJSON)` | 仅监管节点 | 签发 MA 码并 1:1 强绑定哈希；不可重复、不可解绑 |
 | `RegisterHashBinding(ctid, bindingJSON)` | 审核/监管 | 追加哈希绑定（转码版父子关系） |
 | `RegisterMapping(ctid, party, partyID, cdnEndpoint)` | 三方 | 注册编码映射；MA 必须已签发 |
-| `VerifyHash(maCode, fileHash) -> bool` | 任意 | 校验提交哈希与绑定哈希是否一致 |
-| `QueryContent(maCode) -> json` | 任意 | 查询内容主记录 |
-| `QueryMappings(maCode) -> json` | 任意 | 查询全部三方映射与 CDN 端点 |
+| `VerifyHash(ccCode, fileHash) -> bool` | 任意 | 校验提交哈希与绑定哈希是否一致 |
+| `QueryContent(ccCode) -> json` | 任意 | 查询内容主记录 |
+| `QueryMappings(ccCode) -> json` | 任意 | 查询全部三方映射与 CDN 端点 |
 | `RecordVersionChange(ctid, vcJSON)` | 审核/监管 | 记录版本变更，触发重审 |
-| `Revoke(maCode, reason)` | 仅监管节点 | 下架，返回受影响映射 |
+| `Revoke(ccCode, reason)` | 仅监管节点 | 下架，返回受影响映射 |
 
 ## 权限模型（对应需求14）
 
@@ -33,12 +33,12 @@
 ## 状态键设计（KV）
 
 ```
-content:{maCode}            -> Content JSON
-binding:{maCode}:{idx}      -> HashBinding JSON
-hashidx:{fileHash}          -> maCode      （防换壳重发）
-mapping:{maCode}:{idx}      -> Mapping JSON
-version:{maCode}:{idx}      -> VersionChange JSON
-ctid2ma:{ctid}             -> maCode
+content:{ccCode}            -> Content JSON
+binding:{ccCode}:{idx}      -> HashBinding JSON
+hashidx:{fileHash}          -> ccCode      （防换壳重发）
+mapping:{ccCode}:{idx}      -> Mapping JSON
+version:{ccCode}:{idx}      -> VersionChange JSON
+ctid2ma:{ctid}             -> ccCode
 ```
 
 ## 构建与部署（真实链，二期接入）
diff --git a/tcs-iptv/contracts/tcs_registry/registry.go b/tcs-iptv/contracts/tcs_registry/registry.go
index 2482640..94064d4 100644
--- a/tcs-iptv/contracts/tcs_registry/registry.go
+++ b/tcs-iptv/contracts/tcs_registry/registry.go
@@ -6,18 +6,18 @@
 //
 // 状态键设计（KV）：
 //
-//	content:{maCode}        -> Content JSON（含 status）
-//	binding:{maCode}:0      -> 整剧 file 哈希绑定 JSON
-//	binding:{maCode}:p      -> 感知哈希绑定 JSON
-//	ep:{maCode}:{n}         -> 集级绑定 JSON {episode,hash,revoked,reason}
-//	epcount:{maCode}        -> 集数 N
-//	hashidx:{fileHash}      -> maCode（防换壳重发）
-//	mapping:{maCode}:{idx}  -> Mapping JSON
-//	mapcount:{maCode}       -> 映射数 N
-//	version:{maCode}:{idx}  -> VersionChange JSON
-//	vercount:{maCode}       -> 版本变更数 N
-//	ctid2ma:{ctid}          -> maCode
-//	allmacodes              -> []maCode（供 ListContents 遍历）
+//	content:{ccCode}        -> Content JSON（含 status）
+//	binding:{ccCode}:0      -> 整剧 file 哈希绑定 JSON
+//	binding:{ccCode}:p      -> 感知哈希绑定 JSON
+//	ep:{ccCode}:{n}         -> 集级绑定 JSON {episode,hash,revoked,reason}
+//	epcount:{ccCode}        -> 集数 N
+//	hashidx:{fileHash}      -> ccCode（防换壳重发）
+//	mapping:{ccCode}:{idx}  -> Mapping JSON
+//	mapcount:{ccCode}       -> 映射数 N
+//	version:{ccCode}:{idx}  -> VersionChange JSON
+//	vercount:{ccCode}       -> 版本变更数 N
+//	ctid2ma:{ctid}          -> ccCode
+//	allcccodes              -> []ccCode（供 ListContents 遍历）
 //
 // 权限：通过 sender 组织证书判断（仅监管组织可 IssueMA/Revoke/RevokeEpisode/Restore）。
 package main
@@ -76,15 +76,15 @@ type epBinding struct {
 	Reason    string `json:"revoked_reason,omitempty"`
 }
 
-// appendMACode 把新发码加入全局列表（供 ListContents 遍历）。
-func appendMACode(maCode string) {
+// appendCCCode 把新发码加入全局列表（供 ListContents 遍历）。
+func appendCCCode(ccCode string) {
 	var all []string
-	if v, _ := sdk.Instance.GetStateByte("allmacodes", ""); len(v) > 0 {
+	if v, _ := sdk.Instance.GetStateByte("allcccodes", ""); len(v) > 0 {
 		_ = json.Unmarshal(v, &all)
 	}
-	all = append(all, maCode)
+	all = append(all, ccCode)
 	b, _ := json.Marshal(all)
-	_ = sdk.Instance.PutStateByte("allmacodes", "", b)
+	_ = sdk.Instance.PutStateByte("allcccodes", "", b)
 }
 
 // ---- 写方法 ----
@@ -95,11 +95,11 @@ func (t *TCSRegistry) IssueMA() protogo.Response {
 		return sdk.Error("permission denied: only regulator can issue MA")
 	}
 	args := sdk.Instance.GetArgs()
-	maCode := string(args["ma_code"])
+	ccCode := string(args["ma_code"])
 	ctid := string(args["ctid"])
 	fileHash := string(args["file_hash"])
 
-	if existing, _ := sdk.Instance.GetStateByte("content", maCode); len(existing) > 0 {
+	if existing, _ := sdk.Instance.GetStateByte("content", ccCode); len(existing) > 0 {
 		return sdk.Error("MA already issued (1:1 binding immutable)")
 	}
 	if bound, _ := sdk.Instance.GetStateByte("hashidx", fileHash); len(bound) > 0 {
@@ -112,21 +112,21 @@ func (t *TCSRegistry) IssueMA() protogo.Response {
 	if content == nil {
 		content = map[string]interface{}{}
 	}
-	content["ma_code"] = maCode
+	content["ma_code"] = ccCode
 	content["content_twin_id"] = ctid
 	content["status"] = "approved"
 	cj, _ := json.Marshal(content)
-	_ = sdk.Instance.PutStateByte("content", maCode, cj)
+	_ = sdk.Instance.PutStateByte("content", ccCode, cj)
 
 	// 整剧 file 绑定 + 感知哈希绑定
 	fb, _ := json.Marshal(epBinding{Episode: 0, HashValue: fileHash})
-	_ = sdk.Instance.PutStateByte("binding", maCode+":0", fb)
+	_ = sdk.Instance.PutStateByte("binding", ccCode+":0", fb)
 	if ph := string(args["perceptual_hash"]); ph != "" {
 		pb, _ := json.Marshal(map[string]string{"hash_type": "perceptual", "hash_value": ph})
-		_ = sdk.Instance.PutStateByte("binding", maCode+":p", pb)
+		_ = sdk.Instance.PutStateByte("binding", ccCode+":p", pb)
 	}
-	_ = sdk.Instance.PutStateByte("hashidx", fileHash, []byte(maCode))
-	_ = sdk.Instance.PutStateByte("ctid2ma", ctid, []byte(maCode))
+	_ = sdk.Instance.PutStateByte("hashidx", fileHash, []byte(ccCode))
+	_ = sdk.Instance.PutStateByte("ctid2ma", ctid, []byte(ccCode))
 
 	// 集级哈希
 	var eps []map[string]interface{}
@@ -139,19 +139,19 @@ func (t *TCSRegistry) IssueMA() protogo.Response {
 			continue
 		}
 		eb, _ := json.Marshal(epBinding{Episode: ep, HashValue: hv})
-		_ = sdk.Instance.PutStateByte("ep", maCode+":"+strconv.Itoa(ep), eb)
+		_ = sdk.Instance.PutStateByte("ep", ccCode+":"+strconv.Itoa(ep), eb)
 		if exist, _ := sdk.Instance.GetStateByte("hashidx", hv); len(exist) == 0 {
-			_ = sdk.Instance.PutStateByte("hashidx", hv, []byte(maCode))
+			_ = sdk.Instance.PutStateByte("hashidx", hv, []byte(ccCode))
 		}
 		if ep > n {
 			n = ep
 		}
 	}
-	putInt("epcount", maCode, n)
-	appendMACode(maCode)
+	putInt("epcount", ccCode, n)
+	appendCCCode(ccCode)
 
-	sdk.Instance.EmitEvent("RegisterSuccess", []string{maCode, fileHash})
-	return sdk.Success([]byte(maCode))
+	sdk.Instance.EmitEvent("RegisterSuccess", []string{ccCode, fileHash})
+	return sdk.Success([]byte(ccCode))
 }
 
 func toFloat(v interface{}) float64 {
@@ -226,8 +226,8 @@ func (t *TCSRegistry) SetContentStatus() protogo.Response {
 	return setStatus(string(args["ma_code"]), string(args["status"]), "StatusChanged")
 }
 
-func setStatus(maCode, status, event string) protogo.Response {
-	cj, _ := sdk.Instance.GetStateByte("content", maCode)
+func setStatus(ccCode, status, event string) protogo.Response {
+	cj, _ := sdk.Instance.GetStateByte("content", ccCode)
 	if len(cj) == 0 {
 		return sdk.Error("not found")
 	}
@@ -235,8 +235,8 @@ func setStatus(maCode, status, event string) protogo.Response {
 	_ = json.Unmarshal(cj, &content)
 	content["status"] = status
 	nj, _ := json.Marshal(content)
-	_ = sdk.Instance.PutStateByte("content", maCode, nj)
-	sdk.Instance.EmitEvent(event, []string{maCode, status})
+	_ = sdk.Instance.PutStateByte("content", ccCode, nj)
+	sdk.Instance.EmitEvent(event, []string{ccCode, status})
 	return sdk.Success([]byte("ok"))
 }
 
@@ -266,8 +266,8 @@ func (t *TCSRegistry) Restore() protogo.Response {
 	return setStatus(string(sdk.Instance.GetArgs()["ma_code"]), "published", "Restored")
 }
 
-func setEpisodeRevoked(maCode, epStr string, revoked bool, reason string) protogo.Response {
-	key := maCode + ":" + epStr
+func setEpisodeRevoked(ccCode, epStr string, revoked bool, reason string) protogo.Response {
+	key := ccCode + ":" + epStr
 	v, _ := sdk.Instance.GetStateByte("ep", key)
 	if len(v) == 0 {
 		return sdk.Error("not found")
@@ -316,11 +316,11 @@ func (t *TCSRegistry) HashExists() protogo.Response {
 
 // ListEpisodes 返回某 MA 的集级绑定数组（JSON）。
 func (t *TCSRegistry) ListEpisodes() protogo.Response {
-	maCode := string(sdk.Instance.GetArgs()["ma_code"])
-	n := getInt("epcount", maCode)
+	ccCode := string(sdk.Instance.GetArgs()["ma_code"])
+	n := getInt("epcount", ccCode)
 	out := make([]epBinding, 0, n)
 	for i := 1; i <= n; i++ {
-		if v, _ := sdk.Instance.GetStateByte("ep", maCode+":"+strconv.Itoa(i)); len(v) > 0 {
+		if v, _ := sdk.Instance.GetStateByte("ep", ccCode+":"+strconv.Itoa(i)); len(v) > 0 {
 			var eb epBinding
 			_ = json.Unmarshal(v, &eb)
 			out = append(out, eb)
@@ -341,12 +341,12 @@ func (t *TCSRegistry) QueryContent() protogo.Response {
 
 // QueryMappings 返回某 MA 的全部映射（JSON {mappings:[],cdn_endpoints:[]}）。
 func (t *TCSRegistry) QueryMappings() protogo.Response {
-	maCode := string(sdk.Instance.GetArgs()["ma_code"])
-	n := getInt("mapcount", maCode)
+	ccCode := string(sdk.Instance.GetArgs()["ma_code"])
+	n := getInt("mapcount", ccCode)
 	maps := make([]map[string]interface{}, 0, n)
 	cdns := []string{}
 	for i := 1; i <= n; i++ {
-		if v, _ := sdk.Instance.GetStateByte("mapping", maCode+":"+strconv.Itoa(i)); len(v) > 0 {
+		if v, _ := sdk.Instance.GetStateByte("mapping", ccCode+":"+strconv.Itoa(i)); len(v) > 0 {
 			var m map[string]interface{}
 			_ = json.Unmarshal(v, &m)
 			maps = append(maps, m)
@@ -355,7 +355,7 @@ func (t *TCSRegistry) QueryMappings() protogo.Response {
 			}
 		}
 	}
-	b, _ := json.Marshal(map[string]interface{}{"ma_code": maCode, "mappings": maps, "cdn_endpoints": cdns})
+	b, _ := json.Marshal(map[string]interface{}{"ma_code": ccCode, "mappings": maps, "cdn_endpoints": cdns})
 	return sdk.Success(b)
 }
 
@@ -363,7 +363,7 @@ func (t *TCSRegistry) QueryMappings() protogo.Response {
 func (t *TCSRegistry) ListContents() protogo.Response {
 	status := string(sdk.Instance.GetArgs()["status"])
 	var all []string
-	if v, _ := sdk.Instance.GetStateByte("allmacodes", ""); len(v) > 0 {
+	if v, _ := sdk.Instance.GetStateByte("allcccodes", ""); len(v) > 0 {
 		_ = json.Unmarshal(v, &all)
 	}
 	out := make([]map[string]interface{}, 0, len(all))
diff --git a/tcs-iptv/deploy/migrations/0002_macode_cursor.sql b/tcs-iptv/deploy/migrations/0002_cccode_cursor.sql
similarity index 78%
rename from tcs-iptv/deploy/migrations/0002_macode_cursor.sql
rename to tcs-iptv/deploy/migrations/0002_cccode_cursor.sql
index b8ae9f2..3e226dd 100644
--- a/tcs-iptv/deploy/migrations/0002_macode_cursor.sql
+++ b/tcs-iptv/deploy/migrations/0002_cccode_cursor.sql
@@ -3,12 +3,12 @@
 
 BEGIN;
 
-CREATE TABLE IF NOT EXISTS macode_cursor (
+CREATE TABLE IF NOT EXISTS cccode_cursor (
     segment_key VARCHAR(128) PRIMARY KEY,   -- {industryNode}:{orgNode}:{category}
     cursor      BIGINT NOT NULL,            -- 已分配的最大序列
     updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
 );
 
-COMMENT ON TABLE macode_cursor IS 'MA码号段分配游标，行级原子自增';
+COMMENT ON TABLE cccode_cursor IS 'CC码号段分配游标，行级原子自增';
 
 COMMIT;
diff --git a/tcs-iptv/internal/api/catalog_handlers.go b/tcs-iptv/internal/api/catalog_handlers.go
index 6c91584..b633bc2 100644
--- a/tcs-iptv/internal/api/catalog_handlers.go
+++ b/tcs-iptv/internal/api/catalog_handlers.go
@@ -29,12 +29,12 @@ func (h *CatalogHandler) Register(rg *gin.RouterGroup) {
 }
 
 func (h *CatalogHandler) queryByMA(c *gin.Context) {
-	maCode := c.Query("ma_code")
-	if maCode == "" {
+	ccCode := c.Query("ma_code")
+	if ccCode == "" {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "缺少 ma_code 参数")
 		return
 	}
-	result, err := h.cat.QueryByMA(maCode)
+	result, err := h.cat.QueryByMA(ccCode)
 	if err != nil {
 		httpx.Error(c, http.StatusNotFound, "NOT_FOUND", err.Error())
 		return
@@ -85,12 +85,12 @@ func (h *CatalogHandler) queryByLibraryID(c *gin.Context) {
 }
 
 func (h *CatalogHandler) queryAll(c *gin.Context) {
-	maCode := c.Query("ma_code")
-	if maCode == "" {
+	ccCode := c.Query("ma_code")
+	if ccCode == "" {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "缺少 ma_code 参数")
 		return
 	}
-	result, err := h.cat.QueryAll(maCode)
+	result, err := h.cat.QueryAll(ccCode)
 	if err != nil {
 		httpx.Error(c, http.StatusNotFound, "NOT_FOUND", err.Error())
 		return
diff --git a/tcs-iptv/internal/api/catalog_handlers_test.go b/tcs-iptv/internal/api/catalog_handlers_test.go
index 97f8a48..899c7d2 100644
--- a/tcs-iptv/internal/api/catalog_handlers_test.go
+++ b/tcs-iptv/internal/api/catalog_handlers_test.go
@@ -20,7 +20,7 @@ func TestCatalogHandler_QueryByMA(t *testing.T) {
 
 	// 发码
 	_, err := c.IssueMA(chain.RoleRegulator, chain.IssueRequest{
-		MACode: "MA.156.8531.6101/WD/20260000001", ContentTwinID: "ctid-cat-svc-001",
+		CCCode: "MA.156.8531.6101/WD/20260000001", ContentTwinID: "ctid-cat-svc-001",
 		FileHash: "fh-cat-svc-001", MerkleRoot: "mr-cat-svc-001",
 		Content: model.Content{Title: "目录库服务测试", MAType: "WD", Issuer: "测试局"},
 	})
@@ -55,7 +55,7 @@ func TestCatalogHandler_QueryByHash(t *testing.T) {
 	c := chain.NewMemoryChain()
 
 	_, err := c.IssueMA(chain.RoleRegulator, chain.IssueRequest{
-		MACode: "MA.156.8531.6101/WD/20260000002", ContentTwinID: "ctid-cat-svc-002",
+		CCCode: "MA.156.8531.6101/WD/20260000002", ContentTwinID: "ctid-cat-svc-002",
 		FileHash: "fh-cat-svc-002", MerkleRoot: "mr-cat-svc-002",
 		Content: model.Content{Title: "Hash查询服务测试", MAType: "WD", Issuer: "测试局"},
 	})
@@ -81,7 +81,7 @@ func TestCatalogHandler_QueryByHash(t *testing.T) {
 	err = json.Unmarshal(w.Body.Bytes(), &resp)
 	require.NoError(t, err)
 	assert.True(t, resp.Data.Found)
-	assert.Equal(t, "MA.156.8531.6101/WD/20260000002", resp.Data.Content.MACode)
+	assert.Equal(t, "MA.156.8531.6101/WD/20260000002", resp.Data.Content.CCCode)
 
 	// 缺少参数
 	w2 := httptest.NewRecorder()
diff --git a/tcs-iptv/internal/api/handlers.go b/tcs-iptv/internal/api/handlers.go
index 0f3e78f..fa6c8e7 100644
--- a/tcs-iptv/internal/api/handlers.go
+++ b/tcs-iptv/internal/api/handlers.go
@@ -44,7 +44,7 @@ func (h *Handler) Register(rg *gin.RouterGroup) {
 	rg.GET("/content/reviews", h.listReviews)               // 送审待办队列（待审/待发码）
 	rg.GET("/content/list", h.listContents)                 // 内容队列（待入库/待发布/待注入）
 	rg.POST("/data/playback", h.reportPlayback)             // 播放数据回传（需求9）
-	rg.GET("/data/playback-summary", h.playbackSummary)     // 按MA码聚合可信播放数据（需求9/21）
+	rg.GET("/data/playback-summary", h.playbackSummary)     // 按CC码聚合可信播放数据（需求9/21）
 	rg.POST("/settlement/compute", h.computeSettlement)     // 基于可信播放数据分账（需求21）
 	rg.GET("/content/provenance", h.provenance)             // 全链路存证（需求22）
 	rg.GET("/content/accountability", h.accountability)     // 责任界定取证（需求22）
@@ -147,7 +147,7 @@ func (h *Handler) issue(c *gin.Context) {
 }
 
 type verifyReq struct {
-	MACode   string `json:"ma_code"`
+	CCCode   string `json:"ma_code"`
 	FileHash string `json:"file_sha256"`
 }
 
@@ -157,7 +157,7 @@ func (h *Handler) verify(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	res, err := h.svc.Verify(req.MACode, req.FileHash)
+	res, err := h.svc.Verify(req.CCCode, req.FileHash)
 	if err != nil {
 		// 验真不匹配也返回结果体，便于调用方据 match 处理
 		httpx.Error(c, http.StatusBadRequest, "VERIFY_MISMATCH", err.Error())
@@ -210,7 +210,7 @@ func (h *Handler) bindTranscoded(c *gin.Context) {
 }
 
 type ingestReq struct {
-	MACode       string `json:"ma_code"`
+	CCCode       string `json:"ma_code"`
 	CTID         string `json:"content_twin_id"`
 	MediaAssetID string `json:"media_asset_id"`
 	LibName      string `json:"lib_name"`
@@ -222,15 +222,15 @@ func (h *Handler) ingest(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	if err := h.svc.IngestToLibrary(roleOf(c), req.MACode, req.CTID, req.MediaAssetID, req.LibName); err != nil {
+	if err := h.svc.IngestToLibrary(roleOf(c), req.CCCode, req.CTID, req.MediaAssetID, req.LibName); err != nil {
 		httpx.Error(c, http.StatusBadRequest, "INGEST_FAILED", err.Error())
 		return
 	}
-	httpx.OK(c, gin.H{"ma_code": req.MACode, "status": "in_library"})
+	httpx.OK(c, gin.H{"ma_code": req.CCCode, "status": "in_library"})
 }
 
 type publishReq struct {
-	MACode      string `json:"ma_code"`
+	CCCode      string `json:"ma_code"`
 	Certificate string `json:"certificate"`
 }
 
@@ -240,16 +240,16 @@ func (h *Handler) publish(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	if err := h.svc.PublishToOperator(service.PublishRequest{MACode: req.MACode, Certificate: req.Certificate}); err != nil {
+	if err := h.svc.PublishToOperator(service.PublishRequest{CCCode: req.CCCode, Certificate: req.Certificate}); err != nil {
 		httpx.Error(c, http.StatusBadRequest, "PUBLISH_FAILED", err.Error())
 		return
 	}
-	httpx.OK(c, gin.H{"ma_code": req.MACode, "status": "published"})
+	httpx.OK(c, gin.H{"ma_code": req.CCCode, "status": "published"})
 }
 
 type injectReq struct {
 	CTID        string `json:"content_twin_id"`
-	MACode      string `json:"ma_code"`
+	CCCode      string `json:"ma_code"`
 	FileHash    string `json:"file_sha256"`
 	OperatorID  string `json:"operator_id"`
 	CDNEndpoint string `json:"cdn_endpoint"`
@@ -261,7 +261,7 @@ func (h *Handler) inject(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	res, err := h.svc.InjectToCDN(roleOf(c), req.CTID, req.MACode, req.FileHash, req.OperatorID, req.CDNEndpoint)
+	res, err := h.svc.InjectToCDN(roleOf(c), req.CTID, req.CCCode, req.FileHash, req.OperatorID, req.CDNEndpoint)
 	if err != nil {
 		httpx.Error(c, http.StatusBadRequest, "INJECT_REJECTED", err.Error())
 		return
@@ -293,7 +293,7 @@ func (h *Handler) versionChange(c *gin.Context) {
 }
 
 type takedownReq struct {
-	MACode string `json:"ma_code"`
+	CCCode string `json:"ma_code"`
 	Reason string `json:"reason"`
 }
 
@@ -303,7 +303,7 @@ func (h *Handler) takedown(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	res, err := h.svc.Takedown(roleOf(c), req.MACode, req.Reason)
+	res, err := h.svc.Takedown(roleOf(c), req.CCCode, req.Reason)
 	if err != nil {
 		httpx.Error(c, http.StatusForbidden, "TAKEDOWN_FAILED", err.Error())
 		return
@@ -312,7 +312,7 @@ func (h *Handler) takedown(c *gin.Context) {
 }
 
 type takedownEpisodeReq struct {
-	MACode  string `json:"ma_code"`
+	CCCode  string `json:"ma_code"`
 	Episode int    `json:"episode"`
 	Reason  string `json:"reason"`
 }
@@ -323,11 +323,11 @@ func (h *Handler) takedownEpisode(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	if err := h.svc.TakedownEpisode(roleOf(c), req.MACode, req.Episode, req.Reason); err != nil {
+	if err := h.svc.TakedownEpisode(roleOf(c), req.CCCode, req.Episode, req.Reason); err != nil {
 		httpx.Error(c, http.StatusForbidden, "TAKEDOWN_EPISODE_FAILED", err.Error())
 		return
 	}
-	httpx.OK(c, gin.H{"ma_code": req.MACode, "episode": req.Episode, "revoked": true})
+	httpx.OK(c, gin.H{"ma_code": req.CCCode, "episode": req.Episode, "revoked": true})
 }
 
 func (h *Handler) restore(c *gin.Context) {
@@ -336,11 +336,11 @@ func (h *Handler) restore(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	if err := h.svc.Restore(roleOf(c), req.MACode); err != nil {
+	if err := h.svc.Restore(roleOf(c), req.CCCode); err != nil {
 		httpx.Error(c, http.StatusForbidden, "RESTORE_FAILED", err.Error())
 		return
 	}
-	httpx.OK(c, gin.H{"ma_code": req.MACode, "status": "published"})
+	httpx.OK(c, gin.H{"ma_code": req.CCCode, "status": "published"})
 }
 
 func (h *Handler) restoreEpisode(c *gin.Context) {
@@ -349,20 +349,20 @@ func (h *Handler) restoreEpisode(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	if err := h.svc.RestoreEpisode(roleOf(c), req.MACode, req.Episode); err != nil {
+	if err := h.svc.RestoreEpisode(roleOf(c), req.CCCode, req.Episode); err != nil {
 		httpx.Error(c, http.StatusForbidden, "RESTORE_EPISODE_FAILED", err.Error())
 		return
 	}
-	httpx.OK(c, gin.H{"ma_code": req.MACode, "episode": req.Episode, "revoked": false})
+	httpx.OK(c, gin.H{"ma_code": req.CCCode, "episode": req.Episode, "revoked": false})
 }
 
 func (h *Handler) mappings(c *gin.Context) {
-	maCode := c.Query("ma_code")
-	if maCode == "" {
+	ccCode := c.Query("ma_code")
+	if ccCode == "" {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "缺少 ma_code")
 		return
 	}
-	res, err := h.svc.QueryMappings(maCode)
+	res, err := h.svc.QueryMappings(ccCode)
 	if err != nil {
 		httpx.Error(c, http.StatusNotFound, "NOT_FOUND", err.Error())
 		return
@@ -371,7 +371,7 @@ func (h *Handler) mappings(c *gin.Context) {
 }
 
 type verifyEpisodeReq struct {
-	MACode   string `json:"ma_code"`
+	CCCode   string `json:"ma_code"`
 	Episode  int    `json:"episode"`
 	FileHash string `json:"file_sha256"`
 }
@@ -382,7 +382,7 @@ func (h *Handler) verifyEpisode(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	res, err := h.svc.VerifyEpisode(req.MACode, req.Episode, req.FileHash)
+	res, err := h.svc.VerifyEpisode(req.CCCode, req.Episode, req.FileHash)
 	if err != nil {
 		httpx.Error(c, http.StatusBadRequest, "VERIFY_MISMATCH", err.Error())
 		return
@@ -391,17 +391,17 @@ func (h *Handler) verifyEpisode(c *gin.Context) {
 }
 
 func (h *Handler) listEpisodes(c *gin.Context) {
-	maCode := c.Query("ma_code")
-	if maCode == "" {
+	ccCode := c.Query("ma_code")
+	if ccCode == "" {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "缺少 ma_code")
 		return
 	}
-	eps, err := h.svc.ListEpisodes(maCode)
+	eps, err := h.svc.ListEpisodes(ccCode)
 	if err != nil {
 		httpx.Error(c, http.StatusNotFound, "NOT_FOUND", err.Error())
 		return
 	}
-	httpx.OK(c, gin.H{"ma_code": maCode, "episodes": eps, "count": len(eps)})
+	httpx.OK(c, gin.H{"ma_code": ccCode, "episodes": eps, "count": len(eps)})
 }
 
 func (h *Handler) listReviews(c *gin.Context) {
@@ -422,7 +422,7 @@ func (h *Handler) listContents(c *gin.Context) {
 type playbackReq struct {
 	PlatformID string `json:"platform_id"`
 	Batch      []struct {
-		MACode      string `json:"ma_code"`
+		CCCode      string `json:"ma_code"`
 		Episode     int    `json:"episode"`
 		UserHash    string `json:"user_hash"`
 		EventType   string `json:"event_type"`
@@ -440,7 +440,7 @@ func (h *Handler) reportPlayback(c *gin.Context) {
 	events := make([]model.PlaybackEvent, 0, len(req.Batch))
 	for _, b := range req.Batch {
 		events = append(events, model.PlaybackEvent{
-			MACode: b.MACode, Episode: b.Episode, PlatformID: req.PlatformID,
+			CCCode: b.CCCode, Episode: b.Episode, PlatformID: req.PlatformID,
 			UserHash: b.UserHash, EventType: model.PlaybackEventType(b.EventType),
 			DurationSec: b.DurationSec, RevenueCent: b.RevenueCent, EventTime: time.Now(),
 		})
@@ -450,16 +450,16 @@ func (h *Handler) reportPlayback(c *gin.Context) {
 }
 
 func (h *Handler) playbackSummary(c *gin.Context) {
-	maCode := c.Query("ma_code")
-	if maCode == "" {
+	ccCode := c.Query("ma_code")
+	if ccCode == "" {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "缺少 ma_code")
 		return
 	}
-	httpx.OK(c, h.svc.PlaybackSummary(maCode))
+	httpx.OK(c, h.svc.PlaybackSummary(ccCode))
 }
 
 type settlementReq struct {
-	MACode string `json:"ma_code"`
+	CCCode string `json:"ma_code"`
 	Period string `json:"period"`
 }
 
@@ -469,7 +469,7 @@ func (h *Handler) computeSettlement(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	st, err := h.svc.ComputeSettlement(req.MACode, req.Period)
+	st, err := h.svc.ComputeSettlement(req.CCCode, req.Period)
 	if err != nil {
 		httpx.Error(c, http.StatusBadRequest, "SETTLEMENT_FAILED", err.Error())
 		return
@@ -480,30 +480,30 @@ func (h *Handler) computeSettlement(c *gin.Context) {
 // ---- 二期：追责取证与确权举证（需求22/23） ----
 
 func (h *Handler) provenance(c *gin.Context) {
-	maCode := c.Query("ma_code")
-	if maCode == "" {
+	ccCode := c.Query("ma_code")
+	if ccCode == "" {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "缺少 ma_code")
 		return
 	}
-	httpx.OK(c, gin.H{"ma_code": maCode, "trail": h.svc.Provenance(maCode)})
+	httpx.OK(c, gin.H{"ma_code": ccCode, "trail": h.svc.Provenance(ccCode)})
 }
 
 func (h *Handler) accountability(c *gin.Context) {
-	maCode := c.Query("ma_code")
-	if maCode == "" {
+	ccCode := c.Query("ma_code")
+	if ccCode == "" {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "缺少 ma_code")
 		return
 	}
-	httpx.OK(c, h.svc.Accountability(maCode))
+	httpx.OK(c, h.svc.Accountability(ccCode))
 }
 
 func (h *Handler) evidence(c *gin.Context) {
-	maCode := c.Query("ma_code")
-	if maCode == "" {
+	ccCode := c.Query("ma_code")
+	if ccCode == "" {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "缺少 ma_code")
 		return
 	}
-	ev, err := h.svc.CopyrightEvidence(maCode)
+	ev, err := h.svc.CopyrightEvidence(ccCode)
 	if err != nil {
 		httpx.Error(c, http.StatusNotFound, "NOT_FOUND", err.Error())
 		return
@@ -540,7 +540,7 @@ func (h *Handler) infringeMatch(c *gin.Context) {
 // ---- 二期：授权链/追更/跨省/终端抽检（需求25/24/13/8） ----
 
 type authorizeReq struct {
-	MACode    string   `json:"ma_code"`
+	CCCode    string   `json:"ma_code"`
 	Regions   []string `json:"regions"`
 	Platforms []string `json:"platforms"`
 	ExpiryAt  string   `json:"expiry_at"` // RFC3339，空=长期
@@ -556,15 +556,15 @@ func (h *Handler) authorize(c *gin.Context) {
 	if req.ExpiryAt != "" {
 		expiry, _ = time.Parse(time.RFC3339, req.ExpiryAt)
 	}
-	if err := h.svc.RecordAuthorization(req.MACode, req.Regions, req.Platforms, expiry); err != nil {
+	if err := h.svc.RecordAuthorization(req.CCCode, req.Regions, req.Platforms, expiry); err != nil {
 		httpx.Error(c, http.StatusBadRequest, "AUTHORIZE_FAILED", err.Error())
 		return
 	}
-	httpx.OK(c, gin.H{"ma_code": req.MACode, "authorized": true})
+	httpx.OK(c, gin.H{"ma_code": req.CCCode, "authorized": true})
 }
 
 type authCheckReq struct {
-	MACode   string `json:"ma_code"`
+	CCCode   string `json:"ma_code"`
 	Region   string `json:"region"`
 	Platform string `json:"platform"`
 }
@@ -575,11 +575,11 @@ func (h *Handler) authCheck(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	httpx.OK(c, h.svc.CheckAuthorization(req.MACode, req.Region, req.Platform))
+	httpx.OK(c, h.svc.CheckAuthorization(req.CCCode, req.Region, req.Platform))
 }
 
 type addEpisodesReq struct {
-	MACode   string `json:"ma_code"`
+	CCCode   string `json:"ma_code"`
 	Episodes []struct {
 		Episode    int    `json:"episode"`
 		FileSHA256 string `json:"file_sha256"`
@@ -597,15 +597,15 @@ func (h *Handler) addEpisodes(c *gin.Context) {
 	for _, e := range req.Episodes {
 		eps = append(eps, model.EpisodeHash{Episode: e.Episode, FileSHA256: e.FileSHA256, MerkleRoot: e.MerkleRoot})
 	}
-	if err := h.svc.AddEpisodes(roleOf(c), req.MACode, eps); err != nil {
+	if err := h.svc.AddEpisodes(roleOf(c), req.CCCode, eps); err != nil {
 		httpx.Error(c, http.StatusBadRequest, "ADD_EPISODES_FAILED", err.Error())
 		return
 	}
-	httpx.OK(c, gin.H{"ma_code": req.MACode, "added": len(eps)})
+	httpx.OK(c, gin.H{"ma_code": req.CCCode, "added": len(eps)})
 }
 
 type crossProvinceReq struct {
-	MACode   string `json:"ma_code"`
+	CCCode   string `json:"ma_code"`
 	FileHash string `json:"file_sha256"`
 	Province string `json:"province"`
 }
@@ -616,11 +616,11 @@ func (h *Handler) crossProvince(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	httpx.OK(c, h.svc.CrossProvinceAdmit(req.MACode, req.FileHash, req.Province))
+	httpx.OK(c, h.svc.CrossProvinceAdmit(req.CCCode, req.FileHash, req.Province))
 }
 
 type terminalVerifyReq struct {
-	MACode  string `json:"ma_code"`
+	CCCode  string `json:"ma_code"`
 	Episode int    `json:"episode"`
 	SegHash string `json:"segment_hash"`
 }
@@ -631,14 +631,14 @@ func (h *Handler) terminalVerify(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	ok, msg := h.svc.TerminalVerifySegment(req.MACode, req.Episode, req.SegHash)
+	ok, msg := h.svc.TerminalVerifySegment(req.CCCode, req.Episode, req.SegHash)
 	httpx.OK(c, gin.H{"ok": ok, "message": msg})
 }
 
 // ---- 三期：备案对接/全国统计/监管上报/号段管理 ----
 
 type bindFilingReq struct {
-	MACode    string `json:"ma_code"`
+	CCCode    string `json:"ma_code"`
 	LicenseNo string `json:"license_no"`
 	FilingNo  string `json:"filing_no"`
 }
@@ -649,7 +649,7 @@ func (h *Handler) bindFiling(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	rec, err := h.svc.BindFiling(req.MACode, req.LicenseNo, req.FilingNo)
+	rec, err := h.svc.BindFiling(req.CCCode, req.LicenseNo, req.FilingNo)
 	if err != nil {
 		httpx.Error(c, http.StatusBadRequest, "BIND_FILING_FAILED", err.Error())
 		return
@@ -658,8 +658,8 @@ func (h *Handler) bindFiling(c *gin.Context) {
 }
 
 func (h *Handler) queryFiling(c *gin.Context) {
-	maCode := c.Query("ma_code")
-	rec, ok := h.svc.QueryFiling(maCode)
+	ccCode := c.Query("ma_code")
+	rec, ok := h.svc.QueryFiling(ccCode)
 	if !ok {
 		httpx.Error(c, http.StatusNotFound, "NOT_FOUND", "未关联备案")
 		return
@@ -696,16 +696,16 @@ func (h *Handler) listSegments(c *gin.Context) {
 // ---- 四期：大小屏融合（跨域解析/扫码验真/跨屏权益）----
 
 func (h *Handler) resolve(c *gin.Context) {
-	maCode := c.Query("ma_code")
-	if maCode == "" {
+	ccCode := c.Query("ma_code")
+	if ccCode == "" {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "缺少 ma_code")
 		return
 	}
-	httpx.OK(c, h.svc.Resolve(maCode))
+	httpx.OK(c, h.svc.Resolve(ccCode))
 }
 
 type scanVerifyReq struct {
-	MACode string `json:"ma_code"`
+	CCCode string `json:"ma_code"`
 }
 
 func (h *Handler) scanVerify(c *gin.Context) {
@@ -714,11 +714,11 @@ func (h *Handler) scanVerify(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	httpx.OK(c, h.svc.ScanVerify(req.MACode))
+	httpx.OK(c, h.svc.ScanVerify(req.CCCode))
 }
 
 type purchaseReq struct {
-	MACode   string `json:"ma_code"`
+	CCCode   string `json:"ma_code"`
 	UserHash string `json:"user_hash"`
 	Screen   string `json:"screen"` // iptv/ott/app
 }
@@ -729,7 +729,7 @@ func (h *Handler) recordPurchase(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	rec, err := h.svc.RecordPurchase(req.MACode, req.UserHash, model.ScreenType(req.Screen))
+	rec, err := h.svc.RecordPurchase(req.CCCode, req.UserHash, model.ScreenType(req.Screen))
 	if err != nil {
 		httpx.Error(c, http.StatusBadRequest, "PURCHASE_FAILED", err.Error())
 		return
@@ -738,7 +738,7 @@ func (h *Handler) recordPurchase(c *gin.Context) {
 }
 
 type verifyRightsReq struct {
-	MACode   string `json:"ma_code"`
+	CCCode   string `json:"ma_code"`
 	UserHash string `json:"user_hash"`
 	Screen   string `json:"screen"` // 当前请求屏
 }
@@ -749,7 +749,7 @@ func (h *Handler) verifyRights(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	httpx.OK(c, h.svc.VerifyCrossScreenRights(req.MACode, req.UserHash, model.ScreenType(req.Screen)))
+	httpx.OK(c, h.svc.VerifyCrossScreenRights(req.CCCode, req.UserHash, model.ScreenType(req.Screen)))
 }
 
 // ---- 多维度标识查询 handlers ----
@@ -808,7 +808,7 @@ func (h *Handler) mergeMA(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	res, err := h.svc.MergeMACodes(roleOf(c), req)
+	res, err := h.svc.MergeCCCodes(roleOf(c), req)
 	if err != nil {
 		httpx.Error(c, http.StatusBadRequest, "MERGE_FAILED", err.Error())
 		return
@@ -823,7 +823,7 @@ func (h *Handler) splitMA(c *gin.Context) {
 		httpx.Error(c, http.StatusBadRequest, "INVALID_REQUEST", err.Error())
 		return
 	}
-	res, err := h.svc.SplitMACode(roleOf(c), req)
+	res, err := h.svc.SplitCCCode(roleOf(c), req)
 	if err != nil {
 		httpx.Error(c, http.StatusBadRequest, "SPLIT_FAILED", err.Error())
 		return
diff --git a/tcs-iptv/internal/api/integration_test.go b/tcs-iptv/internal/api/integration_test.go
index beb3b5e..bb435e1 100644
--- a/tcs-iptv/internal/api/integration_test.go
+++ b/tcs-iptv/internal/api/integration_test.go
@@ -14,7 +14,7 @@ import (
 	"github.com/tcs-iptv/tcs/internal/chain"
 	"github.com/tcs-iptv/tcs/internal/hash"
 	"github.com/tcs-iptv/tcs/internal/httpx"
-	"github.com/tcs-iptv/tcs/internal/macode"
+	"github.com/tcs-iptv/tcs/internal/cccode"
 	"github.com/tcs-iptv/tcs/internal/service"
 )
 
@@ -24,10 +24,10 @@ func testServer(t *testing.T) (*httptest.Server, *httpx.MemoryKeyStore) {
 	gin.SetMode(gin.TestMode)
 
 	ch := chain.NewMemoryChain()
-	gen := macode.NewGenerator(macode.NewMemoryStore())
-	require.NoError(t, gen.RegisterSegment(macode.Segment{
+	gen := cccode.NewGenerator(cccode.NewMemoryStore())
+	require.NoError(t, gen.RegisterSegment(cccode.Segment{
 		IndustryNode: "8531", OrgNode: "4401",
-		Category: macode.CategoryMicroDrama, Start: 1, End: 9999999, SeqWidth: 7,
+		Category: cccode.CategoryMicroDrama, Start: 1, End: 9999999, SeqWidth: 7,
 	}))
 	svc := service.New(ch, gen)
 	h := NewHandler(svc)
@@ -115,39 +115,39 @@ func TestE2E_FullLifecycle(t *testing.T) {
 		"review_id": reviewID, "issuer": "北京市广播电视局",
 	})
 	require.Equal(t, http.StatusOK, st)
-	maCode := dataOf(resp)["ma_code"].(string)
+	ccCode := dataOf(resp)["ma_code"].(string)
 	cert := dataOf(resp)["certificate"].(string)
-	assert.True(t, macode.IsValid(maCode))
+	assert.True(t, cccode.IsValid(ccCode))
 
 	// 4) 入媒资库
 	st, _ = signedCall(t, b, "ak-reviewer", "sk-reviewer", "POST", "/content/ingest", map[string]any{
-		"ma_code": maCode, "content_twin_id": ctid, "media_asset_id": "MEDIA-001", "lib_name": "广东IPTV媒资库",
+		"ma_code": ccCode, "content_twin_id": ctid, "media_asset_id": "MEDIA-001", "lib_name": "广东IPTV媒资库",
 	})
 	require.Equal(t, http.StatusOK, st)
 
 	// 5) 发布
 	st, _ = signedCall(t, b, "ak-reviewer", "sk-reviewer", "POST", "/content/publish", map[string]any{
-		"ma_code": maCode, "certificate": cert,
+		"ma_code": ccCode, "certificate": cert,
 	})
 	require.Equal(t, http.StatusOK, st)
 
 	// 6) CDN 注入（匹配）
 	st, resp = signedCall(t, b, "ak-operator", "sk-operator", "POST", "/content/inject", map[string]any{
-		"content_twin_id": ctid, "ma_code": maCode, "file_sha256": "fh-e2e",
+		"content_twin_id": ctid, "ma_code": ccCode, "file_sha256": "fh-e2e",
 		"operator_id": "CT-IPTV-GD", "cdn_endpoint": "cdn://ct-gd/vod/1",
 	})
 	require.Equal(t, http.StatusOK, st)
 	assert.Equal(t, true, dataOf(resp)["allowed"])
 
 	// 7) 映射查询
-	st, resp = signedCall(t, b, "ak-regulator", "sk-regulator", "GET", "/content/mappings?ma_code="+maCode, nil)
+	st, resp = signedCall(t, b, "ak-regulator", "sk-regulator", "GET", "/content/mappings?ma_code="+ccCode, nil)
 	require.Equal(t, http.StatusOK, st)
 	mappings := dataOf(resp)["mappings"].([]any)
 	assert.Len(t, mappings, 3) // cp + reviewer + operator
 
 	// 8) 监管下架
 	st, resp = signedCall(t, b, "ak-regulator", "sk-regulator", "POST", "/content/takedown", map[string]any{
-		"ma_code": maCode, "reason": "违规",
+		"ma_code": ccCode, "reason": "违规",
 	})
 	require.Equal(t, http.StatusOK, st)
 	assert.NotEmpty(t, dataOf(resp)["cdn_endpoints"])
@@ -171,14 +171,14 @@ func TestE2E_TamperRejected(t *testing.T) {
 	_, resp = signedCall(t, b, "ak-regulator", "sk-regulator", "POST", "/content/issue", map[string]any{
 		"review_id": reviewID, "issuer": "x",
 	})
-	maCode := dataOf(resp)["ma_code"].(string)
+	ccCode := dataOf(resp)["ma_code"].(string)
 	cert := dataOf(resp)["certificate"].(string)
-	signedCall(t, b, "ak-reviewer", "sk-reviewer", "POST", "/content/ingest", map[string]any{"ma_code": maCode, "content_twin_id": ctid, "media_asset_id": "M", "lib_name": "L"})
-	signedCall(t, b, "ak-reviewer", "sk-reviewer", "POST", "/content/publish", map[string]any{"ma_code": maCode, "certificate": cert})
+	signedCall(t, b, "ak-reviewer", "sk-reviewer", "POST", "/content/ingest", map[string]any{"ma_code": ccCode, "content_twin_id": ctid, "media_asset_id": "M", "lib_name": "L"})
+	signedCall(t, b, "ak-reviewer", "sk-reviewer", "POST", "/content/publish", map[string]any{"ma_code": ccCode, "certificate": cert})
 
 	// 篡改文件注入 → 拒绝
 	st, _ = signedCall(t, b, "ak-operator", "sk-operator", "POST", "/content/inject", map[string]any{
-		"content_twin_id": ctid, "ma_code": maCode, "file_sha256": "fh-TAMPERED",
+		"content_twin_id": ctid, "ma_code": ccCode, "file_sha256": "fh-TAMPERED",
 		"operator_id": "OP", "cdn_endpoint": "cdn://x",
 	})
 	assert.Equal(t, http.StatusBadRequest, st, "篡改注入必须被拒")
@@ -235,14 +235,14 @@ func TestE2E_PermissionMatrix(t *testing.T) {
 
 	// 正常签发
 	_, resp = signedCall(t, b, "ak-regulator", "sk-regulator", "POST", "/content/issue", map[string]any{"review_id": reviewID, "issuer": "x"})
-	maCode := dataOf(resp)["ma_code"].(string)
+	ccCode := dataOf(resp)["ma_code"].(string)
 
 	// 运营商越权下架 → 403
-	st, _ = signedCall(t, b, "ak-operator", "sk-operator", "POST", "/content/takedown", map[string]any{"ma_code": maCode, "reason": "越权"})
+	st, _ = signedCall(t, b, "ak-operator", "sk-operator", "POST", "/content/takedown", map[string]any{"ma_code": ccCode, "reason": "越权"})
 	assert.Equal(t, http.StatusForbidden, st, "运营商不得发起下架")
 
 	// 无效签名 → 401
-	req, _ := http.NewRequest("GET", b+"/api/v1/content/mappings?ma_code="+maCode, nil)
+	req, _ := http.NewRequest("GET", b+"/api/v1/content/mappings?ma_code="+ccCode, nil)
 	req.Header.Set("Authorization", "TCS ak-regulator:badsig")
 	r, _ := http.DefaultClient.Do(req)
 	assert.Equal(t, http.StatusUnauthorized, r.StatusCode, "错误签名应 401")
@@ -261,10 +261,10 @@ func TestE2E_TakedownLatency(t *testing.T) {
 	reviewID := dataOf(resp)["review_id"].(string)
 	signedCall(t, b, "ak-reviewer", "sk-reviewer", "POST", "/content/csps-result", map[string]any{"review_id": reviewID, "approved": true})
 	_, resp = signedCall(t, b, "ak-regulator", "sk-regulator", "POST", "/content/issue", map[string]any{"review_id": reviewID, "issuer": "x"})
-	maCode := dataOf(resp)["ma_code"].(string)
+	ccCode := dataOf(resp)["ma_code"].(string)
 
 	start := time.Now()
-	st, _ := signedCall(t, b, "ak-regulator", "sk-regulator", "POST", "/content/takedown", map[string]any{"ma_code": maCode, "reason": "违规"})
+	st, _ := signedCall(t, b, "ak-regulator", "sk-regulator", "POST", "/content/takedown", map[string]any{"ma_code": ccCode, "reason": "违规"})
 	elapsed := time.Since(start)
 	require.Equal(t, http.StatusOK, st)
 	assert.Less(t, elapsed, time.Second, "下架端到端应在秒级内（目标分钟级）")
diff --git a/tcs-iptv/internal/catalog/catalog.go b/tcs-iptv/internal/catalog/catalog.go
index ddf6a2b..688e100 100644
--- a/tcs-iptv/internal/catalog/catalog.go
+++ b/tcs-iptv/internal/catalog/catalog.go
@@ -16,7 +16,7 @@ import (
 )
 
 // Catalog 目录库查询服务。
-// 提供四种维度的标识信息查询：MA码、Hash、省级编码、片库文件ID。
+// 提供四种维度的标识信息查询：CC码、Hash、省级编码、片库文件ID。
 type Catalog struct {
 	client chain.Client
 	store  CatalogStore // 可选独立存储（为 nil 时委托 chain.Client）
@@ -39,14 +39,14 @@ func NewWithStore(c chain.Client, s CatalogStore) *Catalog {
 	return &Catalog{client: c, store: s}
 }
 
-// QueryByMA 根据MA码查询标识信息及映射关系。
-func (cat *Catalog) QueryByMA(maCode string) (model.ContentQueryResult, error) {
-	c, err := cat.client.QueryContent(maCode)
+// QueryByMA 根据CC码查询标识信息及映射关系。
+func (cat *Catalog) QueryByMA(ccCode string) (model.ContentQueryResult, error) {
+	c, err := cat.client.QueryContent(ccCode)
 	if err != nil {
 		return model.ContentQueryResult{Found: false}, err
 	}
-	mr, _ := cat.client.QueryMappings(maCode)
-	eps, _ := cat.client.ListEpisodes(maCode)
+	mr, _ := cat.client.QueryMappings(ccCode)
+	eps, _ := cat.client.ListEpisodes(ccCode)
 	bindings := eps
 	return model.ContentQueryResult{
 		Found:    true,
@@ -81,6 +81,6 @@ func (cat *Catalog) QueryByLibraryFileID(libraryID string) (model.ContentQueryRe
 }
 
 // QueryAll 批量查询：按 MA 码返回全部关联信息（含绑定、映射、集级哈希）。
-func (cat *Catalog) QueryAll(maCode string) (model.ContentQueryResult, error) {
-	return cat.QueryByMA(maCode)
+func (cat *Catalog) QueryAll(ccCode string) (model.ContentQueryResult, error) {
+	return cat.QueryByMA(ccCode)
 }
diff --git a/tcs-iptv/internal/catalog/catalog_test.go b/tcs-iptv/internal/catalog/catalog_test.go
index fc22ba2..7ac2f57 100644
--- a/tcs-iptv/internal/catalog/catalog_test.go
+++ b/tcs-iptv/internal/catalog/catalog_test.go
@@ -15,7 +15,7 @@ func TestCatalog_QueryByMA(t *testing.T) {
 
 	// 发码
 	_, err := c.IssueMA(chain.RoleRegulator, chain.IssueRequest{
-		MACode: "MA.156.8531.6101/WD/20260000001", ContentTwinID: "ctid-cat-001",
+		CCCode: "MA.156.8531.6101/WD/20260000001", ContentTwinID: "ctid-cat-001",
 		FileHash: "fh-cat-001", MerkleRoot: "mr-cat-001",
 		Content: model.Content{Title: "目录库测试剧", EpisodeCount: 2, MAType: "WD", Issuer: "测试局"},
 	})
@@ -33,7 +33,7 @@ func TestCatalog_QueryByHash(t *testing.T) {
 	cat := New(c)
 
 	_, err := c.IssueMA(chain.RoleRegulator, chain.IssueRequest{
-		MACode: "MA.156.8531.6101/WD/20260000002", ContentTwinID: "ctid-cat-002",
+		CCCode: "MA.156.8531.6101/WD/20260000002", ContentTwinID: "ctid-cat-002",
 		FileHash: "fh-cat-002", MerkleRoot: "mr-cat-002",
 		Content: model.Content{Title: "Hash查询测试", MAType: "WD", Issuer: "测试局"},
 	})
@@ -43,7 +43,7 @@ func TestCatalog_QueryByHash(t *testing.T) {
 	res, err := cat.QueryByHash("fh-cat-002")
 	require.NoError(t, err)
 	assert.True(t, res.Found)
-	assert.Equal(t, "MA.156.8531.6101/WD/20260000002", res.Content.MACode)
+	assert.Equal(t, "MA.156.8531.6101/WD/20260000002", res.Content.CCCode)
 
 	// 不存在的 Hash
 	_, err = cat.QueryByHash("nonexistent")
@@ -55,7 +55,7 @@ func TestCatalog_QueryByProvincialCode(t *testing.T) {
 	cat := New(c)
 
 	_, err := c.IssueMA(chain.RoleRegulator, chain.IssueRequest{
-		MACode: "MA.156.8531.6101/WD/20260000003", ContentTwinID: "ctid-cat-003",
+		CCCode: "MA.156.8531.6101/WD/20260000003", ContentTwinID: "ctid-cat-003",
 		FileHash: "fh-cat-003", MerkleRoot: "mr-cat-003",
 		Content: model.Content{Title: "省级编码查询测试", MAType: "WD", Issuer: "测试局"},
 	})
@@ -71,7 +71,7 @@ func TestCatalog_QueryByProvincialCode(t *testing.T) {
 	res, err := cat.QueryByProvincialCode("PROV-CAT-001")
 	require.NoError(t, err)
 	assert.True(t, res.Found)
-	assert.Equal(t, "MA.156.8531.6101/WD/20260000003", res.Content.MACode)
+	assert.Equal(t, "MA.156.8531.6101/WD/20260000003", res.Content.CCCode)
 }
 
 func TestCatalog_QueryByLibraryFileID(t *testing.T) {
@@ -79,7 +79,7 @@ func TestCatalog_QueryByLibraryFileID(t *testing.T) {
 	cat := New(c)
 
 	_, err := c.IssueMA(chain.RoleRegulator, chain.IssueRequest{
-		MACode: "MA.156.8531.6101/WD/20260000004", ContentTwinID: "ctid-cat-004",
+		CCCode: "MA.156.8531.6101/WD/20260000004", ContentTwinID: "ctid-cat-004",
 		FileHash: "fh-cat-004", MerkleRoot: "mr-cat-004",
 		Content: model.Content{Title: "片库ID查询测试", MAType: "WD", Issuer: "测试局"},
 	})
@@ -95,5 +95,5 @@ func TestCatalog_QueryByLibraryFileID(t *testing.T) {
 	res, err := cat.QueryByLibraryFileID("LIB-CAT-001")
 	require.NoError(t, err)
 	assert.True(t, res.Found)
-	assert.Equal(t, "MA.156.8531.6101/WD/20260000004", res.Content.MACode)
+	assert.Equal(t, "MA.156.8531.6101/WD/20260000004", res.Content.CCCode)
 }
diff --git a/tcs-iptv/internal/macode/macode.go b/tcs-iptv/internal/cccode/cccode.go
similarity index 92%
rename from tcs-iptv/internal/macode/macode.go
rename to tcs-iptv/internal/cccode/cccode.go
index 4efaab8..4fcc5c3 100644
--- a/tcs-iptv/internal/macode/macode.go
+++ b/tcs-iptv/internal/cccode/cccode.go
@@ -1,6 +1,6 @@
-// Package macode 实现 MA 码生成服务（模式B：自行发码）。
+// Package cccode 实现 MA 码生成服务（模式B：自行发码）。
 // TCS 与 MA 发码机构合作获取「码段（号段）」与「备案规则」，在本地按规则原子发码。
-// 对应需求：需求3（MA码签发）、需求16；与 ISO/IEC 15459 MA 标识体系对齐。
+// 对应需求：需求3（CC码签发）、需求16；与 ISO/IEC 15459 MA 标识体系对齐。
 //
 // MA 码结构（六段式，可由备案规则配置）：
 //
@@ -14,7 +14,7 @@
 //   - WD      内容类目（WD=微短剧 / WJ=网络剧 / DY=网络电影 / DH=网络动画）
 //   - yyyy    年份
 //   - sequence 号段内递增序列（按位补零）
-package macode
+package cccode
 
 import (
 	"errors"
@@ -25,9 +25,9 @@ import (
 
 // 错误定义。
 var (
-	ErrSegmentExhausted = errors.New("macode: code segment exhausted")
-	ErrUnknownCategory  = errors.New("macode: unknown content category")
-	ErrInvalidSegment   = errors.New("macode: invalid segment range")
+	ErrSegmentExhausted = errors.New("cccode: code segment exhausted")
+	ErrUnknownCategory  = errors.New("cccode: unknown content category")
+	ErrInvalidSegment   = errors.New("cccode: invalid segment range")
 )
 
 // 内容类目码。
@@ -108,7 +108,7 @@ func segmentKey(s Segment) string {
 
 // Issued 一次发码结果。
 type Issued struct {
-	MACode       string `json:"ma_code"`
+	CCCode       string `json:"ma_code"`
 	IndustryNode string `json:"industry_node"`
 	OrgNode      string `json:"org_node"`
 	Category     string `json:"category"`
@@ -133,7 +133,7 @@ func (g *Generator) Allocate(category string) (Issued, error) {
 	year := g.clock().Year()
 	code := Format(seg, year, seq)
 	return Issued{
-		MACode:       code,
+		CCCode:       code,
 		IndustryNode: seg.IndustryNode,
 		OrgNode:      seg.OrgNode,
 		Category:     category,
diff --git a/tcs-iptv/internal/macode/macode_test.go b/tcs-iptv/internal/cccode/cccode_test.go
similarity index 91%
rename from tcs-iptv/internal/macode/macode_test.go
rename to tcs-iptv/internal/cccode/cccode_test.go
index d818650..a1e3561 100644
--- a/tcs-iptv/internal/macode/macode_test.go
+++ b/tcs-iptv/internal/cccode/cccode_test.go
@@ -1,4 +1,4 @@
-package macode
+package cccode
 
 import (
 	"sync"
@@ -30,9 +30,9 @@ func TestAllocate_SequentialUnique(t *testing.T) {
 	for i := 0; i < 50; i++ {
 		issued, err := g.Allocate(CategoryMicroDrama)
 		require.NoError(t, err)
-		assert.False(t, seen[issued.MACode], "MA 码必须唯一: %s", issued.MACode)
-		seen[issued.MACode] = true
-		assert.True(t, IsValid(issued.MACode), "应符合格式: %s", issued.MACode)
+		assert.False(t, seen[issued.CCCode], "MA 码必须唯一: %s", issued.CCCode)
+		seen[issued.CCCode] = true
+		assert.True(t, IsValid(issued.CCCode), "应符合格式: %s", issued.CCCode)
 	}
 	assert.Len(t, seen, 50)
 }
@@ -41,7 +41,7 @@ func TestAllocate_FormatCorrect(t *testing.T) {
 	g := newGen(t)
 	issued, err := g.Allocate(CategoryMicroDrama)
 	require.NoError(t, err)
-	assert.Equal(t, "MA.156.8531.4401/WD/20250000001", issued.MACode)
+	assert.Equal(t, "MA.156.8531.4401/WD/20250000001", issued.CCCode)
 	assert.Equal(t, uint64(1), issued.Sequence)
 	assert.Equal(t, 2025, issued.Year)
 }
@@ -88,10 +88,10 @@ func TestAllocate_ConcurrentNoDuplicate(t *testing.T) {
 				return
 			}
 			mu.Lock()
-			if seen[issued.MACode] {
+			if seen[issued.CCCode] {
 				dup++
 			}
-			seen[issued.MACode] = true
+			seen[issued.CCCode] = true
 			mu.Unlock()
 		}()
 	}
diff --git a/tcs-iptv/internal/macode/parse.go b/tcs-iptv/internal/cccode/parse.go
similarity index 71%
rename from tcs-iptv/internal/macode/parse.go
rename to tcs-iptv/internal/cccode/parse.go
index e1c3fe6..84d3b9a 100644
--- a/tcs-iptv/internal/macode/parse.go
+++ b/tcs-iptv/internal/cccode/parse.go
@@ -1,4 +1,4 @@
-package macode
+package cccode
 
 import (
 	"fmt"
@@ -17,21 +17,21 @@ type Parsed struct {
 	Sequence     uint64
 }
 
-// maCodePattern 匹配六段式 MA 码：
+// ccCodePattern 匹配六段式 MA 码：
 // MA.156.{industry}.{org}/{category}/{yyyy}{sequence}
-var maCodePattern = regexp.MustCompile(
+var ccCodePattern = regexp.MustCompile(
 	`^(MA)\.(\d{3})\.([0-9A-Za-z]+)\.([0-9A-Za-z]+)/([A-Z]{2})/(\d{4})(\d+)$`)
 
 // Parse 将 MA 码字符串解析为结构化字段；格式非法返回错误（需求4 校验基础）。
 func Parse(code string) (Parsed, error) {
-	m := maCodePattern.FindStringSubmatch(code)
+	m := ccCodePattern.FindStringSubmatch(code)
 	if m == nil {
-		return Parsed{}, fmt.Errorf("macode: invalid format: %s", code)
+		return Parsed{}, fmt.Errorf("cccode: invalid format: %s", code)
 	}
 	year, _ := strconv.Atoi(m[6])
 	seq, err := strconv.ParseUint(m[7], 10, 64)
 	if err != nil {
-		return Parsed{}, fmt.Errorf("macode: invalid sequence: %w", err)
+		return Parsed{}, fmt.Errorf("cccode: invalid sequence: %w", err)
 	}
 	return Parsed{
 		Root:         m[1],
@@ -46,13 +46,13 @@ func Parse(code string) (Parsed, error) {
 
 // IsValid 仅校验格式合法性。
 func IsValid(code string) bool {
-	return maCodePattern.MatchString(code)
+	return ccCodePattern.MatchString(code)
 }
 
-// EpisodeSubID 生成集级子标识：{maCode}#E{NN}。
+// EpisodeSubID 生成集级子标识：{ccCode}#E{NN}。
 // 整剧用 MA 码，单集用子标识，便于按集验真/追更/下架。
-func EpisodeSubID(maCode string, episode int) string {
-	return fmt.Sprintf("%s#E%02d", maCode, episode)
+func EpisodeSubID(ccCode string, episode int) string {
+	return fmt.Sprintf("%s#E%02d", ccCode, episode)
 }
 
 // episodeSubPattern 匹配集级子标识后缀。
@@ -60,7 +60,7 @@ var episodeSubPattern = regexp.MustCompile(`^(.+)#E(\d+)$`)
 
 // ParseEpisodeSubID 拆解集级子标识，返回主 MA 码与集号。
 // 若无 #E 后缀，episode 返回 0（表示整剧）。
-func ParseEpisodeSubID(subID string) (maCode string, episode int) {
+func ParseEpisodeSubID(subID string) (ccCode string, episode int) {
 	m := episodeSubPattern.FindStringSubmatch(subID)
 	if m == nil {
 		return subID, 0
diff --git a/tcs-iptv/internal/macode/store_memory.go b/tcs-iptv/internal/cccode/store_memory.go
similarity index 98%
rename from tcs-iptv/internal/macode/store_memory.go
rename to tcs-iptv/internal/cccode/store_memory.go
index 6f25f89..be7da7b 100644
--- a/tcs-iptv/internal/macode/store_memory.go
+++ b/tcs-iptv/internal/cccode/store_memory.go
@@ -1,4 +1,4 @@
-package macode
+package cccode
 
 import "sync"
 
diff --git a/tcs-iptv/internal/macode/store_postgres.go b/tcs-iptv/internal/cccode/store_postgres.go
similarity index 86%
rename from tcs-iptv/internal/macode/store_postgres.go
rename to tcs-iptv/internal/cccode/store_postgres.go
index ba85f6b..d920e46 100644
--- a/tcs-iptv/internal/macode/store_postgres.go
+++ b/tcs-iptv/internal/cccode/store_postgres.go
@@ -1,4 +1,4 @@
-package macode
+package cccode
 
 import (
 	"database/sql"
@@ -25,15 +25,15 @@ func NewPostgresStore(db *sql.DB) *PostgresStore {
 // 单条 SQL 在行锁内完成读改写，并发安全；超过 end 返回耗尽错误。
 func (s *PostgresStore) Next(segmentKey string, start, end uint64) (uint64, error) {
 	const q = `
-INSERT INTO macode_cursor (segment_key, cursor)
+INSERT INTO cccode_cursor (segment_key, cursor)
 VALUES ($1, $2)
 ON CONFLICT (segment_key)
-DO UPDATE SET cursor = macode_cursor.cursor + 1, updated_at = NOW()
+DO UPDATE SET cursor = cccode_cursor.cursor + 1, updated_at = NOW()
 RETURNING cursor;`
 
 	var next uint64
 	if err := s.db.QueryRow(q, segmentKey, start).Scan(&next); err != nil {
-		return 0, fmt.Errorf("macode: pg next: %w", err)
+		return 0, fmt.Errorf("cccode: pg next: %w", err)
 	}
 	if next > end {
 		return 0, ErrSegmentExhausted
diff --git a/tcs-iptv/internal/macode/store_postgres_test.go b/tcs-iptv/internal/cccode/store_postgres_test.go
similarity index 93%
rename from tcs-iptv/internal/macode/store_postgres_test.go
rename to tcs-iptv/internal/cccode/store_postgres_test.go
index b3a74bc..b2ec6ad 100644
--- a/tcs-iptv/internal/macode/store_postgres_test.go
+++ b/tcs-iptv/internal/cccode/store_postgres_test.go
@@ -1,4 +1,4 @@
-package macode
+package cccode
 
 import (
 	"database/sql"
@@ -31,7 +31,7 @@ func openTestDB(t *testing.T) *sql.DB {
 
 func cleanupKey(t *testing.T, db *sql.DB, key string) {
 	t.Helper()
-	_, _ = db.Exec("DELETE FROM macode_cursor WHERE segment_key = $1", key)
+	_, _ = db.Exec("DELETE FROM cccode_cursor WHERE segment_key = $1", key)
 }
 
 func TestPostgresStore_Sequential(t *testing.T) {
@@ -122,8 +122,8 @@ func TestPostgresStore_WithGenerator(t *testing.T) {
 	for i := 0; i < 10; i++ {
 		issued, err := g.Allocate(CategoryAnimation)
 		require.NoError(t, err)
-		assert.False(t, seen[issued.MACode])
-		assert.True(t, IsValid(issued.MACode))
-		seen[issued.MACode] = true
+		assert.False(t, seen[issued.CCCode])
+		assert.True(t, IsValid(issued.CCCode))
+		seen[issued.CCCode] = true
 	}
 }
diff --git a/tcs-iptv/internal/chain/chain.go b/tcs-iptv/internal/chain/chain.go
index c38c7b2..1b936af 100644
--- a/tcs-iptv/internal/chain/chain.go
+++ b/tcs-iptv/internal/chain/chain.go
@@ -31,7 +31,7 @@ var (
 
 // IssueRequest 签发 MA 码并强绑定哈希包。
 type IssueRequest struct {
-	MACode         string
+	CCCode         string
 	ContentTwinID  string
 	MerkleRoot     string
 	FileHash       string
@@ -43,7 +43,7 @@ type IssueRequest struct {
 // VerifyResult 哈希验真结果（需求4-AC4）。
 type VerifyResult struct {
 	Valid         bool   `json:"valid"`
-	MACode        string `json:"ma_code"`
+	CCCode        string `json:"ma_code"`
 	BoundHash     string `json:"bound_hash"`
 	SubmittedHash string `json:"submitted_hash"`
 	Match         bool   `json:"match"`
@@ -52,7 +52,7 @@ type VerifyResult struct {
 
 // MappingsResult 映射查询结果（需求11/17）。
 type MappingsResult struct {
-	MACode       string          `json:"ma_code"`
+	CCCode       string          `json:"ma_code"`
 	Mappings     []model.Mapping `json:"mappings"`
 	CDNEndpoints []string        `json:"cdn_endpoints"`
 }
@@ -67,31 +67,31 @@ type Client interface {
 	// RegisterMapping 注册三方编码映射（MA 必须已签发）。
 	RegisterMapping(role Role, m model.Mapping) (txID string, err error)
 	// VerifyHash 按 MA 码校验提交哈希是否与绑定哈希一致。
-	VerifyHash(maCode, fileHash string) (VerifyResult, error)
+	VerifyHash(ccCode, fileHash string) (VerifyResult, error)
 	// VerifyEpisodeHash 按 MA 码+集号校验该集哈希。
-	VerifyEpisodeHash(maCode string, episode int, fileHash string) (VerifyResult, error)
+	VerifyEpisodeHash(ccCode string, episode int, fileHash string) (VerifyResult, error)
 	// ListEpisodes 返回某 MA 码下的全部集级哈希绑定。
-	ListEpisodes(maCode string) ([]model.HashBinding, error)
+	ListEpisodes(ccCode string) ([]model.HashBinding, error)
 	// HashExists 判断内容哈希是否已存在（防换壳重发）。
-	HashExists(fileHash string) (maCode string, exists bool)
+	HashExists(fileHash string) (ccCode string, exists bool)
 	// QueryContent 查询内容主记录。
-	QueryContent(maCode string) (model.Content, error)
+	QueryContent(ccCode string) (model.Content, error)
 	// ListContents 按状态列出内容（空状态返回全部）。
 	ListContents(status string) ([]model.Content, error)
 	// QueryMappings 查询 MA 码绑定的全部三方映射与 CDN 端点。
-	QueryMappings(maCode string) (MappingsResult, error)
+	QueryMappings(ccCode string) (MappingsResult, error)
 	// RecordVersionChange 记录版本变更（绑定断裂触发重审）。
 	RecordVersionChange(vc model.VersionChange) (txID string, err error)
 	// Revoke 下架（仅监管主体），返回受影响的映射。
-	Revoke(role Role, maCode, reason string) (MappingsResult, error)
+	Revoke(role Role, ccCode, reason string) (MappingsResult, error)
 	// RevokeEpisode 集级下架（仅监管主体）：只下架指定集，整剧其他集不受影响。
-	RevokeEpisode(role Role, maCode string, episode int, reason string) error
+	RevokeEpisode(role Role, ccCode string, episode int, reason string) error
 	// Restore 恢复上架整剧（仅监管主体）：下架状态恢复为流通中。
-	Restore(role Role, maCode string) error
+	Restore(role Role, ccCode string) error
 	// RestoreEpisode 恢复上架指定集（仅监管主体）。
-	RestoreEpisode(role Role, maCode string, episode int) error
+	RestoreEpisode(role Role, ccCode string, episode int) error
 	// SetContentStatus 更新内容状态。
-	SetContentStatus(maCode, status string) error
+	SetContentStatus(ccCode, status string) error
 	// QueryByHash 根据内容哈希反查标识信息及映射关系。
 	QueryByHash(fileHash string) (model.ContentQueryResult, error)
 	// QueryByProvincialCode 根据省级内容编码（CP MediaID）反查标识信息。
diff --git a/tcs-iptv/internal/chain/chainmaker.go b/tcs-iptv/internal/chain/chainmaker.go
index 8641298..368a3e2 100644
--- a/tcs-iptv/internal/chain/chainmaker.go
+++ b/tcs-iptv/internal/chain/chainmaker.go
@@ -129,7 +129,7 @@ func (c *ChainMakerClient) IssueMA(role Role, req IssueRequest) (string, error)
 	contentJSON, _ := json.Marshal(req.Content)
 	epJSON, _ := json.Marshal(req.Episodes)
 	resp, err := c.invoke(role, "IssueMA", map[string][]byte{
-		"ma_code":         []byte(req.MACode),
+		"ma_code":         []byte(req.CCCode),
 		"ctid":            []byte(req.ContentTwinID),
 		"merkle_root":     []byte(req.MerkleRoot),
 		"file_hash":       []byte(req.FileHash),
@@ -177,66 +177,66 @@ func (c *ChainMakerClient) RecordVersionChange(vc model.VersionChange) (string,
 	return resp.TxId, nil
 }
 
-func (c *ChainMakerClient) Revoke(role Role, maCode, reason string) (MappingsResult, error) {
+func (c *ChainMakerClient) Revoke(role Role, ccCode, reason string) (MappingsResult, error) {
 	if _, err := c.invoke(role, "Revoke", map[string][]byte{
-		"ma_code": []byte(maCode), "reason": []byte(reason),
+		"ma_code": []byte(ccCode), "reason": []byte(reason),
 	}); err != nil {
 		return MappingsResult{}, err
 	}
-	return c.QueryMappings(maCode)
+	return c.QueryMappings(ccCode)
 }
 
-func (c *ChainMakerClient) RevokeEpisode(role Role, maCode string, episode int, reason string) error {
+func (c *ChainMakerClient) RevokeEpisode(role Role, ccCode string, episode int, reason string) error {
 	_, err := c.invoke(role, "RevokeEpisode", map[string][]byte{
-		"ma_code": []byte(maCode), "episode": []byte(fmt.Sprint(episode)), "reason": []byte(reason),
+		"ma_code": []byte(ccCode), "episode": []byte(fmt.Sprint(episode)), "reason": []byte(reason),
 	})
 	return err
 }
 
-func (c *ChainMakerClient) Restore(role Role, maCode string) error {
-	_, err := c.invoke(role, "Restore", map[string][]byte{"ma_code": []byte(maCode)})
+func (c *ChainMakerClient) Restore(role Role, ccCode string) error {
+	_, err := c.invoke(role, "Restore", map[string][]byte{"ma_code": []byte(ccCode)})
 	return err
 }
 
-func (c *ChainMakerClient) RestoreEpisode(role Role, maCode string, episode int) error {
+func (c *ChainMakerClient) RestoreEpisode(role Role, ccCode string, episode int) error {
 	_, err := c.invoke(role, "RestoreEpisode", map[string][]byte{
-		"ma_code": []byte(maCode), "episode": []byte(fmt.Sprint(episode)),
+		"ma_code": []byte(ccCode), "episode": []byte(fmt.Sprint(episode)),
 	})
 	return err
 }
 
-func (c *ChainMakerClient) SetContentStatus(maCode, status string) error {
+func (c *ChainMakerClient) SetContentStatus(ccCode, status string) error {
 	_, err := c.invoke(RoleReviewer, "SetContentStatus", map[string][]byte{
-		"ma_code": []byte(maCode), "status": []byte(status),
+		"ma_code": []byte(ccCode), "status": []byte(status),
 	})
 	return err
 }
 
 // ---- chain.Client 实现（读操作）----
 
-func (c *ChainMakerClient) VerifyHash(maCode, fileHash string) (VerifyResult, error) {
+func (c *ChainMakerClient) VerifyHash(ccCode, fileHash string) (VerifyResult, error) {
 	res, err := c.query(RoleOperator, "VerifyHash", map[string][]byte{
-		"ma_code": []byte(maCode), "file_hash": []byte(fileHash),
+		"ma_code": []byte(ccCode), "file_hash": []byte(fileHash),
 	})
 	if err != nil {
-		return VerifyResult{MACode: maCode, SubmittedHash: fileHash}, err
+		return VerifyResult{CCCode: ccCode, SubmittedHash: fileHash}, err
 	}
 	match := string(res) == "true"
-	return VerifyResult{Valid: true, MACode: maCode, SubmittedHash: fileHash, Match: match}, nil
+	return VerifyResult{Valid: true, CCCode: ccCode, SubmittedHash: fileHash, Match: match}, nil
 }
 
-func (c *ChainMakerClient) VerifyEpisodeHash(maCode string, episode int, fileHash string) (VerifyResult, error) {
+func (c *ChainMakerClient) VerifyEpisodeHash(ccCode string, episode int, fileHash string) (VerifyResult, error) {
 	res, err := c.query(RoleOperator, "VerifyEpisodeHash", map[string][]byte{
-		"ma_code": []byte(maCode), "episode": []byte(fmt.Sprint(episode)), "file_hash": []byte(fileHash),
+		"ma_code": []byte(ccCode), "episode": []byte(fmt.Sprint(episode)), "file_hash": []byte(fileHash),
 	})
 	if err != nil {
-		return VerifyResult{MACode: maCode, SubmittedHash: fileHash}, err
+		return VerifyResult{CCCode: ccCode, SubmittedHash: fileHash}, err
 	}
-	return VerifyResult{Valid: true, MACode: maCode, SubmittedHash: fileHash, Match: string(res) == "true"}, nil
+	return VerifyResult{Valid: true, CCCode: ccCode, SubmittedHash: fileHash, Match: string(res) == "true"}, nil
 }
 
-func (c *ChainMakerClient) ListEpisodes(maCode string) ([]model.HashBinding, error) {
-	res, err := c.query(RoleRegulator, "ListEpisodes", map[string][]byte{"ma_code": []byte(maCode)})
+func (c *ChainMakerClient) ListEpisodes(ccCode string) ([]model.HashBinding, error) {
+	res, err := c.query(RoleRegulator, "ListEpisodes", map[string][]byte{"ma_code": []byte(ccCode)})
 	if err != nil {
 		return nil, err
 	}
@@ -255,8 +255,8 @@ func (c *ChainMakerClient) HashExists(fileHash string) (string, bool) {
 	return string(res), true
 }
 
-func (c *ChainMakerClient) QueryContent(maCode string) (model.Content, error) {
-	res, err := c.query(RoleRegulator, "QueryContent", map[string][]byte{"ma_code": []byte(maCode)})
+func (c *ChainMakerClient) QueryContent(ccCode string) (model.Content, error) {
+	res, err := c.query(RoleRegulator, "QueryContent", map[string][]byte{"ma_code": []byte(ccCode)})
 	if err != nil {
 		return model.Content{}, err
 	}
@@ -280,8 +280,8 @@ func (c *ChainMakerClient) ListContents(status string) ([]model.Content, error)
 	return out, nil
 }
 
-func (c *ChainMakerClient) QueryMappings(maCode string) (MappingsResult, error) {
-	res, err := c.query(RoleRegulator, "QueryMappings", map[string][]byte{"ma_code": []byte(maCode)})
+func (c *ChainMakerClient) QueryMappings(ccCode string) (MappingsResult, error) {
+	res, err := c.query(RoleRegulator, "QueryMappings", map[string][]byte{"ma_code": []byte(ccCode)})
 	if err != nil {
 		return MappingsResult{}, err
 	}
@@ -289,7 +289,7 @@ func (c *ChainMakerClient) QueryMappings(maCode string) (MappingsResult, error)
 	if err := json.Unmarshal(res, &out); err != nil {
 		return MappingsResult{}, err
 	}
-	out.MACode = maCode
+	out.CCCode = ccCode
 	return out, nil
 }
 
diff --git a/tcs-iptv/internal/chain/chainmaker_conformance_test.go b/tcs-iptv/internal/chain/chainmaker_conformance_test.go
index c3f1fa3..ca1e324 100644
--- a/tcs-iptv/internal/chain/chainmaker_conformance_test.go
+++ b/tcs-iptv/internal/chain/chainmaker_conformance_test.go
@@ -14,7 +14,7 @@ import (
 // 仅在 `go test -tags chainmaker` 且配置了测试链时运行：
 //   - TCS_TEST_CHAINMAKER_CONF：测试链 sdk_config.yml 路径
 //
-// 注意：真实链不易"清空状态"，建议每次用全新 maCode/合约实例，或对接专用测试链。
+// 注意：真实链不易"清空状态"，建议每次用全新 ccCode/合约实例，或对接专用测试链。
 // 本用例提供接线骨架，实际跑通需真实 ChainMaker 测试网与已部署的 tcs_registry 合约。
 func TestChainMakerClient_Conformance(t *testing.T) {
 	conf := os.Getenv("TCS_TEST_CHAINMAKER_CONF")
diff --git a/tcs-iptv/internal/chain/conformance_test.go b/tcs-iptv/internal/chain/conformance_test.go
index b3b70ed..18ce073 100644
--- a/tcs-iptv/internal/chain/conformance_test.go
+++ b/tcs-iptv/internal/chain/conformance_test.go
@@ -19,7 +19,7 @@ func RunClientConformance(t *testing.T, newClient func(t *testing.T) Client) {
 	// 构造一条标准发码请求（集级 3 集）。
 	issueReq := func(ma, ctid, fh string) IssueRequest {
 		return IssueRequest{
-			MACode: ma, ContentTwinID: ctid, MerkleRoot: "mr-" + fh, FileHash: fh,
+			CCCode: ma, ContentTwinID: ctid, MerkleRoot: "mr-" + fh, FileHash: fh,
 			PerceptualHash: "ph-" + fh,
 			Episodes: []model.EpisodeHash{
 				{Episode: 1, FileSHA256: fh + "-E1"},
@@ -170,20 +170,20 @@ func RunClientConformance(t *testing.T, newClient func(t *testing.T) Client) {
 		res, err := c.QueryByHash(fh)
 		require.NoError(t, err)
 		assert.True(t, res.Found)
-		assert.Equal(t, ma, res.Content.MACode)
+		assert.Equal(t, ma, res.Content.CCCode)
 		assert.Equal(t, "契约测试剧", res.Content.Title)
 
 		// 按省级内容编码查询
 		res2, err := c.QueryByProvincialCode("PROV-001")
 		require.NoError(t, err)
 		assert.True(t, res2.Found)
-		assert.Equal(t, ma, res2.Content.MACode)
+		assert.Equal(t, ma, res2.Content.CCCode)
 
 		// 按片库文件 ID 查询
 		res3, err := c.QueryByLibraryFileID("LIB-001")
 		require.NoError(t, err)
 		assert.True(t, res3.Found)
-		assert.Equal(t, ma, res3.Content.MACode)
+		assert.Equal(t, ma, res3.Content.CCCode)
 
 		// 不存在的 Hash
 		_, err = c.QueryByHash("nonexistent")
@@ -203,17 +203,17 @@ func RunClientConformance(t *testing.T, newClient func(t *testing.T) Client) {
 
 		// 非监管不可合并
 		_, err = c.MergeMA(RoleCP, model.MergeRequest{
-			PrimaryMACode: ma, SecondaryMACodes: []string{ma2}, Reason: "重复发码",
+			PrimaryCCCode: ma, SecondaryCCCodes: []string{ma2}, Reason: "重复发码",
 		})
 		assert.ErrorIs(t, err, ErrPermissionDenied)
 
 		// 监管合并
 		res, err := c.MergeMA(RoleRegulator, model.MergeRequest{
-			PrimaryMACode: ma, SecondaryMACodes: []string{ma2}, Reason: "重复发码", Operator: "监管局",
+			PrimaryCCCode: ma, SecondaryCCCodes: []string{ma2}, Reason: "重复发码", Operator: "监管局",
 		})
 		require.NoError(t, err)
-		assert.Equal(t, ma, res.PrimaryMACode)
-		assert.Contains(t, res.MergedMACodes, ma2)
+		assert.Equal(t, ma, res.PrimaryCCCode)
+		assert.Contains(t, res.MergedCCCodes, ma2)
 		assert.Greater(t, res.MigratedBindings, 0)
 
 		// 被合并的 MA 状态为 merged
@@ -223,7 +223,7 @@ func RunClientConformance(t *testing.T, newClient func(t *testing.T) Client) {
 		// 按 fh2 查询应指向主 MA 码
 		qr, err := c.QueryByHash(fh2)
 		require.NoError(t, err)
-		assert.Equal(t, ma, qr.Content.MACode)
+		assert.Equal(t, ma, qr.Content.CCCode)
 	})
 
 	t.Run("MA拆分_仅监管且按集迁移", func(t *testing.T) {
@@ -233,20 +233,20 @@ func RunClientConformance(t *testing.T, newClient func(t *testing.T) Client) {
 
 		// 非监管不可拆分
 		_, err = c.SplitMA(RoleCP, model.SplitRequest{
-			SourceMACode: ma, Splits: []model.SplitTarget{{NewMACode: "MA.156.8531.6101/WD/20260000010", Title: "拆分剧A", Episodes: []int{1, 2}}},
+			SourceCCCode: ma, Splits: []model.SplitTarget{{NewCCCode: "MA.156.8531.6101/WD/20260000010", Title: "拆分剧A", Episodes: []int{1, 2}}},
 		})
 		assert.ErrorIs(t, err, ErrPermissionDenied)
 
 		// 监管拆分
 		newMA := "MA.156.8531.6101/WD/20260000011"
 		res, err := c.SplitMA(RoleRegulator, model.SplitRequest{
-			SourceMACode: ma,
-			Splits:       []model.SplitTarget{{NewMACode: newMA, Title: "拆分剧A", Episodes: []int{1, 2}}},
+			SourceCCCode: ma,
+			Splits:       []model.SplitTarget{{NewCCCode: newMA, Title: "拆分剧A", Episodes: []int{1, 2}}},
 			Reason:       "合集拆分",
 			Operator:     "监管局",
 		})
 		require.NoError(t, err)
-		assert.Contains(t, res.NewMACodes, newMA)
+		assert.Contains(t, res.NewCCCodes, newMA)
 		assert.Greater(t, res.MigratedBindings, 0)
 
 		// 源 MA 状态为 split
diff --git a/tcs-iptv/internal/chain/memory.go b/tcs-iptv/internal/chain/memory.go
index b32857e..e4c75e5 100644
--- a/tcs-iptv/internal/chain/memory.go
+++ b/tcs-iptv/internal/chain/memory.go
@@ -12,11 +12,11 @@ import (
 // 严格执行合约级业务规则：签发权限、1:1 不可解绑、映射前置签发、防重复哈希。
 type MemoryChain struct {
 	mu        sync.RWMutex
-	contents  map[string]model.Content       // maCode -> Content
-	bindings  map[string][]model.HashBinding // maCode -> bindings
-	mappings  map[string][]model.Mapping     // maCode -> mappings
+	contents  map[string]model.Content       // ccCode -> Content
+	bindings  map[string][]model.HashBinding // ccCode -> bindings
+	mappings  map[string][]model.Mapping     // ccCode -> mappings
 	versions  map[string][]model.VersionChange
-	hashIndex map[string]string // fileHash -> maCode（防换壳重发）
+	hashIndex map[string]string // fileHash -> ccCode（防换壳重发）
 	txSeq     int
 }
 
@@ -44,7 +44,7 @@ func (m *MemoryChain) IssueMA(role Role, req IssueRequest) (string, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	if _, ok := m.contents[req.MACode]; ok {
+	if _, ok := m.contents[req.CCCode]; ok {
 		return "", ErrMAAlreadyIssued
 	}
 	if existing, ok := m.hashIndex[req.FileHash]; ok {
@@ -52,15 +52,15 @@ func (m *MemoryChain) IssueMA(role Role, req IssueRequest) (string, error) {
 	}
 
 	c := req.Content
-	c.MACode = req.MACode
+	c.CCCode = req.CCCode
 	c.ContentTwinID = req.ContentTwinID
 	c.Status = model.StatusApproved
 	if c.CreatedAt.IsZero() {
 		c.CreatedAt = time.Now()
 	}
-	m.contents[req.MACode] = c
+	m.contents[req.CCCode] = c
 
-	m.bindings[req.MACode] = []model.HashBinding{{
+	m.bindings[req.CCCode] = []model.HashBinding{{
 		ContentTwinID: req.ContentTwinID,
 		HashType:      model.HashFile,
 		HashValue:     req.FileHash,
@@ -69,7 +69,7 @@ func (m *MemoryChain) IssueMA(role Role, req IssueRequest) (string, error) {
 		CreatedBy:     string(RoleRegulator),
 	}}
 	if req.PerceptualHash != "" {
-		m.bindings[req.MACode] = append(m.bindings[req.MACode], model.HashBinding{
+		m.bindings[req.CCCode] = append(m.bindings[req.CCCode], model.HashBinding{
 			ContentTwinID: req.ContentTwinID,
 			HashType:      model.HashPerceptual,
 			HashValue:     req.PerceptualHash,
@@ -77,11 +77,11 @@ func (m *MemoryChain) IssueMA(role Role, req IssueRequest) (string, error) {
 			CreatedBy:     string(RoleRegulator),
 		})
 	}
-	m.hashIndex[req.FileHash] = req.MACode
+	m.hashIndex[req.FileHash] = req.CCCode
 
 	// 集级哈希绑定（分集内容）：每集独立哈希，挂在同一 MA 码下。
 	for _, ep := range req.Episodes {
-		m.bindings[req.MACode] = append(m.bindings[req.MACode], model.HashBinding{
+		m.bindings[req.CCCode] = append(m.bindings[req.CCCode], model.HashBinding{
 			ContentTwinID: req.ContentTwinID,
 			HashType:      model.HashFile,
 			HashValue:     ep.FileSHA256,
@@ -94,7 +94,7 @@ func (m *MemoryChain) IssueMA(role Role, req IssueRequest) (string, error) {
 		})
 		if ep.FileSHA256 != "" {
 			if _, ok := m.hashIndex[ep.FileSHA256]; !ok {
-				m.hashIndex[ep.FileSHA256] = req.MACode
+				m.hashIndex[ep.FileSHA256] = req.CCCode
 			}
 		}
 	}
@@ -109,14 +109,14 @@ func (m *MemoryChain) RegisterHashBinding(role Role, b model.HashBinding) (strin
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	maCode := m.maCodeByCTID(b.ContentTwinID)
-	if maCode == "" {
+	ccCode := m.ccCodeByCTID(b.ContentTwinID)
+	if ccCode == "" {
 		return "", ErrMANotIssued
 	}
-	m.bindings[maCode] = append(m.bindings[maCode], b)
+	m.bindings[ccCode] = append(m.bindings[ccCode], b)
 	if b.HashType == model.HashFile || b.HashType == model.HashTranscoded {
 		if _, ok := m.hashIndex[b.HashValue]; !ok {
-			m.hashIndex[b.HashValue] = maCode
+			m.hashIndex[b.HashValue] = ccCode
 		}
 	}
 	return m.nextTx("registerHashBinding"), nil
@@ -127,28 +127,28 @@ func (m *MemoryChain) RegisterMapping(role Role, mp model.Mapping) (string, erro
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	maCode := m.maCodeByCTID(mp.ContentTwinID)
-	if maCode == "" {
+	ccCode := m.ccCodeByCTID(mp.ContentTwinID)
+	if ccCode == "" {
 		return "", ErrMANotIssued
 	}
-	m.mappings[maCode] = append(m.mappings[maCode], mp)
+	m.mappings[ccCode] = append(m.mappings[ccCode], mp)
 	return m.nextTx("registerMapping"), nil
 }
 
 // VerifyHash 按 MA 码校验提交哈希。
-func (m *MemoryChain) VerifyHash(maCode, fileHash string) (VerifyResult, error) {
+func (m *MemoryChain) VerifyHash(ccCode, fileHash string) (VerifyResult, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 
-	bs, ok := m.bindings[maCode]
+	bs, ok := m.bindings[ccCode]
 	if !ok {
-		return VerifyResult{Valid: false, MACode: maCode, SubmittedHash: fileHash}, ErrMANotIssued
+		return VerifyResult{Valid: false, CCCode: ccCode, SubmittedHash: fileHash}, ErrMANotIssued
 	}
 	for _, b := range bs {
 		if b.HashType == model.HashFile || b.HashType == model.HashTranscoded {
 			if b.HashValue == fileHash {
 				return VerifyResult{
-					Valid: true, MACode: maCode,
+					Valid: true, CCCode: ccCode,
 					BoundHash: b.HashValue, SubmittedHash: fileHash,
 					Match: true, Version: b.Version,
 				}, nil
@@ -163,7 +163,7 @@ func (m *MemoryChain) VerifyHash(maCode, fileHash string) (VerifyResult, error)
 			break
 		}
 	}
-	return VerifyResult{Valid: true, MACode: maCode, BoundHash: bound, SubmittedHash: fileHash, Match: false}, nil
+	return VerifyResult{Valid: true, CCCode: ccCode, BoundHash: bound, SubmittedHash: fileHash, Match: false}, nil
 }
 
 // HashExists 判断内容哈希是否已存在。
@@ -175,12 +175,12 @@ func (m *MemoryChain) HashExists(fileHash string) (string, bool) {
 }
 
 // VerifyEpisodeHash 按 MA 码+集号校验该集哈希。
-func (m *MemoryChain) VerifyEpisodeHash(maCode string, episode int, fileHash string) (VerifyResult, error) {
+func (m *MemoryChain) VerifyEpisodeHash(ccCode string, episode int, fileHash string) (VerifyResult, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
-	bs, ok := m.bindings[maCode]
+	bs, ok := m.bindings[ccCode]
 	if !ok {
-		return VerifyResult{Valid: false, MACode: maCode, SubmittedHash: fileHash}, ErrMANotIssued
+		return VerifyResult{Valid: false, CCCode: ccCode, SubmittedHash: fileHash}, ErrMANotIssued
 	}
 	var bound string
 	for _, b := range bs {
@@ -190,7 +190,7 @@ func (m *MemoryChain) VerifyEpisodeHash(maCode string, episode int, fileHash str
 			}
 			if b.HashValue == fileHash {
 				return VerifyResult{
-					Valid: true, MACode: maCode,
+					Valid: true, CCCode: ccCode,
 					BoundHash: b.HashValue, SubmittedHash: fileHash,
 					Match: true, Version: b.Version,
 				}, nil
@@ -198,16 +198,16 @@ func (m *MemoryChain) VerifyEpisodeHash(maCode string, episode int, fileHash str
 		}
 	}
 	if bound == "" {
-		return VerifyResult{Valid: false, MACode: maCode, SubmittedHash: fileHash}, ErrNotFound
+		return VerifyResult{Valid: false, CCCode: ccCode, SubmittedHash: fileHash}, ErrNotFound
 	}
-	return VerifyResult{Valid: true, MACode: maCode, BoundHash: bound, SubmittedHash: fileHash, Match: false}, nil
+	return VerifyResult{Valid: true, CCCode: ccCode, BoundHash: bound, SubmittedHash: fileHash, Match: false}, nil
 }
 
 // ListEpisodes 返回某 MA 码下的全部集级哈希绑定（episode > 0）。
-func (m *MemoryChain) ListEpisodes(maCode string) ([]model.HashBinding, error) {
+func (m *MemoryChain) ListEpisodes(ccCode string) ([]model.HashBinding, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
-	bs, ok := m.bindings[maCode]
+	bs, ok := m.bindings[ccCode]
 	if !ok {
 		return nil, ErrMANotIssued
 	}
@@ -221,10 +221,10 @@ func (m *MemoryChain) ListEpisodes(maCode string) ([]model.HashBinding, error) {
 }
 
 // QueryContent 查询内容主记录。
-func (m *MemoryChain) QueryContent(maCode string) (model.Content, error) {
+func (m *MemoryChain) QueryContent(ccCode string) (model.Content, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
-	c, ok := m.contents[maCode]
+	c, ok := m.contents[ccCode]
 	if !ok {
 		return model.Content{}, ErrNotFound
 	}
@@ -252,14 +252,14 @@ func (m *MemoryChain) ListContents(status string) ([]model.Content, error) {
 }
 
 // QueryMappings 查询 MA 码绑定的全部映射与 CDN 端点。
-func (m *MemoryChain) QueryMappings(maCode string) (MappingsResult, error) {
+func (m *MemoryChain) QueryMappings(ccCode string) (MappingsResult, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
-	if _, ok := m.contents[maCode]; !ok {
+	if _, ok := m.contents[ccCode]; !ok {
 		return MappingsResult{}, ErrNotFound
 	}
-	res := MappingsResult{MACode: maCode, Mappings: m.mappings[maCode]}
-	for _, mp := range m.mappings[maCode] {
+	res := MappingsResult{CCCode: ccCode, Mappings: m.mappings[ccCode]}
+	for _, mp := range m.mappings[ccCode] {
 		if mp.CDNEndpoint != "" {
 			res.CDNEndpoints = append(res.CDNEndpoints, mp.CDNEndpoint)
 		}
@@ -271,30 +271,30 @@ func (m *MemoryChain) QueryMappings(maCode string) (MappingsResult, error) {
 func (m *MemoryChain) RecordVersionChange(vc model.VersionChange) (string, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	maCode := m.maCodeByCTID(vc.ContentTwinID)
-	if maCode == "" {
+	ccCode := m.ccCodeByCTID(vc.ContentTwinID)
+	if ccCode == "" {
 		return "", ErrMANotIssued
 	}
-	m.versions[maCode] = append(m.versions[maCode], vc)
+	m.versions[ccCode] = append(m.versions[ccCode], vc)
 	return m.nextTx("recordVersionChange"), nil
 }
 
 // Revoke 下架，仅监管主体。
-func (m *MemoryChain) Revoke(role Role, maCode, reason string) (MappingsResult, error) {
+func (m *MemoryChain) Revoke(role Role, ccCode, reason string) (MappingsResult, error) {
 	if role != RoleRegulator {
 		return MappingsResult{}, ErrPermissionDenied
 	}
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	c, ok := m.contents[maCode]
+	c, ok := m.contents[ccCode]
 	if !ok {
 		return MappingsResult{}, ErrNotFound
 	}
 	c.Status = model.StatusRevoked
-	m.contents[maCode] = c
+	m.contents[ccCode] = c
 
-	res := MappingsResult{MACode: maCode, Mappings: m.mappings[maCode]}
-	for _, mp := range m.mappings[maCode] {
+	res := MappingsResult{CCCode: ccCode, Mappings: m.mappings[ccCode]}
+	for _, mp := range m.mappings[ccCode] {
 		if mp.CDNEndpoint != "" {
 			res.CDNEndpoints = append(res.CDNEndpoints, mp.CDNEndpoint)
 		}
@@ -303,13 +303,13 @@ func (m *MemoryChain) Revoke(role Role, maCode, reason string) (MappingsResult,
 }
 
 // RevokeEpisode 集级下架：只下架指定集，整剧其他集不受影响（仅监管主体）。
-func (m *MemoryChain) RevokeEpisode(role Role, maCode string, episode int, reason string) error {
+func (m *MemoryChain) RevokeEpisode(role Role, ccCode string, episode int, reason string) error {
 	if role != RoleRegulator {
 		return ErrPermissionDenied
 	}
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	bs, ok := m.bindings[maCode]
+	bs, ok := m.bindings[ccCode]
 	if !ok {
 		return ErrMANotIssued
 	}
@@ -324,34 +324,34 @@ func (m *MemoryChain) RevokeEpisode(role Role, maCode string, episode int, reaso
 	if !found {
 		return ErrNotFound
 	}
-	m.bindings[maCode] = bs
+	m.bindings[ccCode] = bs
 	return nil
 }
 
 // Restore 恢复上架整剧：下架状态恢复为流通中（仅监管主体）。
-func (m *MemoryChain) Restore(role Role, maCode string) error {
+func (m *MemoryChain) Restore(role Role, ccCode string) error {
 	if role != RoleRegulator {
 		return ErrPermissionDenied
 	}
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	c, ok := m.contents[maCode]
+	c, ok := m.contents[ccCode]
 	if !ok {
 		return ErrNotFound
 	}
 	c.Status = model.StatusPublished
-	m.contents[maCode] = c
+	m.contents[ccCode] = c
 	return nil
 }
 
 // RestoreEpisode 恢复上架指定集（仅监管主体）。
-func (m *MemoryChain) RestoreEpisode(role Role, maCode string, episode int) error {
+func (m *MemoryChain) RestoreEpisode(role Role, ccCode string, episode int) error {
 	if role != RoleRegulator {
 		return ErrPermissionDenied
 	}
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	bs, ok := m.bindings[maCode]
+	bs, ok := m.bindings[ccCode]
 	if !ok {
 		return ErrMANotIssued
 	}
@@ -366,25 +366,25 @@ func (m *MemoryChain) RestoreEpisode(role Role, maCode string, episode int) erro
 	if !found {
 		return ErrNotFound
 	}
-	m.bindings[maCode] = bs
+	m.bindings[ccCode] = bs
 	return nil
 }
 
 // SetContentStatus 更新内容状态。
-func (m *MemoryChain) SetContentStatus(maCode, status string) error {
+func (m *MemoryChain) SetContentStatus(ccCode, status string) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	c, ok := m.contents[maCode]
+	c, ok := m.contents[ccCode]
 	if !ok {
 		return ErrNotFound
 	}
 	c.Status = status
-	m.contents[maCode] = c
+	m.contents[ccCode] = c
 	return nil
 }
 
-// maCodeByCTID 内部辅助：通过 CTID 反查 MA 码（调用方已持锁）。
-func (m *MemoryChain) maCodeByCTID(ctid string) string {
+// ccCodeByCTID 内部辅助：通过 CTID 反查 MA 码（调用方已持锁）。
+func (m *MemoryChain) ccCodeByCTID(ctid string) string {
 	for ma, c := range m.contents {
 		if c.ContentTwinID == ctid {
 			return ma
@@ -397,15 +397,15 @@ func (m *MemoryChain) maCodeByCTID(ctid string) string {
 func (m *MemoryChain) QueryByHash(fileHash string) (model.ContentQueryResult, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
-	maCode, ok := m.hashIndex[fileHash]
+	ccCode, ok := m.hashIndex[fileHash]
 	if !ok {
 		return model.ContentQueryResult{Found: false}, ErrNotFound
 	}
 	return model.ContentQueryResult{
 		Found:    true,
-		Content:  m.contents[maCode],
-		Bindings: m.bindings[maCode],
-		Mappings: m.mappings[maCode],
+		Content:  m.contents[ccCode],
+		Bindings: m.bindings[ccCode],
+		Mappings: m.mappings[ccCode],
 	}, nil
 }
 
@@ -413,13 +413,13 @@ func (m *MemoryChain) QueryByHash(fileHash string) (model.ContentQueryResult, er
 func (m *MemoryChain) QueryByProvincialCode(provincialCode string) (model.ContentQueryResult, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
-	for maCode, maps := range m.mappings {
+	for ccCode, maps := range m.mappings {
 		for _, mp := range maps {
 			if mp.Party == model.PartyCP && mp.PartyID == provincialCode {
 				return model.ContentQueryResult{
 					Found:    true,
-					Content:  m.contents[maCode],
-					Bindings: m.bindings[maCode],
+					Content:  m.contents[ccCode],
+					Bindings: m.bindings[ccCode],
 					Mappings: maps,
 				}, nil
 			}
@@ -432,13 +432,13 @@ func (m *MemoryChain) QueryByProvincialCode(provincialCode string) (model.Conten
 func (m *MemoryChain) QueryByLibraryFileID(libraryFileID string) (model.ContentQueryResult, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
-	for maCode, maps := range m.mappings {
+	for ccCode, maps := range m.mappings {
 		for _, mp := range maps {
 			if mp.Party == model.PartyReviewer && mp.PartyID == libraryFileID {
 				return model.ContentQueryResult{
 					Found:    true,
-					Content:  m.contents[maCode],
-					Bindings: m.bindings[maCode],
+					Content:  m.contents[ccCode],
+					Bindings: m.bindings[ccCode],
 					Mappings: maps,
 				}, nil
 			}
@@ -456,7 +456,7 @@ func (m *MemoryChain) MergeMA(role Role, req model.MergeRequest) (model.MergeRes
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	primary, ok := m.contents[req.PrimaryMACode]
+	primary, ok := m.contents[req.PrimaryCCCode]
 	if !ok {
 		return model.MergeResult{}, ErrNotFound
 	}
@@ -464,7 +464,7 @@ func (m *MemoryChain) MergeMA(role Role, req model.MergeRequest) (model.MergeRes
 
 	migratedBindings := 0
 	migratedMappings := 0
-	for _, secMA := range req.SecondaryMACodes {
+	for _, secMA := range req.SecondaryCCCodes {
 		secContent, exists := m.contents[secMA]
 		if !exists {
 			return model.MergeResult{}, fmt.Errorf("%w: secondary MA %s not found", ErrNotFound, secMA)
@@ -476,21 +476,21 @@ func (m *MemoryChain) MergeMA(role Role, req model.MergeRequest) (model.MergeRes
 		// 迁移哈希绑定至主 MA 码
 		for _, b := range m.bindings[secMA] {
 			b.ContentTwinID = primary.ContentTwinID
-			m.bindings[req.PrimaryMACode] = append(m.bindings[req.PrimaryMACode], b)
+			m.bindings[req.PrimaryCCCode] = append(m.bindings[req.PrimaryCCCode], b)
 			migratedBindings++
 		}
 
 		// 迁移映射至主 MA 码
 		for _, mp := range m.mappings[secMA] {
 			mp.ContentTwinID = primary.ContentTwinID
-			m.mappings[req.PrimaryMACode] = append(m.mappings[req.PrimaryMACode], mp)
+			m.mappings[req.PrimaryCCCode] = append(m.mappings[req.PrimaryCCCode], mp)
 			migratedMappings++
 		}
 
 		// 更新哈希索引指向主 MA 码
 		for _, b := range m.bindings[secMA] {
 			if b.HashType == model.HashFile || b.HashType == model.HashTranscoded {
-				m.hashIndex[b.HashValue] = req.PrimaryMACode
+				m.hashIndex[b.HashValue] = req.PrimaryCCCode
 			}
 		}
 
@@ -503,8 +503,8 @@ func (m *MemoryChain) MergeMA(role Role, req model.MergeRequest) (model.MergeRes
 
 	txID := m.nextTx("mergeMA")
 	return model.MergeResult{
-		PrimaryMACode:    req.PrimaryMACode,
-		MergedMACodes:    req.SecondaryMACodes,
+		PrimaryCCCode:    req.PrimaryCCCode,
+		MergedCCCodes:    req.SecondaryCCCodes,
 		MigratedBindings: migratedBindings,
 		MigratedMappings: migratedMappings,
 		TxID:             txID,
@@ -520,30 +520,30 @@ func (m *MemoryChain) SplitMA(role Role, req model.SplitRequest) (model.SplitRes
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	srcContent, ok := m.contents[req.SourceMACode]
+	srcContent, ok := m.contents[req.SourceCCCode]
 	if !ok {
 		return model.SplitResult{}, ErrNotFound
 	}
 	if srcContent.Status == model.StatusMerged || srcContent.Status == model.StatusSplit {
-		return model.SplitResult{}, fmt.Errorf("chain: MA %s already %s", req.SourceMACode, srcContent.Status)
+		return model.SplitResult{}, fmt.Errorf("chain: MA %s already %s", req.SourceCCCode, srcContent.Status)
 	}
 
 	migratedBindings := 0
 	migratedMappings := 0
-	newMACodes := make([]string, 0, len(req.Splits))
+	newCCCodes := make([]string, 0, len(req.Splits))
 
 	for _, split := range req.Splits {
 		// 创建新内容记录
 		newContent := srcContent
-		newContent.MACode = split.NewMACode
-		newContent.ContentTwinID = split.NewMACode + "-ctid"
+		newContent.CCCode = split.NewCCCode
+		newContent.ContentTwinID = split.NewCCCode + "-ctid"
 		newContent.Title = split.Title
 		newContent.Status = model.StatusApproved
 		newContent.CreatedAt = time.Now()
-		m.contents[split.NewMACode] = newContent
+		m.contents[split.NewCCCode] = newContent
 
 		// 按集号迁移哈希绑定
-		for _, b := range m.bindings[req.SourceMACode] {
+		for _, b := range m.bindings[req.SourceCCCode] {
 			shouldMigrate := false
 			if len(split.Episodes) == 0 {
 				// 空集号列表：迁移全部（整剧拆分场景）
@@ -559,34 +559,34 @@ func (m *MemoryChain) SplitMA(role Role, req model.SplitRequest) (model.SplitRes
 			if shouldMigrate {
 				newB := b
 				newB.ContentTwinID = newContent.ContentTwinID
-				m.bindings[split.NewMACode] = append(m.bindings[split.NewMACode], newB)
+				m.bindings[split.NewCCCode] = append(m.bindings[split.NewCCCode], newB)
 				// 更新哈希索引
 				if b.HashType == model.HashFile || b.HashType == model.HashTranscoded {
-					m.hashIndex[b.HashValue] = split.NewMACode
+					m.hashIndex[b.HashValue] = split.NewCCCode
 				}
 				migratedBindings++
 			}
 		}
 
 		// 迁移映射（全部映射复制到新 MA 码）
-		for _, mp := range m.mappings[req.SourceMACode] {
+		for _, mp := range m.mappings[req.SourceCCCode] {
 			newMP := mp
 			newMP.ContentTwinID = newContent.ContentTwinID
-			m.mappings[split.NewMACode] = append(m.mappings[split.NewMACode], newMP)
+			m.mappings[split.NewCCCode] = append(m.mappings[split.NewCCCode], newMP)
 			migratedMappings++
 		}
 
-		newMACodes = append(newMACodes, split.NewMACode)
+		newCCCodes = append(newCCCodes, split.NewCCCode)
 	}
 
 	// 源 MA 码状态标记为 split
 	srcContent.Status = model.StatusSplit
-	m.contents[req.SourceMACode] = srcContent
+	m.contents[req.SourceCCCode] = srcContent
 
 	txID := m.nextTx("splitMA")
 	return model.SplitResult{
-		SourceMACode:     req.SourceMACode,
-		NewMACodes:       newMACodes,
+		SourceCCCode:     req.SourceCCCode,
+		NewCCCodes:       newCCCodes,
 		MigratedBindings: migratedBindings,
 		MigratedMappings: migratedMappings,
 		TxID:             txID,
diff --git a/tcs-iptv/internal/chain/memory_test.go b/tcs-iptv/internal/chain/memory_test.go
index efdd90d..763b191 100644
--- a/tcs-iptv/internal/chain/memory_test.go
+++ b/tcs-iptv/internal/chain/memory_test.go
@@ -12,7 +12,7 @@ func newIssued(t *testing.T) *MemoryChain {
 	t.Helper()
 	c := NewMemoryChain()
 	_, err := c.IssueMA(RoleRegulator, IssueRequest{
-		MACode:        "(京)网微剧审字(2025)第123号",
+		CCCode:        "(京)网微剧审字(2025)第123号",
 		ContentTwinID: "ctid-001",
 		MerkleRoot:    "merkle-root-1",
 		FileHash:      "filehash-1",
@@ -24,13 +24,13 @@ func newIssued(t *testing.T) *MemoryChain {
 
 func TestIssueMA_OnlyRegulator(t *testing.T) {
 	c := NewMemoryChain()
-	_, err := c.IssueMA(RoleCP, IssueRequest{MACode: "MA-1", ContentTwinID: "ct-1", FileHash: "h1"})
+	_, err := c.IssueMA(RoleCP, IssueRequest{CCCode: "MA-1", ContentTwinID: "ct-1", FileHash: "h1"})
 	assert.ErrorIs(t, err, ErrPermissionDenied)
 
-	_, err = c.IssueMA(RoleReviewer, IssueRequest{MACode: "MA-1", ContentTwinID: "ct-1", FileHash: "h1"})
+	_, err = c.IssueMA(RoleReviewer, IssueRequest{CCCode: "MA-1", ContentTwinID: "ct-1", FileHash: "h1"})
 	assert.ErrorIs(t, err, ErrPermissionDenied)
 
-	_, err = c.IssueMA(RoleRegulator, IssueRequest{MACode: "MA-1", ContentTwinID: "ct-1", FileHash: "h1"})
+	_, err = c.IssueMA(RoleRegulator, IssueRequest{CCCode: "MA-1", ContentTwinID: "ct-1", FileHash: "h1"})
 	assert.NoError(t, err)
 }
 
@@ -38,7 +38,7 @@ func TestIssueMA_NoReissue(t *testing.T) {
 	c := newIssued(t)
 	// 同 MA 码重复签发被拒（1:1 不可解绑/不可覆盖）
 	_, err := c.IssueMA(RoleRegulator, IssueRequest{
-		MACode: "(京)网微剧审字(2025)第123号", ContentTwinID: "ctid-001", FileHash: "other",
+		CCCode: "(京)网微剧审字(2025)第123号", ContentTwinID: "ctid-001", FileHash: "other",
 	})
 	assert.ErrorIs(t, err, ErrMAAlreadyIssued)
 }
@@ -47,7 +47,7 @@ func TestIssueMA_DuplicateHashRejected(t *testing.T) {
 	c := newIssued(t)
 	// 换壳重发：不同 MA 码但相同内容哈希 → 拒绝
 	_, err := c.IssueMA(RoleRegulator, IssueRequest{
-		MACode: "(沪)网微剧审字(2025)第999号", ContentTwinID: "ctid-002", FileHash: "filehash-1",
+		CCCode: "(沪)网微剧审字(2025)第999号", ContentTwinID: "ctid-002", FileHash: "filehash-1",
 	})
 	assert.ErrorIs(t, err, ErrHashExists)
 }
diff --git a/tcs-iptv/internal/chain/persistent.go b/tcs-iptv/internal/chain/persistent.go
index deb5fd3..017d634 100644
--- a/tcs-iptv/internal/chain/persistent.go
+++ b/tcs-iptv/internal/chain/persistent.go
@@ -40,9 +40,9 @@ func (p *PersistentChain) IssueMA(role Role, req IssueRequest) (string, error) {
 	if err != nil {
 		return tx, err
 	}
-	c, _ := p.MemoryChain.QueryContent(req.MACode)
+	c, _ := p.MemoryChain.QueryContent(req.CCCode)
 	p.persistContent(c)
-	for _, b := range p.snapshotBindings(req.MACode) {
+	for _, b := range p.snapshotBindings(req.CCCode) {
 		p.persistBinding(b)
 	}
 	p.persistTx(req.ContentTwinID, tx, "issueMA")
@@ -86,48 +86,48 @@ func (p *PersistentChain) RecordVersionChange(vc model.VersionChange) (string, e
 }
 
 // Revoke 整剧下架：镜像内容状态。
-func (p *PersistentChain) Revoke(role Role, maCode, reason string) (MappingsResult, error) {
-	res, err := p.MemoryChain.Revoke(role, maCode, reason)
+func (p *PersistentChain) Revoke(role Role, ccCode, reason string) (MappingsResult, error) {
+	res, err := p.MemoryChain.Revoke(role, ccCode, reason)
 	if err != nil {
 		return res, err
 	}
-	p.updateStatus(maCode, model.StatusRevoked)
+	p.updateStatus(ccCode, model.StatusRevoked)
 	return res, nil
 }
 
 // Restore 整剧恢复上架：镜像内容状态。
-func (p *PersistentChain) Restore(role Role, maCode string) error {
-	if err := p.MemoryChain.Restore(role, maCode); err != nil {
+func (p *PersistentChain) Restore(role Role, ccCode string) error {
+	if err := p.MemoryChain.Restore(role, ccCode); err != nil {
 		return err
 	}
-	p.updateStatus(maCode, model.StatusPublished)
+	p.updateStatus(ccCode, model.StatusPublished)
 	return nil
 }
 
 // RevokeEpisode 集级下架：镜像该集 revoked 标记。
-func (p *PersistentChain) RevokeEpisode(role Role, maCode string, episode int, reason string) error {
-	if err := p.MemoryChain.RevokeEpisode(role, maCode, episode, reason); err != nil {
+func (p *PersistentChain) RevokeEpisode(role Role, ccCode string, episode int, reason string) error {
+	if err := p.MemoryChain.RevokeEpisode(role, ccCode, episode, reason); err != nil {
 		return err
 	}
-	p.updateEpisodeRevoked(maCode, episode, true, reason)
+	p.updateEpisodeRevoked(ccCode, episode, true, reason)
 	return nil
 }
 
 // RestoreEpisode 集级恢复：镜像该集 revoked 标记。
-func (p *PersistentChain) RestoreEpisode(role Role, maCode string, episode int) error {
-	if err := p.MemoryChain.RestoreEpisode(role, maCode, episode); err != nil {
+func (p *PersistentChain) RestoreEpisode(role Role, ccCode string, episode int) error {
+	if err := p.MemoryChain.RestoreEpisode(role, ccCode, episode); err != nil {
 		return err
 	}
-	p.updateEpisodeRevoked(maCode, episode, false, "")
+	p.updateEpisodeRevoked(ccCode, episode, false, "")
 	return nil
 }
 
 // SetContentStatus 状态流转（入库/发布等）：镜像内容状态。
-func (p *PersistentChain) SetContentStatus(maCode, status string) error {
-	if err := p.MemoryChain.SetContentStatus(maCode, status); err != nil {
+func (p *PersistentChain) SetContentStatus(ccCode, status string) error {
+	if err := p.MemoryChain.SetContentStatus(ccCode, status); err != nil {
 		return err
 	}
-	p.updateStatus(maCode, status)
+	p.updateStatus(ccCode, status)
 	return nil
 }
 
@@ -138,14 +138,14 @@ func (p *PersistentChain) MergeMA(role Role, req model.MergeRequest) (model.Merg
 		return res, err
 	}
 	// 被合并的 MA 码状态标记为 merged
-	for _, secMA := range req.SecondaryMACodes {
+	for _, secMA := range req.SecondaryCCCodes {
 		p.updateStatus(secMA, model.StatusMerged)
 	}
 	// 主 MA 码的绑定和映射已在内存中追加，写穿最新状态
-	for _, b := range p.snapshotBindings(req.PrimaryMACode) {
+	for _, b := range p.snapshotBindings(req.PrimaryCCCode) {
 		p.persistBinding(b)
 	}
-	p.persistTx(req.PrimaryMACode, res.TxID, "mergeMA")
+	p.persistTx(req.PrimaryCCCode, res.TxID, "mergeMA")
 	return res, nil
 }
 
@@ -156,9 +156,9 @@ func (p *PersistentChain) SplitMA(role Role, req model.SplitRequest) (model.Spli
 		return res, err
 	}
 	// 源 MA 码状态标记为 split
-	p.updateStatus(req.SourceMACode, model.StatusSplit)
+	p.updateStatus(req.SourceCCCode, model.StatusSplit)
 	// 新 MA 码的内容记录和绑定写穿
-	for _, newMA := range res.NewMACodes {
+	for _, newMA := range res.NewCCCodes {
 		c, _ := p.MemoryChain.QueryContent(newMA)
 		p.persistContent(c)
 		for _, b := range p.snapshotBindings(newMA) {
@@ -168,7 +168,7 @@ func (p *PersistentChain) SplitMA(role Role, req model.SplitRequest) (model.Spli
 			p.persistMapping(mp)
 		}
 	}
-	p.persistTx(req.SourceMACode, res.TxID, "splitMA")
+	p.persistTx(req.SourceCCCode, res.TxID, "splitMA")
 	return res, nil
 }
 
@@ -189,7 +189,7 @@ func (p *PersistentChain) persistContent(c model.Content) {
 		(content_twin_id, ma_code, ma_type, title, episode_count, status, issuer, issue_date, created_at)
 		VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)
 		ON CONFLICT (content_twin_id) DO UPDATE SET status=EXCLUDED.status, updated_at=NOW()`,
-		c.ContentTwinID, c.MACode, c.MAType, c.Title, c.EpisodeCount, c.Status, c.Issuer, issueDate, c.CreatedAt)
+		c.ContentTwinID, c.CCCode, c.MAType, c.Title, c.EpisodeCount, c.Status, c.Issuer, issueDate, c.CreatedAt)
 }
 
 func (p *PersistentChain) persistBinding(b model.HashBinding) {
@@ -214,32 +214,32 @@ func (p *PersistentChain) persistTx(ctid, txID, method string) {
 		ctid, txID, method)
 }
 
-func (p *PersistentChain) updateStatus(maCode, status string) {
-	p.exec(`UPDATE content_registry SET status=$1, updated_at=NOW() WHERE ma_code=$2`, status, maCode)
+func (p *PersistentChain) updateStatus(ccCode, status string) {
+	p.exec(`UPDATE content_registry SET status=$1, updated_at=NOW() WHERE ma_code=$2`, status, ccCode)
 }
 
-func (p *PersistentChain) updateEpisodeRevoked(maCode string, episode int, revoked bool, reason string) {
+func (p *PersistentChain) updateEpisodeRevoked(ccCode string, episode int, revoked bool, reason string) {
 	p.exec(`UPDATE hash_binding hb SET revoked=$1, revoked_reason=$2
 		FROM content_registry cr
 		WHERE hb.content_twin_id = cr.content_twin_id AND cr.ma_code=$3 AND hb.episode=$4`,
-		revoked, reason, maCode, episode)
+		revoked, reason, ccCode, episode)
 }
 
 // snapshotBindings 复制某 MA 码当前的内存绑定（同包访问，读锁保护）。
-func (p *PersistentChain) snapshotBindings(maCode string) []model.HashBinding {
+func (p *PersistentChain) snapshotBindings(ccCode string) []model.HashBinding {
 	p.mu.RLock()
 	defer p.mu.RUnlock()
-	src := p.bindings[maCode]
+	src := p.bindings[ccCode]
 	out := make([]model.HashBinding, len(src))
 	copy(out, src)
 	return out
 }
 
 // snapshotMappings 复制某 MA 码当前的内存映射（同包访问，读锁保护）。
-func (p *PersistentChain) snapshotMappings(maCode string) []model.Mapping {
+func (p *PersistentChain) snapshotMappings(ccCode string) []model.Mapping {
 	p.mu.RLock()
 	defer p.mu.RUnlock()
-	src := p.mappings[maCode]
+	src := p.mappings[ccCode]
 	out := make([]model.Mapping, len(src))
 	copy(out, src)
 	return out
@@ -248,7 +248,7 @@ func (p *PersistentChain) snapshotMappings(maCode string) []model.Mapping {
 // ---- 启动水合：从 PG 镜像恢复内存状态 ----
 
 func (p *PersistentChain) hydrate() error {
-	// 1) 内容主表 + 建立 ctid -> maCode 映射
+	// 1) 内容主表 + 建立 ctid -> ccCode 映射
 	ctidToMA := map[string]string{}
 	rows, err := p.db.Query(`SELECT content_twin_id, ma_code, COALESCE(ma_type,''), title,
 		COALESCE(episode_count,1), status, COALESCE(issuer,''),
@@ -259,13 +259,13 @@ func (p *PersistentChain) hydrate() error {
 	n := 0
 	for rows.Next() {
 		var c model.Content
-		if err := rows.Scan(&c.ContentTwinID, &c.MACode, &c.MAType, &c.Title,
+		if err := rows.Scan(&c.ContentTwinID, &c.CCCode, &c.MAType, &c.Title,
 			&c.EpisodeCount, &c.Status, &c.Issuer, &c.IssueDate, &c.CreatedAt); err != nil {
 			rows.Close()
 			return err
 		}
-		p.contents[c.MACode] = c
-		ctidToMA[c.ContentTwinID] = c.MACode
+		p.contents[c.CCCode] = c
+		ctidToMA[c.ContentTwinID] = c.CCCode
 		n++
 	}
 	rows.Close()
diff --git a/tcs-iptv/internal/model/authorization.go b/tcs-iptv/internal/model/authorization.go
index f79da15..8dd75e3 100644
--- a/tcs-iptv/internal/model/authorization.go
+++ b/tcs-iptv/internal/model/authorization.go
@@ -6,7 +6,7 @@ import "time"
 
 // Authorization 信息网络传播权授权（需求25-AC1）。
 type Authorization struct {
-	MACode    string    `json:"ma_code"`
+	CCCode    string    `json:"ma_code"`
 	Regions   []string  `json:"regions"`   // 授权地域（省码），空=全国
 	Platforms []string  `json:"platforms"` // 授权平台/运营商，空=不限
 	ExpiryAt  time.Time `json:"expiry_at"` // 授权到期；零值=长期
@@ -22,7 +22,7 @@ type AuthCheckResult struct {
 // CrossProvinceResult 跨省复用准入结果（需求13）。
 type CrossProvinceResult struct {
 	Admitted       bool   `json:"admitted"`
-	MACodeValid    bool   `json:"ma_code_valid"`
+	CCCodeValid    bool   `json:"ma_code_valid"`
 	HashConsistent bool   `json:"hash_consistent"`
 	NotBlacklisted bool   `json:"not_blacklisted"`
 	ProvinceFlowNo string `json:"province_flow_no"` // 本省审核流水号
diff --git a/tcs-iptv/internal/model/model.go b/tcs-iptv/internal/model/model.go
index 965cf37..b3b326e 100644
--- a/tcs-iptv/internal/model/model.go
+++ b/tcs-iptv/internal/model/model.go
@@ -16,7 +16,7 @@ const (
 // Content 内容主表（Content Registry）。
 type Content struct {
 	ContentTwinID string    `json:"content_twin_id"`
-	MACode        string    `json:"ma_code"`
+	CCCode        string    `json:"ma_code"`
 	MAType        string    `json:"ma_type"`
 	Title         string    `json:"title"`
 	EpisodeCount  int       `json:"episode_count"`
@@ -95,8 +95,8 @@ const (
 	StatusInLibrary   = "in_library"   // 已入媒资库
 	StatusPublished   = "published"    // 已发布
 	StatusRevoked     = "revoked"      // 已下架
-	StatusMerged      = "merged"       // 已合并入其他MA码
-	StatusSplit       = "split"        // 已拆分为多个MA码
+	StatusMerged      = "merged"       // 已合并入其他CC码
+	StatusSplit       = "split"        // 已拆分为多个CC码
 )
 
 // ContentQueryResult 多维度标识查询的统一返回结果。
@@ -110,16 +110,16 @@ type ContentQueryResult struct {
 
 // MergeRequest MA 合并请求（将多个 MA 码合并为一个主 MA 码）。
 type MergeRequest struct {
-	PrimaryMACode   string   `json:"primary_ma_code"`   // 合并后保留的主 MA 码
-	SecondaryMACodes []string `json:"secondary_ma_codes"` // 被合并的 MA 码列表（合并后标记为 merged）
+	PrimaryCCCode   string   `json:"primary_ma_code"`   // 合并后保留的主 MA 码
+	SecondaryCCCodes []string `json:"secondary_ma_codes"` // 被合并的 MA 码列表（合并后标记为 merged）
 	Reason          string   `json:"reason"`            // 合并原因
 	Operator        string   `json:"operator"`          // 操作人
 }
 
 // MergeResult MA 合并结果。
 type MergeResult struct {
-	PrimaryMACode    string   `json:"primary_ma_code"`    // 主 MA 码
-	MergedMACodes    []string `json:"merged_ma_codes"`    // 已合并的 MA 码列表
+	PrimaryCCCode    string   `json:"primary_ma_code"`    // 主 MA 码
+	MergedCCCodes    []string `json:"merged_ma_codes"`    // 已合并的 MA 码列表
 	MigratedBindings int      `json:"migrated_bindings"`  // 迁移的哈希绑定数
 	MigratedMappings int      `json:"migrated_mappings"`  // 迁移的映射数
 	TxID             string   `json:"tx_id"`              // 链上交易 ID
@@ -127,7 +127,7 @@ type MergeResult struct {
 
 // SplitRequest MA 拆分请求（将一个 MA 码拆分为多个独立 MA 码）。
 type SplitRequest struct {
-	SourceMACode string          `json:"source_ma_code"`  // 被拆分的源 MA 码
+	SourceCCCode string          `json:"source_ma_code"`  // 被拆分的源 MA 码
 	Splits       []SplitTarget   `json:"splits"`          // 拆分目标列表
 	Reason       string          `json:"reason"`          // 拆分原因
 	Operator     string          `json:"operator"`        // 操作人
@@ -135,15 +135,15 @@ type SplitRequest struct {
 
 // SplitTarget 拆分目标：每集或每组内容拆分后的新 MA 码信息。
 type SplitTarget struct {
-	NewMACode  string `json:"new_ma_code"`   // 拆分后新分配的 MA 码
+	NewCCCode  string `json:"new_ma_code"`   // 拆分后新分配的 MA 码
 	Title      string `json:"title"`         // 拆分后内容标题
 	Episodes   []int  `json:"episodes"`      // 关联的集号列表（空表示整剧拆分）
 }
 
 // SplitResult MA 拆分结果。
 type SplitResult struct {
-	SourceMACode     string   `json:"source_ma_code"`     // 源 MA 码
-	NewMACodes       []string `json:"new_ma_codes"`       // 拆分后生成的新 MA 码列表
+	SourceCCCode     string   `json:"source_ma_code"`     // 源 MA 码
+	NewCCCodes       []string `json:"new_ma_codes"`       // 拆分后生成的新 MA 码列表
 	MigratedBindings int      `json:"migrated_bindings"`  // 迁移的哈希绑定数
 	MigratedMappings int      `json:"migrated_mappings"`  // 迁移的映射数
 	TxID             string   `json:"tx_id"`              // 链上交易 ID
diff --git a/tcs-iptv/internal/model/playback.go b/tcs-iptv/internal/model/playback.go
index eff5240..a3cf668 100644
--- a/tcs-iptv/internal/model/playback.go
+++ b/tcs-iptv/internal/model/playback.go
@@ -15,7 +15,7 @@ const (
 
 // PlaybackEvent 运营商以 MA 码为维度回传的播放/消费事件（需求9-AC1）。
 type PlaybackEvent struct {
-	MACode      string            `json:"ma_code"`
+	CCCode      string            `json:"ma_code"`
 	Episode     int               `json:"episode"`     // 0=整剧/单体
 	PlatformID  string            `json:"platform_id"` // 运营商节点
 	UserHash    string            `json:"user_hash"`   // 用户标识哈希（隐私保护）
@@ -27,7 +27,7 @@ type PlaybackEvent struct {
 
 // PlaybackSummary 按 MA 码聚合的可信播放数据（需求9-AC2、需求21-AC1）。
 type PlaybackSummary struct {
-	MACode        string                    `json:"ma_code"`
+	CCCode        string                    `json:"ma_code"`
 	TotalPlays    int64                     `json:"total_plays"`
 	TotalComplete int64                     `json:"total_complete"`
 	TotalRevenue  int64                     `json:"total_revenue_cent"`
@@ -55,7 +55,7 @@ func DefaultShareConfig() RevenueShareConfig {
 
 // Settlement 基于可信播放数据的分账结算结果（需求21-AC3）。
 type Settlement struct {
-	MACode        string `json:"ma_code"`
+	CCCode        string `json:"ma_code"`
 	Period        string `json:"period"`
 	TotalRevenue  int64  `json:"total_revenue_cent"`
 	CPShare       int64  `json:"cp_share_cent"`
diff --git a/tcs-iptv/internal/model/provenance.go b/tcs-iptv/internal/model/provenance.go
index ad87aa5..039fab7 100644
--- a/tcs-iptv/internal/model/provenance.go
+++ b/tcs-iptv/internal/model/provenance.go
@@ -18,7 +18,7 @@ const (
 
 // ProvenanceEvent 全链路存证事件（需求22-AC1/AC3）：带时间戳、操作方、不可篡改。
 type ProvenanceEvent struct {
-	MACode    string         `json:"ma_code"`
+	CCCode    string         `json:"ma_code"`
 	Node      ProvenanceNode `json:"node"`
 	HashValue string         `json:"hash_value"` // 该节点经手的内容哈希（可空，如纯审核结论）
 	Operator  string         `json:"operator"`   // 操作方标识
@@ -28,7 +28,7 @@ type ProvenanceEvent struct {
 
 // AccountabilityReport 责任界定取证报告（需求22-AC2/AC4）。
 type AccountabilityReport struct {
-	MACode       string            `json:"ma_code"`
+	CCCode       string            `json:"ma_code"`
 	Trail        []ProvenanceEvent `json:"trail"`
 	BaselineHash string            `json:"baseline_hash"` // 发码时绑定的基准哈希
 	FirstChange  *ProvenanceEvent  `json:"first_change"`  // 首次发生哈希变化的节点（nil=全程一致）
@@ -38,7 +38,7 @@ type AccountabilityReport struct {
 
 // CopyrightEvidence 版权确权证据链（需求23-AC1/AC2）。
 type CopyrightEvidence struct {
-	MACode      string            `json:"ma_code"`
+	CCCode      string            `json:"ma_code"`
 	Title       string            `json:"title"`
 	ContentHash string            `json:"content_hash"`
 	Issuer      string            `json:"issuer"`
@@ -51,7 +51,7 @@ type CopyrightEvidence struct {
 
 // InfringeMatch 疑似侵权命中（需求23-AC3）。
 type InfringeMatch struct {
-	MACode     string `json:"ma_code"`
+	CCCode     string `json:"ma_code"`
 	Title      string `json:"title"`
 	Distance   int    `json:"hamming_distance"` // 感知哈希汉明距离，越小越相似
 	Similarity string `json:"similarity"`       // high/medium
diff --git a/tcs-iptv/internal/model/regulatory.go b/tcs-iptv/internal/model/regulatory.go
index 573d7fc..e86d3f4 100644
--- a/tcs-iptv/internal/model/regulatory.go
+++ b/tcs-iptv/internal/model/regulatory.go
@@ -4,7 +4,7 @@ package model
 
 // FilingRecord 备案/网标关联（三期 A.1，对接广电总局备案/发行许可证系统）。
 type FilingRecord struct {
-	MACode    string `json:"ma_code"`
+	CCCode    string `json:"ma_code"`
 	LicenseNo string `json:"license_no"` // 网络剧片发行许可证号（网标号）
 	FilingNo  string `json:"filing_no"`  // 重点网络影视剧备案号
 	BoundAt   string `json:"bound_at"`
diff --git a/tcs-iptv/internal/model/rights.go b/tcs-iptv/internal/model/rights.go
index bf47c38..8b40920 100644
--- a/tcs-iptv/internal/model/rights.go
+++ b/tcs-iptv/internal/model/rights.go
@@ -44,7 +44,7 @@ type ParsedMA struct {
 
 // ResolveResult 跨域解析网关返回（四期 C.1/C.2，大小屏统一解析）。
 type ResolveResult struct {
-	MACode        string       `json:"ma_code"`
+	CCCode        string       `json:"ma_code"`
 	Parsed        ParsedMA     `json:"parsed"`
 	Title         string       `json:"title"`
 	Status        string       `json:"status"`         // 流通状态（published/revoked/...）
@@ -58,7 +58,7 @@ type ResolveResult struct {
 
 // ScanVerifyResult 用户扫码验真返回（四期 B.2）。
 type ScanVerifyResult struct {
-	MACode    string       `json:"ma_code"`
+	CCCode    string       `json:"ma_code"`
 	Authentic bool         `json:"authentic"` // MA 码真伪（链上存在且结构合法）
 	Compliant bool         `json:"compliant"` // 是否合规流通（未下架）
 	Status    string       `json:"status"`
@@ -70,7 +70,7 @@ type ScanVerifyResult struct {
 
 // PurchaseRecord 用户一次购买记录（四期 D.1）。
 type PurchaseRecord struct {
-	MACode      string     `json:"ma_code"`
+	CCCode      string     `json:"ma_code"`
 	UserHash    string     `json:"user_hash"`
 	Screen      ScreenType `json:"screen"` // 购买时所在屏
 	PurchasedAt time.Time  `json:"purchased_at"`
@@ -79,12 +79,12 @@ type PurchaseRecord struct {
 // UserRights 用户跨屏权益账户：以 MA 码为维度记录购买，任一屏购买即全屏通看。
 type UserRights struct {
 	UserHash  string                    `json:"user_hash"`
-	Purchases map[string]PurchaseRecord `json:"purchases"` // maCode -> record
+	Purchases map[string]PurchaseRecord `json:"purchases"` // ccCode -> record
 }
 
 // CrossScreenRightsResult 跨屏权益核验返回（四期 D.1）。
 type CrossScreenRightsResult struct {
-	MACode         string     `json:"ma_code"`
+	CCCode         string     `json:"ma_code"`
 	UserHash       string     `json:"user_hash"`
 	Entitled       bool       `json:"entitled"`                  // 是否有权益（任一屏购买即全屏通看）
 	RequestScreen  ScreenType `json:"request_screen"`            // 当前请求屏
diff --git a/tcs-iptv/internal/nationalcatalog/nationalcatalog.go b/tcs-iptv/internal/nationalcatalog/nationalcatalog.go
index c9d8d63..69f0a3a 100644
--- a/tcs-iptv/internal/nationalcatalog/nationalcatalog.go
+++ b/tcs-iptv/internal/nationalcatalog/nationalcatalog.go
@@ -25,11 +25,11 @@ import (
 // 聚合多省标识数据，提供统一查询入口。
 type NationalCatalog struct {
 	mu          stdsync.RWMutex
-	contents    map[string]model.Content           // maCode -> Content
-	bindings    map[string][]model.HashBinding     // maCode -> bindings
-	mappings    map[string][]model.Mapping         // maCode -> mappings
+	contents    map[string]model.Content           // ccCode -> Content
+	bindings    map[string][]model.HashBinding     // ccCode -> bindings
+	mappings    map[string][]model.Mapping         // ccCode -> mappings
 	provinces   map[string]*ProvinceInfo           // provinceCode -> 省级信息
-	auditShared map[string][]model.ProvenanceEvent // maCode -> 跨省共享审核记录
+	auditShared map[string][]model.ProvenanceEvent // ccCode -> 跨省共享审核记录
 }
 
 // ProvinceInfo 省级节点信息。
@@ -81,44 +81,44 @@ func (nc *NationalCatalog) ListProvinces() []ProvinceInfo {
 func (nc *NationalCatalog) UpsertContent(c model.Content) error {
 	nc.mu.Lock()
 	defer nc.mu.Unlock()
-	if _, exists := nc.contents[c.MACode]; exists {
+	if _, exists := nc.contents[c.CCCode]; exists {
 		return syncpkg.ErrConflict
 	}
-	nc.contents[c.MACode] = c
+	nc.contents[c.CCCode] = c
 	return nil
 }
 
 // UpsertBinding 写入/更新哈希绑定。
-func (nc *NationalCatalog) UpsertBinding(maCode string, b model.HashBinding) error {
+func (nc *NationalCatalog) UpsertBinding(ccCode string, b model.HashBinding) error {
 	nc.mu.Lock()
 	defer nc.mu.Unlock()
-	nc.bindings[maCode] = append(nc.bindings[maCode], b)
+	nc.bindings[ccCode] = append(nc.bindings[ccCode], b)
 	return nil
 }
 
 // UpsertMapping 写入/更新映射。
-func (nc *NationalCatalog) UpsertMapping(maCode string, m model.Mapping) error {
+func (nc *NationalCatalog) UpsertMapping(ccCode string, m model.Mapping) error {
 	nc.mu.Lock()
 	defer nc.mu.Unlock()
-	nc.mappings[maCode] = append(nc.mappings[maCode], m)
+	nc.mappings[ccCode] = append(nc.mappings[ccCode], m)
 	return nil
 }
 
 // ---- 全国统一查询 ----
 
 // QueryByMA 按 MA 码查询（全国维度）。
-func (nc *NationalCatalog) QueryByMA(maCode string) (model.ContentQueryResult, error) {
+func (nc *NationalCatalog) QueryByMA(ccCode string) (model.ContentQueryResult, error) {
 	nc.mu.RLock()
 	defer nc.mu.RUnlock()
-	c, ok := nc.contents[maCode]
+	c, ok := nc.contents[ccCode]
 	if !ok {
-		return model.ContentQueryResult{Found: false}, fmt.Errorf("national: MA 码 %s 未找到", maCode)
+		return model.ContentQueryResult{Found: false}, fmt.Errorf("national: MA 码 %s 未找到", ccCode)
 	}
 	return model.ContentQueryResult{
 		Found:    true,
 		Content:  c,
-		Bindings: nc.bindings[maCode],
-		Mappings: nc.mappings[maCode],
+		Bindings: nc.bindings[ccCode],
+		Mappings: nc.mappings[ccCode],
 	}, nil
 }
 
@@ -127,25 +127,25 @@ func (nc *NationalCatalog) QueryByHash(fileHash string) (model.ContentQueryResul
 	nc.mu.RLock()
 	defer nc.mu.RUnlock()
 	// 先搜索 Content.FileHash（整剧主哈希）
-	for maCode, c := range nc.contents {
+	for ccCode, c := range nc.contents {
 		if c.FileHash == fileHash {
 			return model.ContentQueryResult{
 				Found:    true,
 				Content:  c,
-				Bindings: nc.bindings[maCode],
-				Mappings: nc.mappings[maCode],
+				Bindings: nc.bindings[ccCode],
+				Mappings: nc.mappings[ccCode],
 			}, nil
 		}
 	}
 	// 再搜索 bindings 中的 HashValue（集级/转码版哈希）
-	for maCode, bindings := range nc.bindings {
+	for ccCode, bindings := range nc.bindings {
 		for _, b := range bindings {
 			if b.HashValue == fileHash {
 				return model.ContentQueryResult{
 					Found:    true,
-					Content:  nc.contents[maCode],
+					Content:  nc.contents[ccCode],
 					Bindings: bindings,
-					Mappings: nc.mappings[maCode],
+					Mappings: nc.mappings[ccCode],
 				}, nil
 			}
 		}
@@ -157,13 +157,13 @@ func (nc *NationalCatalog) QueryByHash(fileHash string) (model.ContentQueryResul
 func (nc *NationalCatalog) QueryByProvincialCode(provincialCode string) (model.ContentQueryResult, error) {
 	nc.mu.RLock()
 	defer nc.mu.RUnlock()
-	for maCode, mappings := range nc.mappings {
+	for ccCode, mappings := range nc.mappings {
 		for _, mp := range mappings {
 			if mp.Party == model.PartyCP && mp.PartyID == provincialCode {
 				return model.ContentQueryResult{
 					Found:    true,
-					Content:  nc.contents[maCode],
-					Bindings: nc.bindings[maCode],
+					Content:  nc.contents[ccCode],
+					Bindings: nc.bindings[ccCode],
 					Mappings: mappings,
 				}, nil
 			}
@@ -175,17 +175,17 @@ func (nc *NationalCatalog) QueryByProvincialCode(provincialCode string) (model.C
 // ---- 跨省审核记录共享 ----
 
 // ShareAuditRecord 省级节点上报审核记录至全国中心。
-func (nc *NationalCatalog) ShareAuditRecord(maCode string, event model.ProvenanceEvent) {
+func (nc *NationalCatalog) ShareAuditRecord(ccCode string, event model.ProvenanceEvent) {
 	nc.mu.Lock()
 	defer nc.mu.Unlock()
-	nc.auditShared[maCode] = append(nc.auditShared[maCode], event)
+	nc.auditShared[ccCode] = append(nc.auditShared[ccCode], event)
 }
 
 // QuerySharedAudit 查询跨省共享的审核记录。
-func (nc *NationalCatalog) QuerySharedAudit(maCode string) []model.ProvenanceEvent {
+func (nc *NationalCatalog) QuerySharedAudit(ccCode string) []model.ProvenanceEvent {
 	nc.mu.RLock()
 	defer nc.mu.RUnlock()
-	return nc.auditShared[maCode]
+	return nc.auditShared[ccCode]
 }
 
 // ---- 全国统计 ----
@@ -214,7 +214,7 @@ func (nc *NationalCatalog) Stats() NationalStats {
 		st.ByStatus[c.Status]++
 		st.ByCategory[c.MAType]++
 		// 按机构节点统计省份
-		for _, mp := range nc.mappings[c.MACode] {
+		for _, mp := range nc.mappings[c.CCCode] {
 			if mp.Party == model.PartyCP {
 				st.ByProvince[mp.PartyName]++
 			}
diff --git a/tcs-iptv/internal/nationalcatalog/nationalcatalog_test.go b/tcs-iptv/internal/nationalcatalog/nationalcatalog_test.go
index 93d9b15..4b9e451 100644
--- a/tcs-iptv/internal/nationalcatalog/nationalcatalog_test.go
+++ b/tcs-iptv/internal/nationalcatalog/nationalcatalog_test.go
@@ -29,7 +29,7 @@ func TestNationalCatalog_SyncFromProvince(t *testing.T) {
 	// 源端发码
 	srcClient := chain.NewMemoryChain()
 	_, err := srcClient.IssueMA(chain.RoleRegulator, chain.IssueRequest{
-		MACode: "MA.156.8531.6101/WD/20260000001", ContentTwinID: "ctid-nat-001",
+		CCCode: "MA.156.8531.6101/WD/20260000001", ContentTwinID: "ctid-nat-001",
 		FileHash: "fh-nat-001", MerkleRoot: "mr-nat-001",
 		Episodes: []model.EpisodeHash{
 			{Episode: 1, FileSHA256: "fh-nat-001-E1"},
@@ -74,7 +74,7 @@ func TestNationalCatalog_Stats(t *testing.T) {
 
 	srcClient := chain.NewMemoryChain()
 	_, err := srcClient.IssueMA(chain.RoleRegulator, chain.IssueRequest{
-		MACode: "MA.156.8531.6101/WD/20260000002", ContentTwinID: "ctid-nat-002",
+		CCCode: "MA.156.8531.6101/WD/20260000002", ContentTwinID: "ctid-nat-002",
 		FileHash: "fh-nat-002", MerkleRoot: "mr-nat-002",
 		Content: model.Content{Title: "统计测试剧", MAType: "WD", Issuer: "陕西局"},
 	})
@@ -98,7 +98,7 @@ func TestNationalCatalog_Stats(t *testing.T) {
 func TestNationalCatalog_ShareAuditRecord(t *testing.T) {
 	nc := New()
 	nc.ShareAuditRecord("MA.156.8531.6101/WD/20260000003", model.ProvenanceEvent{
-		MACode:   "MA.156.8531.6101/WD/20260000003",
+		CCCode:   "MA.156.8531.6101/WD/20260000003",
 		Node:     model.NodeIssue,
 		Operator: "陕西局",
 		Detail:   "跨省审核记录",
diff --git a/tcs-iptv/internal/playback/playback.go b/tcs-iptv/internal/playback/playback.go
index 647a22c..125bbbe 100644
--- a/tcs-iptv/internal/playback/playback.go
+++ b/tcs-iptv/internal/playback/playback.go
@@ -14,7 +14,7 @@ import (
 // Store 播放事件存储与聚合。
 type Store struct {
 	mu     sync.RWMutex
-	events map[string][]model.PlaybackEvent // maCode -> events
+	events map[string][]model.PlaybackEvent // ccCode -> events
 }
 
 // NewStore 创建播放数据存储。
@@ -29,21 +29,21 @@ func (s *Store) Ingest(events []model.PlaybackEvent) int {
 	defer s.mu.Unlock()
 	n := 0
 	for _, e := range events {
-		if e.MACode == "" {
+		if e.CCCode == "" {
 			continue
 		}
-		s.events[e.MACode] = append(s.events[e.MACode], e)
+		s.events[e.CCCode] = append(s.events[e.CCCode], e)
 		n++
 	}
 	return n
 }
 
 // Summary 按 MA 码聚合可信播放数据（需求9-AC2、需求21-AC1）。
-func (s *Store) Summary(maCode string) model.PlaybackSummary {
+func (s *Store) Summary(ccCode string) model.PlaybackSummary {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
-	sum := model.PlaybackSummary{MACode: maCode, ByPlatform: map[string]model.PlatformMetric{}}
-	for _, e := range s.events[maCode] {
+	sum := model.PlaybackSummary{CCCode: ccCode, ByPlatform: map[string]model.PlatformMetric{}}
+	for _, e := range s.events[ccCode] {
 		pm := sum.ByPlatform[e.PlatformID]
 		switch e.EventType {
 		case model.EventPlay:
@@ -62,12 +62,12 @@ func (s *Store) Summary(maCode string) model.PlaybackSummary {
 
 // ComputeSettlement 基于聚合的可信播放收益执行分账（需求21-AC3）。
 // 分账依据明确标注为"链上可信播放数据"，保证 CP 与运营商口径一致。
-func (s *Store) ComputeSettlement(maCode, period string, cfg model.RevenueShareConfig) (model.Settlement, error) {
+func (s *Store) ComputeSettlement(ccCode, period string, cfg model.RevenueShareConfig) (model.Settlement, error) {
 	if cfg.CPShareBp+cfg.PlatformShareBp+cfg.HubFeeBp != 10000 {
 		return model.Settlement{}, fmt.Errorf("playback: share config must sum to 10000bp, got %d",
 			cfg.CPShareBp+cfg.PlatformShareBp+cfg.HubFeeBp)
 	}
-	sum := s.Summary(maCode)
+	sum := s.Summary(ccCode)
 	total := sum.TotalRevenue
 
 	cp := total * int64(cfg.CPShareBp) / 10000
@@ -76,7 +76,7 @@ func (s *Store) ComputeSettlement(maCode, period string, cfg model.RevenueShareC
 	hub := total - cp - platform
 
 	return model.Settlement{
-		MACode: maCode, Period: period, TotalRevenue: total,
+		CCCode: ccCode, Period: period, TotalRevenue: total,
 		CPShare: cp, PlatformShare: platform, HubFee: hub,
 		DataSource: "链上可信播放数据",
 	}, nil
diff --git a/tcs-iptv/internal/playback/playback_test.go b/tcs-iptv/internal/playback/playback_test.go
index d0f4f36..1a671e3 100644
--- a/tcs-iptv/internal/playback/playback_test.go
+++ b/tcs-iptv/internal/playback/playback_test.go
@@ -9,7 +9,7 @@ import (
 )
 
 func ev(ma, plat string, t model.PlaybackEventType, rev int64) model.PlaybackEvent {
-	return model.PlaybackEvent{MACode: ma, PlatformID: plat, EventType: t, RevenueCent: rev}
+	return model.PlaybackEvent{CCCode: ma, PlatformID: plat, EventType: t, RevenueCent: rev}
 }
 
 func TestIngestAndSummary(t *testing.T) {
@@ -33,7 +33,7 @@ func TestIngestAndSummary(t *testing.T) {
 
 func TestIngestSkipsEmptyMA(t *testing.T) {
 	s := NewStore()
-	n := s.Ingest([]model.PlaybackEvent{{MACode: ""}, ev("MA-1", "P", model.EventPlay, 0)})
+	n := s.Ingest([]model.PlaybackEvent{{CCCode: ""}, ev("MA-1", "P", model.EventPlay, 0)})
 	assert.Equal(t, 1, n)
 }
 
diff --git a/tcs-iptv/internal/provenance/provenance.go b/tcs-iptv/internal/provenance/provenance.go
index c076f29..0565477 100644
--- a/tcs-iptv/internal/provenance/provenance.go
+++ b/tcs-iptv/internal/provenance/provenance.go
@@ -13,7 +13,7 @@ import (
 // Store 全链路存证存储。
 type Store struct {
 	mu     sync.RWMutex
-	trails map[string][]model.ProvenanceEvent // maCode -> 时间序事件
+	trails map[string][]model.ProvenanceEvent // ccCode -> 时间序事件
 }
 
 // NewStore 创建存证存储。
@@ -28,22 +28,22 @@ func (s *Store) Record(e model.ProvenanceEvent) {
 	}
 	s.mu.Lock()
 	defer s.mu.Unlock()
-	s.trails[e.MACode] = append(s.trails[e.MACode], e)
+	s.trails[e.CCCode] = append(s.trails[e.CCCode], e)
 }
 
 // Trail 返回某 MA 码的全链路存证（需求22-AC1）。
-func (s *Store) Trail(maCode string) []model.ProvenanceEvent {
+func (s *Store) Trail(ccCode string) []model.ProvenanceEvent {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
-	out := make([]model.ProvenanceEvent, len(s.trails[maCode]))
-	copy(out, s.trails[maCode])
+	out := make([]model.ProvenanceEvent, len(s.trails[ccCode]))
+	copy(out, s.trails[ccCode])
 	return out
 }
 
 // Accountability 责任界定：以发码基准哈希为准，定位首次发生哈希变化的节点（需求22-AC2）。
-func (s *Store) Accountability(maCode string) model.AccountabilityReport {
-	trail := s.Trail(maCode)
-	report := model.AccountabilityReport{MACode: maCode, Trail: trail, Consistent: true}
+func (s *Store) Accountability(ccCode string) model.AccountabilityReport {
+	trail := s.Trail(ccCode)
+	report := model.AccountabilityReport{CCCode: ccCode, Trail: trail, Consistent: true}
 
 	// 基准哈希 = 发码节点（NodeIssue）的哈希
 	for _, e := range trail {
diff --git a/tcs-iptv/internal/service/accountability_test.go b/tcs-iptv/internal/service/accountability_test.go
index 2ead4b3..828f0b0 100644
--- a/tcs-iptv/internal/service/accountability_test.go
+++ b/tcs-iptv/internal/service/accountability_test.go
@@ -12,13 +12,13 @@ import (
 // 全链路一致：发码→入库→正确注入，追责判定审播一致。
 func TestAccountability_Consistent(t *testing.T) {
 	s := newService(t)
-	maCode, ctid, cert := issueOne(t, s)
-	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, maCode, ctid, "M", "陕西IPTV媒资库"))
-	require.NoError(t, s.PublishToOperator(PublishRequest{MACode: maCode, Certificate: cert}))
-	_, err := s.InjectToCDN(chain.RoleOperator, ctid, maCode, "filehash-abc", "CT-SX", "cdn://x")
+	ccCode, ctid, cert := issueOne(t, s)
+	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, ccCode, ctid, "M", "陕西IPTV媒资库"))
+	require.NoError(t, s.PublishToOperator(PublishRequest{CCCode: ccCode, Certificate: cert}))
+	_, err := s.InjectToCDN(chain.RoleOperator, ctid, ccCode, "filehash-abc", "CT-SX", "cdn://x")
 	require.NoError(t, err)
 
-	rep := s.Accountability(maCode)
+	rep := s.Accountability(ccCode)
 	assert.True(t, rep.Consistent, "全链路应一致")
 	assert.Nil(t, rep.FirstChange)
 	assert.Equal(t, "filehash-abc", rep.BaselineHash)
@@ -28,19 +28,19 @@ func TestAccountability_Consistent(t *testing.T) {
 // 注入环节偷换：追责定位到 cdn_inject 节点与运营商。
 func TestAccountability_TamperLocated(t *testing.T) {
 	s := newService(t)
-	maCode, ctid, cert := issueOne(t, s)
-	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, maCode, ctid, "M", "媒资库"))
-	require.NoError(t, s.PublishToOperator(PublishRequest{MACode: maCode, Certificate: cert}))
+	ccCode, ctid, cert := issueOne(t, s)
+	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, ccCode, ctid, "M", "媒资库"))
+	require.NoError(t, s.PublishToOperator(PublishRequest{CCCode: ccCode, Certificate: cert}))
 
 	// 直接往存证里记录一次"被偷换"的注入（绕过校验模拟违规留痕）
 	// 实际中 InjectToCDN 会拒绝不匹配，但运营商侧若绕过校验偷换，存证仍会暴露
-	_, _ = s.InjectToCDN(chain.RoleOperator, ctid, maCode, "filehash-abc", "CT-SX", "cdn://x")
+	_, _ = s.InjectToCDN(chain.RoleOperator, ctid, ccCode, "filehash-abc", "CT-SX", "cdn://x")
 	s.prov.Record(model.ProvenanceEvent{
-		MACode: maCode, Node: model.NodeInject, HashValue: "TAMPERED",
+		CCCode: ccCode, Node: model.NodeInject, HashValue: "TAMPERED",
 		Operator: "CT-SX-违规", Detail: "疑似偷换",
 	})
 
-	rep := s.Accountability(maCode)
+	rep := s.Accountability(ccCode)
 	assert.False(t, rep.Consistent)
 	require.NotNil(t, rep.FirstChange)
 	assert.Equal(t, model.NodeInject, rep.FirstChange.Node)
@@ -50,22 +50,22 @@ func TestAccountability_TamperLocated(t *testing.T) {
 // 转码版哈希不同属合法，不应误判为篡改。
 func TestAccountability_TranscodeNotFlagged(t *testing.T) {
 	s := newService(t)
-	maCode, ctid, _ := issueOne(t, s)
+	ccCode, ctid, _ := issueOne(t, s)
 	_, err := s.BindTranscoded(chain.RoleReviewer, ctid, "filehash-abc", "h265-4k", "H.265", "4K", "v1-4k")
 	require.NoError(t, err)
-	s.prov.Record(model.ProvenanceEvent{MACode: maCode, Node: model.NodeTranscode, HashValue: "h265-4k", Operator: "转码中心"})
+	s.prov.Record(model.ProvenanceEvent{CCCode: ccCode, Node: model.NodeTranscode, HashValue: "h265-4k", Operator: "转码中心"})
 
-	rep := s.Accountability(maCode)
+	rep := s.Accountability(ccCode)
 	assert.True(t, rep.Consistent, "转码版哈希不同属合法，不应判为篡改")
 }
 
 func TestCopyrightEvidence(t *testing.T) {
 	s := newService(t)
-	maCode, _, _ := issueOne(t, s)
+	ccCode, _, _ := issueOne(t, s)
 
-	ev, err := s.CopyrightEvidence(maCode)
+	ev, err := s.CopyrightEvidence(ccCode)
 	require.NoError(t, err)
-	assert.Equal(t, maCode, ev.MACode)
+	assert.Equal(t, ccCode, ev.CCCode)
 	assert.NotEmpty(t, ev.Trail)
 	assert.False(t, ev.FirstSeenAt.IsZero(), "应有最早登记时间戳")
 	assert.Contains(t, ev.Statement, "谁先锁定谁有权")
@@ -86,7 +86,7 @@ func TestMatchInfringement(t *testing.T) {
 	matches, err := s.MatchInfringement("a1b2c3d4e5f60718", 5, 10)
 	require.NoError(t, err)
 	require.NotEmpty(t, matches)
-	assert.Equal(t, issued.MACode, matches[0].MACode)
+	assert.Equal(t, issued.CCCode, matches[0].CCCode)
 	assert.Equal(t, "high", matches[0].Similarity)
 	assert.Equal(t, 0, matches[0].Distance)
 
diff --git a/tcs-iptv/internal/service/distribution.go b/tcs-iptv/internal/service/distribution.go
index 50f4e60..6c20e9a 100644
--- a/tcs-iptv/internal/service/distribution.go
+++ b/tcs-iptv/internal/service/distribution.go
@@ -32,8 +32,8 @@ func (s *Service) BindTranscoded(role chain.Role, ctid, parentFileHash, transcod
 // ---- 工作包8：媒体资源库入库、发布与映射（需求6） ----
 
 // IngestToLibrary 审核合格内容入媒资库，建立媒资编码映射（需求6-AC1/AC2/AC3）。
-func (s *Service) IngestToLibrary(role chain.Role, maCode, ctid, mediaAssetID, libName string) error {
-	c, err := s.chain.QueryContent(maCode)
+func (s *Service) IngestToLibrary(role chain.Role, ccCode, ctid, mediaAssetID, libName string) error {
+	c, err := s.chain.QueryContent(ccCode)
 	if err != nil {
 		return err
 	}
@@ -49,19 +49,19 @@ func (s *Service) IngestToLibrary(role chain.Role, maCode, ctid, mediaAssetID, l
 	}); err != nil {
 		return err
 	}
-	s.prov.Record(model.ProvenanceEvent{MACode: maCode, Node: model.NodeIngest, Operator: libName, Detail: "审合格入媒资库"})
-	return s.chain.SetContentStatus(maCode, model.StatusInLibrary)
+	s.prov.Record(model.ProvenanceEvent{CCCode: ccCode, Node: model.NodeIngest, Operator: libName, Detail: "审合格入媒资库"})
+	return s.chain.SetContentStatus(ccCode, model.StatusInLibrary)
 }
 
 // PublishRequest 从媒资库向运营商发布的请求（需求6-AC4）。
 type PublishRequest struct {
-	MACode      string
-	Certificate string // 必须携带 MA码+哈希证书
+	CCCode      string
+	Certificate string // 必须携带 CC码+哈希证书
 }
 
 // PublishToOperator 校验证书后将内容置为已发布（需求6-AC4/AC5、需求3-AC8）。
 func (s *Service) PublishToOperator(req PublishRequest) error {
-	c, err := s.chain.QueryContent(req.MACode)
+	c, err := s.chain.QueryContent(req.CCCode)
 	if err != nil {
 		return err
 	}
@@ -69,10 +69,10 @@ func (s *Service) PublishToOperator(req PublishRequest) error {
 		return ErrNotApproved
 	}
 	// 发布必须携带证书（含 MA 码）
-	if req.Certificate == "" || !certContainsMA(req.Certificate, req.MACode) {
+	if req.Certificate == "" || !certContainsMA(req.Certificate, req.CCCode) {
 		return ErrNoCertificate
 	}
-	return s.chain.SetContentStatus(req.MACode, model.StatusPublished)
+	return s.chain.SetContentStatus(req.CCCode, model.StatusPublished)
 }
 
 // ---- 工作包9：CDN 注入校验（需求7） ----
@@ -85,9 +85,9 @@ type InjectResult struct {
 }
 
 // InjectToCDN 运营商注入 CDN 前校验哈希；匹配则放行并注册运营商映射（需求7-AC1~AC4）。
-func (s *Service) InjectToCDN(role chain.Role, ctid, maCode, injectFileHash, operatorID, cdnEndpoint string) (InjectResult, error) {
+func (s *Service) InjectToCDN(role chain.Role, ctid, ccCode, injectFileHash, operatorID, cdnEndpoint string) (InjectResult, error) {
 	// 内容须处于已发布状态
-	c, err := s.chain.QueryContent(maCode)
+	c, err := s.chain.QueryContent(ccCode)
 	if err != nil {
 		return InjectResult{}, err
 	}
@@ -95,7 +95,7 @@ func (s *Service) InjectToCDN(role chain.Role, ctid, maCode, injectFileHash, ope
 		return InjectResult{Allowed: false, Reason: "内容已下架"}, ErrNotApproved
 	}
 
-	res, err := s.chain.VerifyHash(maCode, injectFileHash)
+	res, err := s.chain.VerifyHash(ccCode, injectFileHash)
 	if err != nil {
 		return InjectResult{Allowed: false, Reason: err.Error()}, err
 	}
@@ -105,7 +105,7 @@ func (s *Service) InjectToCDN(role chain.Role, ctid, maCode, injectFileHash, ope
 	}
 
 	// 授权核验（需求25-AC2/AC3）：若已登记授权，校验该运营商是否在授权平台内
-	if authRes := s.CheckAuthorization(maCode, "", operatorID); !authRes.Allowed {
+	if authRes := s.CheckAuthorization(ccCode, "", operatorID); !authRes.Allowed {
 		return InjectResult{Allowed: false, Reason: authRes.Reason}, ErrNotApproved
 	}
 
@@ -118,7 +118,7 @@ func (s *Service) InjectToCDN(role chain.Role, ctid, maCode, injectFileHash, ope
 	}); err != nil {
 		return InjectResult{}, err
 	}
-	s.prov.Record(model.ProvenanceEvent{MACode: maCode, Node: model.NodeInject, HashValue: injectFileHash, Operator: operatorID, Detail: "CDN 注入校验通过"})
+	s.prov.Record(model.ProvenanceEvent{CCCode: ccCode, Node: model.NodeInject, HashValue: injectFileHash, Operator: operatorID, Detail: "CDN 注入校验通过"})
 	return InjectResult{Allowed: true, DistributionID: distID}, nil
 }
 
@@ -159,28 +159,28 @@ func (s *Service) ReportVersionChange(ctid, reason, prevHash, newHash string, ol
 // ---- 工作包14：违规应急下架（需求11） ----
 
 // Takedown 监管主体一键下架：解析 MA 码绑定的三方编码与 CDN 端点（需求11-AC1/AC2/AC4）。
-func (s *Service) Takedown(role chain.Role, maCode, reason string) (chain.MappingsResult, error) {
-	return s.chain.Revoke(role, maCode, reason)
+func (s *Service) Takedown(role chain.Role, ccCode, reason string) (chain.MappingsResult, error) {
+	return s.chain.Revoke(role, ccCode, reason)
 }
 
 // TakedownEpisode 集级下架：只下架指定集，整剧其他集继续流通（仅监管主体）。
-func (s *Service) TakedownEpisode(role chain.Role, maCode string, episode int, reason string) error {
-	return s.chain.RevokeEpisode(role, maCode, episode, reason)
+func (s *Service) TakedownEpisode(role chain.Role, ccCode string, episode int, reason string) error {
+	return s.chain.RevokeEpisode(role, ccCode, episode, reason)
 }
 
 // Restore 恢复上架整剧（仅监管主体）。
-func (s *Service) Restore(role chain.Role, maCode string) error {
-	return s.chain.Restore(role, maCode)
+func (s *Service) Restore(role chain.Role, ccCode string) error {
+	return s.chain.Restore(role, ccCode)
 }
 
 // RestoreEpisode 恢复上架指定集（仅监管主体）。
-func (s *Service) RestoreEpisode(role chain.Role, maCode string, episode int) error {
-	return s.chain.RestoreEpisode(role, maCode, episode)
+func (s *Service) RestoreEpisode(role chain.Role, ccCode string, episode int) error {
+	return s.chain.RestoreEpisode(role, ccCode, episode)
 }
 
 // certContainsMA 校验证书是否包含指定 MA 码。
-func certContainsMA(cert, maCode string) bool {
-	return cert != "" && maCode != "" && strings.Contains(cert, maCode)
+func certContainsMA(cert, ccCode string) bool {
+	return cert != "" && ccCode != "" && strings.Contains(cert, ccCode)
 }
 
 // ---- 二期 F09/F18：数据回传聚合与分账（需求9/需求21） ----
@@ -190,7 +190,7 @@ func certContainsMA(cert, maCode string) bool {
 func (s *Service) ReportPlayback(events []model.PlaybackEvent) (accepted int, rejected int) {
 	valid := make([]model.PlaybackEvent, 0, len(events))
 	for _, e := range events {
-		c, err := s.chain.QueryContent(e.MACode)
+		c, err := s.chain.QueryContent(e.CCCode)
 		if err != nil || c.Status == model.StatusRevoked {
 			rejected++
 			continue
@@ -202,40 +202,40 @@ func (s *Service) ReportPlayback(events []model.PlaybackEvent) (accepted int, re
 }
 
 // PlaybackSummary 查询按 MA 码聚合的可信播放数据（需求9-AC2/AC3）。
-func (s *Service) PlaybackSummary(maCode string) model.PlaybackSummary {
-	return s.pb.Summary(maCode)
+func (s *Service) PlaybackSummary(ccCode string) model.PlaybackSummary {
+	return s.pb.Summary(ccCode)
 }
 
 // ComputeSettlement 基于可信播放数据计算分账（需求21-AC3）。
-func (s *Service) ComputeSettlement(maCode, period string) (model.Settlement, error) {
-	if _, err := s.chain.QueryContent(maCode); err != nil {
+func (s *Service) ComputeSettlement(ccCode, period string) (model.Settlement, error) {
+	if _, err := s.chain.QueryContent(ccCode); err != nil {
 		return model.Settlement{}, err
 	}
-	return s.pb.ComputeSettlement(maCode, period, model.DefaultShareConfig())
+	return s.pb.ComputeSettlement(ccCode, period, model.DefaultShareConfig())
 }
 
 // ---- 二期 F19/F20：追责取证与确权举证（需求22/23） ----
 
 // Provenance 返回某 MA 码的全链路存证（需求22-AC1）。
-func (s *Service) Provenance(maCode string) []model.ProvenanceEvent {
-	return s.prov.Trail(maCode)
+func (s *Service) Provenance(ccCode string) []model.ProvenanceEvent {
+	return s.prov.Trail(ccCode)
 }
 
 // Accountability 责任界定取证：定位首次哈希变化节点与责任方（需求22-AC2）。
-func (s *Service) Accountability(maCode string) model.AccountabilityReport {
-	return s.prov.Accountability(maCode)
+func (s *Service) Accountability(ccCode string) model.AccountabilityReport {
+	return s.prov.Accountability(ccCode)
 }
 
 // CopyrightEvidence 导出版权确权证据链（需求23-AC1/AC2）。
-func (s *Service) CopyrightEvidence(maCode string) (model.CopyrightEvidence, error) {
-	c, err := s.chain.QueryContent(maCode)
+func (s *Service) CopyrightEvidence(ccCode string) (model.CopyrightEvidence, error) {
+	c, err := s.chain.QueryContent(ccCode)
 	if err != nil {
 		return model.CopyrightEvidence{}, err
 	}
-	trail := s.prov.Trail(maCode)
+	trail := s.prov.Trail(ccCode)
 	ev := model.CopyrightEvidence{
-		MACode: maCode, Title: c.Title, Issuer: c.Issuer, IssueDate: c.IssueDate,
-		ContentHash: c.FileHash, ChainAnchor: "chain://" + maCode, Trail: trail,
+		CCCode: ccCode, Title: c.Title, Issuer: c.Issuer, IssueDate: c.IssueDate,
+		ContentHash: c.FileHash, ChainAnchor: "chain://" + ccCode, Trail: trail,
 		Statement: "本证据链由 MA 码、内容哈希与上链时间戳构成，遵循『谁先锁定谁有权』，不可抵赖，可用于侵权投诉与司法举证。",
 	}
 	for _, e := range trail {
@@ -271,7 +271,7 @@ func (s *Service) MatchInfringement(perceptual string, high, medium int) ([]mode
 			if d <= high {
 				sim = "high"
 			}
-			out = append(out, model.InfringeMatch{MACode: ma, Title: e.Title, Distance: d, Similarity: sim})
+			out = append(out, model.InfringeMatch{CCCode: ma, Title: e.Title, Distance: d, Similarity: sim})
 		}
 	}
 	return out, nil
@@ -280,13 +280,13 @@ func (s *Service) MatchInfringement(perceptual string, high, medium int) ([]mode
 // ---- 二期 F22：授权链与发布前核验（需求25） ----
 
 // RecordAuthorization 登记信息网络传播权授权（需求25-AC1）。
-func (s *Service) RecordAuthorization(maCode string, regions, platforms []string, expiry time.Time) error {
-	if _, err := s.chain.QueryContent(maCode); err != nil {
+func (s *Service) RecordAuthorization(ccCode string, regions, platforms []string, expiry time.Time) error {
+	if _, err := s.chain.QueryContent(ccCode); err != nil {
 		return err
 	}
 	s.mu.Lock()
-	s.auths[maCode] = model.Authorization{
-		MACode: maCode, Regions: regions, Platforms: platforms,
+	s.auths[ccCode] = model.Authorization{
+		CCCode: ccCode, Regions: regions, Platforms: platforms,
 		ExpiryAt: expiry, GrantedAt: time.Now(),
 	}
 	s.mu.Unlock()
@@ -295,9 +295,9 @@ func (s *Service) RecordAuthorization(maCode string, regions, platforms []string
 
 // CheckAuthorization 核验某地域/平台是否在授权范围内（需求25-AC2/AC3）。
 // 未登记授权时默认放行（向后兼容）；登记后超地域/过期/非授权平台拦截。
-func (s *Service) CheckAuthorization(maCode, region, platform string) model.AuthCheckResult {
+func (s *Service) CheckAuthorization(ccCode, region, platform string) model.AuthCheckResult {
 	s.mu.Lock()
-	a, ok := s.auths[maCode]
+	a, ok := s.auths[ccCode]
 	s.mu.Unlock()
 	if !ok {
 		return model.AuthCheckResult{Allowed: true, Reason: "未登记授权限制"}
@@ -317,8 +317,8 @@ func (s *Service) CheckAuthorization(maCode, region, platform string) model.Auth
 // ---- 二期 F21：追更与增量哈希更新（需求24） ----
 
 // AddEpisodes 追更：为已发码剧追加新集哈希，不触发存量重审、不重新发码（需求24-AC4）。
-func (s *Service) AddEpisodes(role chain.Role, maCode string, episodes []model.EpisodeHash) error {
-	c, err := s.chain.QueryContent(maCode)
+func (s *Service) AddEpisodes(role chain.Role, ccCode string, episodes []model.EpisodeHash) error {
+	c, err := s.chain.QueryContent(ccCode)
 	if err != nil {
 		return err
 	}
@@ -336,7 +336,7 @@ func (s *Service) AddEpisodes(role chain.Role, maCode string, episodes []model.E
 		}
 	}
 	s.prov.Record(model.ProvenanceEvent{
-		MACode: maCode, Node: model.NodeSubmit,
+		CCCode: ccCode, Node: model.NodeSubmit,
 		Operator: "追更", Detail: "追加新集，增量赋码",
 	})
 	return nil
@@ -345,26 +345,26 @@ func (s *Service) AddEpisodes(role chain.Role, maCode string, episodes []model.E
 // ---- 二期 F13：跨省复用快速准入（需求13） ----
 
 // Blacklist 将 MA 码加入黑名单（用于跨省校验）。
-func (s *Service) Blacklist(maCode string) {
+func (s *Service) Blacklist(ccCode string) {
 	s.mu.Lock()
-	s.black[maCode] = true
+	s.black[ccCode] = true
 	s.mu.Unlock()
 }
 
 // CrossProvinceAdmit B 省凭 MA 码+哈希证书快速准入（需求13）。
 // 三重校验：MA 码有效 + 哈希与原过审版一致 + 非黑名单。
-func (s *Service) CrossProvinceAdmit(maCode, fileHash, province string) model.CrossProvinceResult {
+func (s *Service) CrossProvinceAdmit(ccCode, fileHash, province string) model.CrossProvinceResult {
 	res := model.CrossProvinceResult{}
 
 	// 1. MA 码有效
-	if _, err := s.chain.QueryContent(maCode); err != nil {
+	if _, err := s.chain.QueryContent(ccCode); err != nil {
 		res.Reason = "MA 码无效或不存在"
 		return res
 	}
-	res.MACodeValid = true
+	res.CCCodeValid = true
 
 	// 2. 哈希与原过审版一致
-	vr, err := s.chain.VerifyHash(maCode, fileHash)
+	vr, err := s.chain.VerifyHash(ccCode, fileHash)
 	if err != nil || !vr.Match {
 		res.Reason = "哈希与原过审版不一致"
 		return res
@@ -373,7 +373,7 @@ func (s *Service) CrossProvinceAdmit(maCode, fileHash, province string) model.Cr
 
 	// 3. 非黑名单
 	s.mu.Lock()
-	bl := s.black[maCode]
+	bl := s.black[ccCode]
 	s.mu.Unlock()
 	if bl {
 		res.Reason = "内容在黑名单中"
@@ -391,8 +391,8 @@ func (s *Service) CrossProvinceAdmit(maCode, fileHash, province string) model.Cr
 // ---- 二期 F08：终端片段抽检（需求8） ----
 
 // TerminalVerifySegment 终端按集抽检：校验某集哈希，不匹配则提示断流（需求8-AC1/AC2）。
-func (s *Service) TerminalVerifySegment(maCode string, episode int, segHash string) (bool, string) {
-	res, err := s.chain.VerifyEpisodeHash(maCode, episode, segHash)
+func (s *Service) TerminalVerifySegment(ccCode string, episode int, segHash string) (bool, string) {
+	res, err := s.chain.VerifyEpisodeHash(ccCode, episode, segHash)
 	if err != nil {
 		return false, "无法校验：" + err.Error()
 	}
diff --git a/tcs-iptv/internal/service/distribution_test.go b/tcs-iptv/internal/service/distribution_test.go
index b22de86..ad166fc 100644
--- a/tcs-iptv/internal/service/distribution_test.go
+++ b/tcs-iptv/internal/service/distribution_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/tcs-iptv/tcs/internal/hash"
 )
 
-// issueOne 完成一次"送审→CSPS审核→发码签发"，返回 maCode、ctid、证书。
+// issueOne 完成一次"送审→CSPS审核→发码签发"，返回 ccCode、ctid、证书。
 func issueOne(t *testing.T, s *Service) (string, string, string) {
 	t.Helper()
 	sub, err := s.SubmitForReview(sampleSub())
@@ -17,19 +17,19 @@ func issueOne(t *testing.T, s *Service) (string, string, string) {
 	require.NoError(t, s.ReviewCSPS(sub.ReviewID, true, "reviewer-1")) // 审核在前
 	issued, err := s.ApproveAndIssue(chain.RoleRegulator, sub.ReviewID, "北京市广播电视局")
 	require.NoError(t, err)
-	return issued.MACode, issued.ContentTwinID, issued.Certificate
+	return issued.CCCode, issued.ContentTwinID, issued.Certificate
 }
 
 func TestCSPSAndTranscode(t *testing.T) {
 	s := newService(t)
-	maCode, ctid, _ := issueOne(t, s)
+	ccCode, ctid, _ := issueOne(t, s)
 
 	_, err := s.BindTranscoded(chain.RoleReviewer, ctid, "filehash-abc",
 		"transcoded-h265-4k", "H.265", "3840x2160", "v1.0-4k")
 	require.NoError(t, err)
 
 	// 转码版也能验真通过
-	res, err := s.Verify(maCode, "transcoded-h265-4k")
+	res, err := s.Verify(ccCode, "transcoded-h265-4k")
 	require.NoError(t, err)
 	assert.True(t, res.Match)
 }
@@ -55,33 +55,33 @@ func TestIssueRequiresCSPSApproval(t *testing.T) {
 
 func TestIngestAndPublish(t *testing.T) {
 	s := newService(t)
-	maCode, ctid, cert := issueOne(t, s)
+	ccCode, ctid, cert := issueOne(t, s)
 
-	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, maCode, ctid, "MEDIA-001", "广东IPTV媒资库"))
+	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, ccCode, ctid, "MEDIA-001", "广东IPTV媒资库"))
 
 	// 无证书发布被拒
-	err := s.PublishToOperator(PublishRequest{MACode: maCode, Certificate: ""})
+	err := s.PublishToOperator(PublishRequest{CCCode: ccCode, Certificate: ""})
 	assert.ErrorIs(t, err, ErrNoCertificate)
 
 	// 携带证书发布成功
-	require.NoError(t, s.PublishToOperator(PublishRequest{MACode: maCode, Certificate: cert}))
+	require.NoError(t, s.PublishToOperator(PublishRequest{CCCode: ccCode, Certificate: cert}))
 }
 
 func TestInjectToCDN_MatchAndMismatch(t *testing.T) {
 	s := newService(t)
-	maCode, ctid, cert := issueOne(t, s)
-	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, maCode, ctid, "MEDIA-001", "媒资库"))
-	require.NoError(t, s.PublishToOperator(PublishRequest{MACode: maCode, Certificate: cert}))
+	ccCode, ctid, cert := issueOne(t, s)
+	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, ccCode, ctid, "MEDIA-001", "媒资库"))
+	require.NoError(t, s.PublishToOperator(PublishRequest{CCCode: ccCode, Certificate: cert}))
 
 	// 哈希匹配 → 允许注入
-	res, err := s.InjectToCDN(chain.RoleOperator, ctid, maCode, "filehash-abc",
+	res, err := s.InjectToCDN(chain.RoleOperator, ctid, ccCode, "filehash-abc",
 		"CT-IPTV-GD", "cdn://ct-gd/iptv/vod/008923")
 	require.NoError(t, err)
 	assert.True(t, res.Allowed)
 	assert.NotEmpty(t, res.DistributionID)
 
 	// 哈希不匹配 → 拒绝注入
-	res, err = s.InjectToCDN(chain.RoleOperator, ctid, maCode, "tampered-hash",
+	res, err = s.InjectToCDN(chain.RoleOperator, ctid, ccCode, "tampered-hash",
 		"CT-IPTV-GD", "cdn://x")
 	assert.ErrorIs(t, err, ErrHashMismatch)
 	assert.False(t, res.Allowed)
@@ -89,30 +89,30 @@ func TestInjectToCDN_MatchAndMismatch(t *testing.T) {
 
 func TestInjectToCDN_RevokedBlocked(t *testing.T) {
 	s := newService(t)
-	maCode, ctid, cert := issueOne(t, s)
-	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, maCode, ctid, "MEDIA-001", "媒资库"))
-	require.NoError(t, s.PublishToOperator(PublishRequest{MACode: maCode, Certificate: cert}))
+	ccCode, ctid, cert := issueOne(t, s)
+	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, ccCode, ctid, "MEDIA-001", "媒资库"))
+	require.NoError(t, s.PublishToOperator(PublishRequest{CCCode: ccCode, Certificate: cert}))
 
 	// 下架后不得注入
-	_, err := s.Takedown(chain.RoleRegulator, maCode, "违规")
+	_, err := s.Takedown(chain.RoleRegulator, ccCode, "违规")
 	require.NoError(t, err)
-	_, err = s.InjectToCDN(chain.RoleOperator, ctid, maCode, "filehash-abc", "OP", "cdn://x")
+	_, err = s.InjectToCDN(chain.RoleOperator, ctid, ccCode, "filehash-abc", "OP", "cdn://x")
 	assert.ErrorIs(t, err, ErrNotApproved)
 }
 
 func TestTakedown_ResolvesMappings(t *testing.T) {
 	s := newService(t)
-	maCode, ctid, cert := issueOne(t, s)
-	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, maCode, ctid, "MEDIA-001", "媒资库"))
-	require.NoError(t, s.PublishToOperator(PublishRequest{MACode: maCode, Certificate: cert}))
-	_, _ = s.InjectToCDN(chain.RoleOperator, ctid, maCode, "filehash-abc", "CT-IPTV-GD", "cdn://ct-gd/vod/1")
+	ccCode, ctid, cert := issueOne(t, s)
+	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, ccCode, ctid, "MEDIA-001", "媒资库"))
+	require.NoError(t, s.PublishToOperator(PublishRequest{CCCode: ccCode, Certificate: cert}))
+	_, _ = s.InjectToCDN(chain.RoleOperator, ctid, ccCode, "filehash-abc", "CT-IPTV-GD", "cdn://ct-gd/vod/1")
 
 	// 非监管主体不得下架
-	_, err := s.Takedown(chain.RoleOperator, maCode, "越权")
+	_, err := s.Takedown(chain.RoleOperator, ccCode, "越权")
 	assert.ErrorIs(t, err, chain.ErrPermissionDenied)
 
 	// 监管下架，解析出 CDN 端点
-	res, err := s.Takedown(chain.RoleRegulator, maCode, "违规")
+	res, err := s.Takedown(chain.RoleRegulator, ccCode, "违规")
 	require.NoError(t, err)
 	assert.Contains(t, res.CDNEndpoints, "cdn://ct-gd/vod/1")
 }
diff --git a/tcs-iptv/internal/service/episode_test.go b/tcs-iptv/internal/service/episode_test.go
index 9e0a645..d075102 100644
--- a/tcs-iptv/internal/service/episode_test.go
+++ b/tcs-iptv/internal/service/episode_test.go
@@ -6,7 +6,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/tcs-iptv/tcs/internal/chain"
-	"github.com/tcs-iptv/tcs/internal/macode"
+	"github.com/tcs-iptv/tcs/internal/cccode"
 	"github.com/tcs-iptv/tcs/internal/model"
 )
 
@@ -24,7 +24,7 @@ func TestEpisodeLevel_OneSeriesOneCodeMultiEpisodeHash(t *testing.T) {
 		})
 	}
 	sub := Submission{
-		Title: "长安少年行", EpisodeCount: 24, Category: macode.CategoryMicroDrama,
+		Title: "长安少年行", EpisodeCount: 24, Category: cccode.CategoryMicroDrama,
 		FileHash: "series-root-hash", MerkleRoot: "series-merkle-root",
 		Episodes:  eps,
 		CPMediaID: "XAQJSL-2026-001", CPName: "西安曲江丝路文化传播有限公司",
@@ -36,20 +36,20 @@ func TestEpisodeLevel_OneSeriesOneCodeMultiEpisodeHash(t *testing.T) {
 	require.NoError(t, err)
 
 	// 一剧一码
-	assert.True(t, macode.IsValid(issued.MACode))
+	assert.True(t, cccode.IsValid(issued.CCCode))
 
 	// 24 集哈希全部绑定在同一 MA 码下
-	list, err := s.ListEpisodes(issued.MACode)
+	list, err := s.ListEpisodes(issued.CCCode)
 	require.NoError(t, err)
 	assert.Len(t, list, 24)
 
 	// 按集验真：第 7 集正确哈希匹配
-	res, err := s.VerifyEpisode(issued.MACode, 7, "ep-hash-"+string(rune('a'+7)))
+	res, err := s.VerifyEpisode(issued.CCCode, 7, "ep-hash-"+string(rune('a'+7)))
 	require.NoError(t, err)
 	assert.True(t, res.Match)
 
 	// 第 7 集错误哈希 → 不匹配（疑似该集被替换）
-	_, err = s.VerifyEpisode(issued.MACode, 7, "tampered-ep7")
+	_, err = s.VerifyEpisode(issued.CCCode, 7, "tampered-ep7")
 	assert.ErrorIs(t, err, ErrHashMismatch)
 }
 
@@ -62,7 +62,7 @@ func TestEpisodeTakedown(t *testing.T) {
 		{Episode: 3, FileSHA256: "h3"}, {Episode: 4, FileSHA256: "h4"},
 	}
 	sub := Submission{
-		Title: "多集剧", EpisodeCount: 4, Category: macode.CategoryMicroDrama,
+		Title: "多集剧", EpisodeCount: 4, Category: cccode.CategoryMicroDrama,
 		FileHash: "series-h", MerkleRoot: "series-mr", Episodes: eps,
 	}
 	r, err := s.SubmitForReview(sub)
@@ -72,13 +72,13 @@ func TestEpisodeTakedown(t *testing.T) {
 	require.NoError(t, err)
 
 	// 运营商无权集级下架
-	err = s.TakedownEpisode(chain.RoleOperator, issued.MACode, 3, "第3集违规")
+	err = s.TakedownEpisode(chain.RoleOperator, issued.CCCode, 3, "第3集违规")
 	assert.ErrorIs(t, err, chain.ErrPermissionDenied)
 
 	// 监管下架第3集
-	require.NoError(t, s.TakedownEpisode(chain.RoleRegulator, issued.MACode, 3, "第3集违规"))
+	require.NoError(t, s.TakedownEpisode(chain.RoleRegulator, issued.CCCode, 3, "第3集违规"))
 
-	list, err := s.ListEpisodes(issued.MACode)
+	list, err := s.ListEpisodes(issued.CCCode)
 	require.NoError(t, err)
 	for _, b := range list {
 		if b.Episode == 3 {
@@ -89,18 +89,18 @@ func TestEpisodeTakedown(t *testing.T) {
 	}
 }
 
-// 集级子标识：MA码#E07 解析与生成。
+// 集级子标识：CC码#E07 解析与生成。
 func TestEpisodeSubID(t *testing.T) {
 	ma := "MA.156.8531.6101/WD/20260000001"
-	sub := macode.EpisodeSubID(ma, 7)
+	sub := cccode.EpisodeSubID(ma, 7)
 	assert.Equal(t, "MA.156.8531.6101/WD/20260000001#E07", sub)
 
-	parsedMA, ep := macode.ParseEpisodeSubID(sub)
+	parsedMA, ep := cccode.ParseEpisodeSubID(sub)
 	assert.Equal(t, ma, parsedMA)
 	assert.Equal(t, 7, ep)
 
 	// 无后缀 → 整剧（episode 0）
-	parsedMA2, ep2 := macode.ParseEpisodeSubID(ma)
+	parsedMA2, ep2 := cccode.ParseEpisodeSubID(ma)
 	assert.Equal(t, ma, parsedMA2)
 	assert.Equal(t, 0, ep2)
 }
@@ -116,12 +116,12 @@ func TestSingleContent_NoEpisodes(t *testing.T) {
 	issued, err := s.ApproveAndIssue(chain.RoleRegulator, r.ReviewID, "陕西IPTV运营公司")
 	require.NoError(t, err)
 
-	list, err := s.ListEpisodes(issued.MACode)
+	list, err := s.ListEpisodes(issued.CCCode)
 	require.NoError(t, err)
 	assert.Empty(t, list, "单体内容无集级绑定")
 
 	// 整剧验真仍可用
-	res, err := s.Verify(issued.MACode, sub.FileHash)
+	res, err := s.Verify(issued.CCCode, sub.FileHash)
 	require.NoError(t, err)
 	assert.True(t, res.Match)
 }
diff --git a/tcs-iptv/internal/service/phase2_test.go b/tcs-iptv/internal/service/phase2_test.go
index 466f3d6..2f1a0d8 100644
--- a/tcs-iptv/internal/service/phase2_test.go
+++ b/tcs-iptv/internal/service/phase2_test.go
@@ -14,38 +14,38 @@ import (
 
 func TestAuthorization_PlatformGate(t *testing.T) {
 	s := newService(t)
-	maCode, ctid, cert := issueOne(t, s)
-	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, maCode, ctid, "M", "媒资库"))
-	require.NoError(t, s.PublishToOperator(PublishRequest{MACode: maCode, Certificate: cert}))
+	ccCode, ctid, cert := issueOne(t, s)
+	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, ccCode, ctid, "M", "媒资库"))
+	require.NoError(t, s.PublishToOperator(PublishRequest{CCCode: ccCode, Certificate: cert}))
 
 	// 仅授权 CT-SX
-	require.NoError(t, s.RecordAuthorization(maCode, nil, []string{"CT-SX"}, time.Time{}))
+	require.NoError(t, s.RecordAuthorization(ccCode, nil, []string{"CT-SX"}, time.Time{}))
 
 	// 授权平台注入通过
-	_, err := s.InjectToCDN(chain.RoleOperator, ctid, maCode, "filehash-abc", "CT-SX", "cdn://ct")
+	_, err := s.InjectToCDN(chain.RoleOperator, ctid, ccCode, "filehash-abc", "CT-SX", "cdn://ct")
 	require.NoError(t, err)
 
 	// 非授权平台注入被拒
-	_, err = s.InjectToCDN(chain.RoleOperator, ctid, maCode, "filehash-abc", "CM-SX", "cdn://cm")
+	_, err = s.InjectToCDN(chain.RoleOperator, ctid, ccCode, "filehash-abc", "CM-SX", "cdn://cm")
 	assert.ErrorIs(t, err, ErrNotApproved)
 }
 
 func TestAuthorization_Expiry(t *testing.T) {
 	s := newService(t)
-	maCode, _, _ := issueOne(t, s)
+	ccCode, _, _ := issueOne(t, s)
 	// 已过期授权
-	require.NoError(t, s.RecordAuthorization(maCode, nil, nil, time.Now().Add(-time.Hour)))
-	res := s.CheckAuthorization(maCode, "", "")
+	require.NoError(t, s.RecordAuthorization(ccCode, nil, nil, time.Now().Add(-time.Hour)))
+	res := s.CheckAuthorization(ccCode, "", "")
 	assert.False(t, res.Allowed)
 	assert.Contains(t, res.Reason, "过期")
 }
 
 func TestAuthorization_RegionGate(t *testing.T) {
 	s := newService(t)
-	maCode, _, _ := issueOne(t, s)
-	require.NoError(t, s.RecordAuthorization(maCode, []string{"610000"}, nil, time.Time{}))
-	assert.True(t, s.CheckAuthorization(maCode, "610000", "").Allowed)  // 陕西
-	assert.False(t, s.CheckAuthorization(maCode, "440000", "").Allowed) // 广东，超域
+	ccCode, _, _ := issueOne(t, s)
+	require.NoError(t, s.RecordAuthorization(ccCode, []string{"610000"}, nil, time.Time{}))
+	assert.True(t, s.CheckAuthorization(ccCode, "610000", "").Allowed)  // 陕西
+	assert.False(t, s.CheckAuthorization(ccCode, "440000", "").Allowed) // 广东，超域
 }
 
 // ---- F21 追更 ----
@@ -61,16 +61,16 @@ func TestAddEpisodes_NoReissue(t *testing.T) {
 	require.NoError(t, err)
 
 	// 追更第 3、4 集（不重新发码）
-	require.NoError(t, s.AddEpisodes(chain.RoleReviewer, issued.MACode, []model.EpisodeHash{
+	require.NoError(t, s.AddEpisodes(chain.RoleReviewer, issued.CCCode, []model.EpisodeHash{
 		{Episode: 3, FileSHA256: "e3"}, {Episode: 4, FileSHA256: "e4"},
 	}))
 
-	list, err := s.ListEpisodes(issued.MACode)
+	list, err := s.ListEpisodes(issued.CCCode)
 	require.NoError(t, err)
 	assert.Len(t, list, 4, "应有 4 集")
 
 	// 新集可独立验真
-	res, err := s.VerifyEpisode(issued.MACode, 3, "e3")
+	res, err := s.VerifyEpisode(issued.CCCode, 3, "e3")
 	require.NoError(t, err)
 	assert.True(t, res.Match)
 }
@@ -79,28 +79,28 @@ func TestAddEpisodes_NoReissue(t *testing.T) {
 
 func TestCrossProvince_Admit(t *testing.T) {
 	s := newService(t)
-	maCode, _, _ := issueOne(t, s) // sampleSub FileHash=filehash-abc
+	ccCode, _, _ := issueOne(t, s) // sampleSub FileHash=filehash-abc
 
-	res := s.CrossProvinceAdmit(maCode, "filehash-abc", "610000")
+	res := s.CrossProvinceAdmit(ccCode, "filehash-abc", "610000")
 	assert.True(t, res.Admitted)
-	assert.True(t, res.MACodeValid && res.HashConsistent && res.NotBlacklisted)
+	assert.True(t, res.CCCodeValid && res.HashConsistent && res.NotBlacklisted)
 	assert.NotEmpty(t, res.ProvinceFlowNo)
 }
 
 func TestCrossProvince_HashMismatch(t *testing.T) {
 	s := newService(t)
-	maCode, _, _ := issueOne(t, s)
-	res := s.CrossProvinceAdmit(maCode, "tampered", "610000")
+	ccCode, _, _ := issueOne(t, s)
+	res := s.CrossProvinceAdmit(ccCode, "tampered", "610000")
 	assert.False(t, res.Admitted)
-	assert.True(t, res.MACodeValid)
+	assert.True(t, res.CCCodeValid)
 	assert.False(t, res.HashConsistent)
 }
 
 func TestCrossProvince_Blacklisted(t *testing.T) {
 	s := newService(t)
-	maCode, _, _ := issueOne(t, s)
-	s.Blacklist(maCode)
-	res := s.CrossProvinceAdmit(maCode, "filehash-abc", "610000")
+	ccCode, _, _ := issueOne(t, s)
+	s.Blacklist(ccCode)
+	res := s.CrossProvinceAdmit(ccCode, "filehash-abc", "610000")
 	assert.False(t, res.Admitted)
 	assert.False(t, res.NotBlacklisted)
 	assert.Contains(t, res.Reason, "黑名单")
@@ -110,7 +110,7 @@ func TestCrossProvince_UnknownMA(t *testing.T) {
 	s := newService(t)
 	res := s.CrossProvinceAdmit("MA.156.8531.6101/WD/不存在", "h", "610000")
 	assert.False(t, res.Admitted)
-	assert.False(t, res.MACodeValid)
+	assert.False(t, res.CCCodeValid)
 }
 
 // ---- F08 终端抽检 ----
@@ -124,10 +124,10 @@ func TestTerminalVerifySegment(t *testing.T) {
 	issued, err := s.ApproveAndIssue(chain.RoleRegulator, r.ReviewID, "陕西IPTV")
 	require.NoError(t, err)
 
-	ok, _ := s.TerminalVerifySegment(issued.MACode, 1, "seg1")
+	ok, _ := s.TerminalVerifySegment(issued.CCCode, 1, "seg1")
 	assert.True(t, ok)
 
-	ok, msg := s.TerminalVerifySegment(issued.MACode, 1, "tampered")
+	ok, msg := s.TerminalVerifySegment(issued.CCCode, 1, "tampered")
 	assert.False(t, ok)
 	assert.Contains(t, msg, "断流")
 }
diff --git a/tcs-iptv/internal/service/phase4.go b/tcs-iptv/internal/service/phase4.go
index 017c228..0a908b1 100644
--- a/tcs-iptv/internal/service/phase4.go
+++ b/tcs-iptv/internal/service/phase4.go
@@ -14,16 +14,16 @@ import (
 // 将 MA+哈希机制从 IPTV 扩展至 OTT、手机 APP，实现大小屏内容身份互通。
 // 对应任务：C.1 跨域解析网关、C.2 身份互通、B.2 扫码验真、D.1 跨屏权益子链。
 
-// maCodePattern 匹配六段式 MA 码（含可选集级子标识 #Exx）。
+// ccCodePattern 匹配六段式 MA 码（含可选集级子标识 #Exx）。
 // 形如 MA.156.8531.6101/WD/20260000004 或 MA.156.8531.6101/WD/20260000004#E07
-var maCodePattern = regexp.MustCompile(
+var ccCodePattern = regexp.MustCompile(
 	`^(MA)\.(\d{3})\.([0-9A-Za-z]+)\.([0-9A-Za-z]+)/([0-9A-Za-z]+)/(\d{4})(\d+)(?:#E(\d+))?$`)
 
-// ParseMACode 解析六段式 MA 码（纯结构解析，不查链）。
+// ParseCCCode 解析六段式 MA 码（纯结构解析，不查链）。
 // 返回 Valid=false 表示结构不合法（可能是伪造/损坏的码）。
-func ParseMACode(maCode string) model.ParsedMA {
-	p := model.ParsedMA{Raw: maCode}
-	m := maCodePattern.FindStringSubmatch(strings.TrimSpace(maCode))
+func ParseCCCode(ccCode string) model.ParsedMA {
+	p := model.ParsedMA{Raw: ccCode}
+	m := ccCodePattern.FindStringSubmatch(strings.TrimSpace(ccCode))
 	if m == nil {
 		p.Valid = false
 		return p
@@ -44,19 +44,19 @@ func ParseMACode(maCode string) model.ParsedMA {
 	return p
 }
 
-// baseMACode 去除集级子标识 #Exx，返回整剧 MA 码（用于查链/查权益）。
-func baseMACode(maCode string) string {
-	if i := strings.Index(maCode, "#"); i >= 0 {
-		return maCode[:i]
+// baseCCCode 去除集级子标识 #Exx，返回整剧 MA 码（用于查链/查权益）。
+func baseCCCode(ccCode string) string {
+	if i := strings.Index(ccCode, "#"); i >= 0 {
+		return ccCode[:i]
 	}
-	return maCode
+	return ccCode
 }
 
 // Resolve 跨域解析网关（C.1/C.2）：同一 MA 码在 IPTV/OTT/APP 统一解析。
 // 返回解析结构 + 流通状态 + 跨屏可用性，保证大小屏解析结果一致。
-func (s *Service) Resolve(maCode string) model.ResolveResult {
-	res := model.ResolveResult{MACode: maCode}
-	parsed := ParseMACode(maCode)
+func (s *Service) Resolve(ccCode string) model.ResolveResult {
+	res := model.ResolveResult{CCCode: ccCode}
+	parsed := ParseCCCode(ccCode)
 	res.Parsed = parsed
 	if !parsed.Valid {
 		res.Resolved = false
@@ -64,7 +64,7 @@ func (s *Service) Resolve(maCode string) model.ResolveResult {
 		return res
 	}
 
-	c, err := s.chain.QueryContent(baseMACode(maCode))
+	c, err := s.chain.QueryContent(baseCCCode(ccCode))
 	if err != nil {
 		res.Resolved = false
 		res.Message = "MA 码未在可信数据空间登记"
@@ -89,9 +89,9 @@ func (s *Service) Resolve(maCode string) model.ResolveResult {
 }
 
 // ScanVerify 用户扫码验真（B.2）：验证内容 MA 码真伪、合规与流通状态，防盗版。
-func (s *Service) ScanVerify(maCode string) model.ScanVerifyResult {
-	res := model.ScanVerifyResult{MACode: maCode}
-	parsed := ParseMACode(maCode)
+func (s *Service) ScanVerify(ccCode string) model.ScanVerifyResult {
+	res := model.ScanVerifyResult{CCCode: ccCode}
+	parsed := ParseCCCode(ccCode)
 	res.Parsed = parsed
 	if !parsed.Valid {
 		res.Authentic = false
@@ -100,7 +100,7 @@ func (s *Service) ScanVerify(maCode string) model.ScanVerifyResult {
 		return res
 	}
 
-	c, err := s.chain.QueryContent(baseMACode(maCode))
+	c, err := s.chain.QueryContent(baseCCCode(ccCode))
 	if err != nil {
 		res.Authentic = false
 		res.Compliant = false
@@ -127,14 +127,14 @@ func (s *Service) ScanVerify(maCode string) model.ScanVerifyResult {
 
 // RecordPurchase 记录用户购买（D.1）：用户在某一屏购买内容，记录跨屏权益。
 // 校验 MA 码有效、屏类型合法；同一用户对同一 MA 码重复购买不覆盖首次记录。
-func (s *Service) RecordPurchase(maCode, userHash string, screen model.ScreenType) (model.PurchaseRecord, error) {
+func (s *Service) RecordPurchase(ccCode, userHash string, screen model.ScreenType) (model.PurchaseRecord, error) {
 	if userHash == "" {
 		return model.PurchaseRecord{}, fmt.Errorf("service: 缺少用户标识")
 	}
 	if !model.ValidScreen(screen) {
 		return model.PurchaseRecord{}, fmt.Errorf("service: 非法屏类型 %q（仅 iptv/ott/app）", screen)
 	}
-	base := baseMACode(maCode)
+	base := baseCCCode(ccCode)
 	if _, err := s.chain.QueryContent(base); err != nil {
 		return model.PurchaseRecord{}, fmt.Errorf("service: MA 码无效或未登记: %w", err)
 	}
@@ -151,17 +151,17 @@ func (s *Service) RecordPurchase(maCode, userHash string, screen model.ScreenTyp
 		return rec, nil
 	}
 	rec := model.PurchaseRecord{
-		MACode: base, UserHash: userHash, Screen: screen, PurchasedAt: time.Now(),
+		CCCode: base, UserHash: userHash, Screen: screen, PurchasedAt: time.Now(),
 	}
 	acct.Purchases[base] = rec
 	return rec, nil
 }
 
 // VerifyCrossScreenRights 跨屏权益核验（D.1）：任一屏购买即全屏通看，不重复付费。
-func (s *Service) VerifyCrossScreenRights(maCode, userHash string, requestScreen model.ScreenType) model.CrossScreenRightsResult {
-	base := baseMACode(maCode)
+func (s *Service) VerifyCrossScreenRights(ccCode, userHash string, requestScreen model.ScreenType) model.CrossScreenRightsResult {
+	base := baseCCCode(ccCode)
 	res := model.CrossScreenRightsResult{
-		MACode: base, UserHash: userHash, RequestScreen: requestScreen,
+		CCCode: base, UserHash: userHash, RequestScreen: requestScreen,
 	}
 	if !model.ValidScreen(requestScreen) {
 		res.Entitled = false
diff --git a/tcs-iptv/internal/service/phase4_test.go b/tcs-iptv/internal/service/phase4_test.go
index a0a2b97..4ee5cdc 100644
--- a/tcs-iptv/internal/service/phase4_test.go
+++ b/tcs-iptv/internal/service/phase4_test.go
@@ -10,20 +10,20 @@ import (
 )
 
 // issueAndPublish 走完送审→审核→发码→入库→发布，返回已流通内容的 MA 码与 ctid。
-func issueAndPublish(t *testing.T, s *Service) (maCode, ctid string) {
+func issueAndPublish(t *testing.T, s *Service) (ccCode, ctid string) {
 	t.Helper()
 	sub, err := s.SubmitForReview(sampleSub())
 	require.NoError(t, err)
 	require.NoError(t, s.ReviewCSPS(sub.ReviewID, true, "rv-1"))
 	issued, err := s.ApproveAndIssue(chain.RoleRegulator, sub.ReviewID, "陕西省广播电视局")
 	require.NoError(t, err)
-	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, issued.MACode, issued.ContentTwinID, "MA-001", "省媒资库"))
-	require.NoError(t, s.PublishToOperator(PublishRequest{MACode: issued.MACode, Certificate: issued.Certificate}))
-	return issued.MACode, issued.ContentTwinID
+	require.NoError(t, s.IngestToLibrary(chain.RoleReviewer, issued.CCCode, issued.ContentTwinID, "MA-001", "省媒资库"))
+	require.NoError(t, s.PublishToOperator(PublishRequest{CCCode: issued.CCCode, Certificate: issued.Certificate}))
+	return issued.CCCode, issued.ContentTwinID
 }
 
-func TestParseMACode_Valid(t *testing.T) {
-	p := ParseMACode("MA.156.8531.6101/WD/20260000004")
+func TestParseCCCode_Valid(t *testing.T) {
+	p := ParseCCCode("MA.156.8531.6101/WD/20260000004")
 	assert.True(t, p.Valid)
 	assert.Equal(t, "156", p.CountryCode)
 	assert.Equal(t, "8531", p.IndustryNode)
@@ -33,24 +33,24 @@ func TestParseMACode_Valid(t *testing.T) {
 	assert.Equal(t, 0, p.Episode)
 }
 
-func TestParseMACode_WithEpisode(t *testing.T) {
-	p := ParseMACode("MA.156.8531.6101/WD/20260000004#E07")
+func TestParseCCCode_WithEpisode(t *testing.T) {
+	p := ParseCCCode("MA.156.8531.6101/WD/20260000004#E07")
 	assert.True(t, p.Valid)
 	assert.Equal(t, 7, p.Episode)
 }
 
-func TestParseMACode_Invalid(t *testing.T) {
+func TestParseCCCode_Invalid(t *testing.T) {
 	for _, bad := range []string{"", "not-a-code", "MA.156", "XX.156.8531.6101/WD/20260000004"} {
-		p := ParseMACode(bad)
+		p := ParseCCCode(bad)
 		assert.False(t, p.Valid, "应判定非法: %q", bad)
 	}
 }
 
 func TestResolve_PublishedAvailableAllScreens(t *testing.T) {
 	s := newService(t)
-	maCode, _ := issueAndPublish(t, s)
+	ccCode, _ := issueAndPublish(t, s)
 
-	r := s.Resolve(maCode)
+	r := s.Resolve(ccCode)
 	assert.True(t, r.Resolved)
 	assert.True(t, r.InCirculation)
 	assert.Equal(t, model.StatusPublished, r.Status)
@@ -59,9 +59,9 @@ func TestResolve_PublishedAvailableAllScreens(t *testing.T) {
 
 func TestResolve_EpisodeSubIDResolvesToBase(t *testing.T) {
 	s := newService(t)
-	maCode, _ := issueAndPublish(t, s)
+	ccCode, _ := issueAndPublish(t, s)
 
-	r := s.Resolve(maCode + "#E03")
+	r := s.Resolve(ccCode + "#E03")
 	assert.True(t, r.Resolved)
 	assert.Equal(t, 3, r.Parsed.Episode)
 	assert.True(t, r.InCirculation)
@@ -83,11 +83,11 @@ func TestResolve_UnregisteredCode(t *testing.T) {
 
 func TestResolve_RevokedNotInCirculation(t *testing.T) {
 	s := newService(t)
-	maCode, _ := issueAndPublish(t, s)
-	_, err := s.Takedown(chain.RoleRegulator, maCode, "违规")
+	ccCode, _ := issueAndPublish(t, s)
+	_, err := s.Takedown(chain.RoleRegulator, ccCode, "违规")
 	require.NoError(t, err)
 
-	r := s.Resolve(maCode)
+	r := s.Resolve(ccCode)
 	assert.True(t, r.Resolved)
 	assert.False(t, r.InCirculation)
 	assert.Empty(t, r.Screens)
@@ -95,9 +95,9 @@ func TestResolve_RevokedNotInCirculation(t *testing.T) {
 
 func TestScanVerify_AuthenticAndCompliant(t *testing.T) {
 	s := newService(t)
-	maCode, _ := issueAndPublish(t, s)
+	ccCode, _ := issueAndPublish(t, s)
 
-	r := s.ScanVerify(maCode)
+	r := s.ScanVerify(ccCode)
 	assert.True(t, r.Authentic)
 	assert.True(t, r.Compliant)
 }
@@ -111,23 +111,23 @@ func TestScanVerify_FakeCode(t *testing.T) {
 
 func TestScanVerify_RevokedNotCompliant(t *testing.T) {
 	s := newService(t)
-	maCode, _ := issueAndPublish(t, s)
-	_, err := s.Takedown(chain.RoleRegulator, maCode, "违规")
+	ccCode, _ := issueAndPublish(t, s)
+	_, err := s.Takedown(chain.RoleRegulator, ccCode, "违规")
 	require.NoError(t, err)
 
-	r := s.ScanVerify(maCode)
+	r := s.ScanVerify(ccCode)
 	assert.True(t, r.Authentic, "下架仍是真码")
 	assert.False(t, r.Compliant, "下架内容不合规")
 }
 
 func TestRecordPurchase_InvalidScreenRejected(t *testing.T) {
 	s := newService(t)
-	maCode, _ := issueAndPublish(t, s)
-	_, err := s.RecordPurchase(maCode, "user-1", "smartwatch")
+	ccCode, _ := issueAndPublish(t, s)
+	_, err := s.RecordPurchase(ccCode, "user-1", "smartwatch")
 	assert.Error(t, err)
 }
 
-func TestRecordPurchase_UnknownMACodeRejected(t *testing.T) {
+func TestRecordPurchase_UnknownCCCodeRejected(t *testing.T) {
 	s := newService(t)
 	_, err := s.RecordPurchase("MA.156.8531.6101/WD/20269999999", "user-1", model.ScreenIPTV)
 	assert.Error(t, err)
@@ -135,38 +135,38 @@ func TestRecordPurchase_UnknownMACodeRejected(t *testing.T) {
 
 func TestCrossScreenRights_BuyOnceWatchEverywhere(t *testing.T) {
 	s := newService(t)
-	maCode, _ := issueAndPublish(t, s)
+	ccCode, _ := issueAndPublish(t, s)
 
 	// 电视端购买
-	rec, err := s.RecordPurchase(maCode, "user-1", model.ScreenIPTV)
+	rec, err := s.RecordPurchase(ccCode, "user-1", model.ScreenIPTV)
 	require.NoError(t, err)
 	assert.Equal(t, model.ScreenIPTV, rec.Screen)
 
 	// 手机端通看，不重复付费
-	r := s.VerifyCrossScreenRights(maCode, "user-1", model.ScreenApp)
+	r := s.VerifyCrossScreenRights(ccCode, "user-1", model.ScreenApp)
 	assert.True(t, r.Entitled)
 	assert.Equal(t, model.ScreenIPTV, r.PurchaseScreen)
 
 	// OTT 端通看
-	r2 := s.VerifyCrossScreenRights(maCode, "user-1", model.ScreenOTT)
+	r2 := s.VerifyCrossScreenRights(ccCode, "user-1", model.ScreenOTT)
 	assert.True(t, r2.Entitled)
 }
 
 func TestCrossScreenRights_NotPurchased(t *testing.T) {
 	s := newService(t)
-	maCode, _ := issueAndPublish(t, s)
-	r := s.VerifyCrossScreenRights(maCode, "user-x", model.ScreenApp)
+	ccCode, _ := issueAndPublish(t, s)
+	r := s.VerifyCrossScreenRights(ccCode, "user-x", model.ScreenApp)
 	assert.False(t, r.Entitled)
 }
 
 func TestRecordPurchase_IdempotentNoDoubleCharge(t *testing.T) {
 	s := newService(t)
-	maCode, _ := issueAndPublish(t, s)
+	ccCode, _ := issueAndPublish(t, s)
 
-	first, err := s.RecordPurchase(maCode, "user-1", model.ScreenIPTV)
+	first, err := s.RecordPurchase(ccCode, "user-1", model.ScreenIPTV)
 	require.NoError(t, err)
 	// 在手机端再次"购买"同内容 → 返回首次记录，不新建（跨屏通兑）
-	second, err := s.RecordPurchase(maCode, "user-1", model.ScreenApp)
+	second, err := s.RecordPurchase(ccCode, "user-1", model.ScreenApp)
 	require.NoError(t, err)
 	assert.Equal(t, first.Screen, second.Screen, "重复购买应返回首次记录的购买屏")
 	assert.Equal(t, first.PurchasedAt, second.PurchasedAt)
@@ -174,10 +174,10 @@ func TestRecordPurchase_IdempotentNoDoubleCharge(t *testing.T) {
 
 func TestCrossScreenRights_EpisodeSubIDSharesEntitlement(t *testing.T) {
 	s := newService(t)
-	maCode, _ := issueAndPublish(t, s)
-	_, err := s.RecordPurchase(maCode, "user-1", model.ScreenIPTV)
+	ccCode, _ := issueAndPublish(t, s)
+	_, err := s.RecordPurchase(ccCode, "user-1", model.ScreenIPTV)
 	require.NoError(t, err)
 	// 用集级子标识核验权益应归一到整剧 MA 码
-	r := s.VerifyCrossScreenRights(maCode+"#E05", "user-1", model.ScreenApp)
+	r := s.VerifyCrossScreenRights(ccCode+"#E05", "user-1", model.ScreenApp)
 	assert.True(t, r.Entitled)
 }
diff --git a/tcs-iptv/internal/service/query_admin.go b/tcs-iptv/internal/service/query_admin.go
index cf3a2a9..2da99d2 100644
--- a/tcs-iptv/internal/service/query_admin.go
+++ b/tcs-iptv/internal/service/query_admin.go
@@ -24,44 +24,44 @@ func (s *Service) QueryByLibraryFileID(libraryFileID string) (model.ContentQuery
 
 // ---- MA 合并/拆分（方案 MA 管理模块补足）----
 
-// MergeMACodes 将多个 MA 码合并为一个主 MA 码（仅监管主体）。
+// MergeCCCodes 将多个 MA 码合并为一个主 MA 码（仅监管主体）。
 // 被合并的 MA 码的哈希绑定和映射迁移至主 MA 码，原 MA 码状态标记为 merged。
 // 全链路存证记录合并操作。
-func (s *Service) MergeMACodes(role chain.Role, req model.MergeRequest) (model.MergeResult, error) {
+func (s *Service) MergeCCCodes(role chain.Role, req model.MergeRequest) (model.MergeResult, error) {
 	res, err := s.chain.MergeMA(role, req)
 	if err != nil {
 		return res, err
 	}
 	// 记录存证
 	s.prov.Record(model.ProvenanceEvent{
-		MACode:   req.PrimaryMACode,
+		CCCode:   req.PrimaryCCCode,
 		Node:     model.NodeIssue,
 		Operator: req.Operator,
-		Detail:   "MA 码合并：将 " + joinMACodes(req.SecondaryMACodes) + " 合并入 " + req.PrimaryMACode + "，原因：" + req.Reason,
+		Detail:   "MA 码合并：将 " + joinCCCodes(req.SecondaryCCCodes) + " 合并入 " + req.PrimaryCCCode + "，原因：" + req.Reason,
 	})
 	return res, nil
 }
 
-// SplitMACode 将一个 MA 码拆分为多个独立 MA 码（仅监管主体）。
+// SplitCCCode 将一个 MA 码拆分为多个独立 MA 码（仅监管主体）。
 // 按集号将哈希绑定和映射迁移至新 MA 码，源 MA 码状态标记为 split。
 // 全链路存证记录拆分操作。
-func (s *Service) SplitMACode(role chain.Role, req model.SplitRequest) (model.SplitResult, error) {
+func (s *Service) SplitCCCode(role chain.Role, req model.SplitRequest) (model.SplitResult, error) {
 	res, err := s.chain.SplitMA(role, req)
 	if err != nil {
 		return res, err
 	}
 	// 记录存证
 	s.prov.Record(model.ProvenanceEvent{
-		MACode:   req.SourceMACode,
+		CCCode:   req.SourceCCCode,
 		Node:     model.NodeIssue,
 		Operator: req.Operator,
-		Detail:   "MA 码拆分：将 " + req.SourceMACode + " 拆分为 " + joinMACodes(res.NewMACodes) + "，原因：" + req.Reason,
+		Detail:   "MA 码拆分：将 " + req.SourceCCCode + " 拆分为 " + joinCCCodes(res.NewCCCodes) + "，原因：" + req.Reason,
 	})
 	return res, nil
 }
 
-// joinMACodes 将 MA 码列表拼接为逗号分隔的字符串。
-func joinMACodes(codes []string) string {
+// joinCCCodes 将 MA 码列表拼接为逗号分隔的字符串。
+func joinCCCodes(codes []string) string {
 	if len(codes) == 0 {
 		return ""
 	}
diff --git a/tcs-iptv/internal/service/regulatory.go b/tcs-iptv/internal/service/regulatory.go
index 04e358c..ef7d9f3 100644
--- a/tcs-iptv/internal/service/regulatory.go
+++ b/tcs-iptv/internal/service/regulatory.go
@@ -3,7 +3,7 @@ package service
 import (
 	"time"
 
-	"github.com/tcs-iptv/tcs/internal/macode"
+	"github.com/tcs-iptv/tcs/internal/cccode"
 	"github.com/tcs-iptv/tcs/internal/model"
 )
 
@@ -16,29 +16,29 @@ var orgNodeProvince = map[string]string{
 }
 
 // BindFiling 关联备案号/网标号至 MA 码（三期 A.1，对接广电总局备案系统）。
-func (s *Service) BindFiling(maCode, licenseNo, filingNo string) (model.FilingRecord, error) {
-	if _, err := s.chain.QueryContent(maCode); err != nil {
+func (s *Service) BindFiling(ccCode, licenseNo, filingNo string) (model.FilingRecord, error) {
+	if _, err := s.chain.QueryContent(ccCode); err != nil {
 		return model.FilingRecord{}, err
 	}
 	rec := model.FilingRecord{
-		MACode: maCode, LicenseNo: licenseNo, FilingNo: filingNo,
+		CCCode: ccCode, LicenseNo: licenseNo, FilingNo: filingNo,
 		BoundAt: time.Now().Format(time.RFC3339),
 	}
 	s.mu.Lock()
-	s.filings[maCode] = rec
+	s.filings[ccCode] = rec
 	s.mu.Unlock()
 	s.prov.Record(model.ProvenanceEvent{
-		MACode: maCode, Node: model.NodeIssue, Operator: "广电总局备案系统",
+		CCCode: ccCode, Node: model.NodeIssue, Operator: "广电总局备案系统",
 		Detail: "关联网标号 " + licenseNo + " / 备案号 " + filingNo,
 	})
 	return rec, nil
 }
 
 // QueryFiling 查询备案关联。
-func (s *Service) QueryFiling(maCode string) (model.FilingRecord, bool) {
+func (s *Service) QueryFiling(ccCode string) (model.FilingRecord, bool) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
-	r, ok := s.filings[maCode]
+	r, ok := s.filings[ccCode]
 	return r, ok
 }
 
@@ -56,7 +56,7 @@ func (s *Service) NationalStats() (model.NationalStats, error) {
 	st.TotalContents = len(all)
 	for _, c := range all {
 		st.ByStatus[c.Status]++
-		p, perr := macode.Parse(c.MACode)
+		p, perr := cccode.Parse(c.CCCode)
 		if perr == nil {
 			st.ByCategory[p.Category]++
 			prov := orgNodeProvince[p.OrgNode]
@@ -80,12 +80,12 @@ func (s *Service) NationalStats() (model.NationalStats, error) {
 }
 
 // ListSegments 列出已登记号段及使用情况（三期 B.1）。
-func (s *Service) ListSegments() []macode.SegmentInfo {
+func (s *Service) ListSegments() []cccode.SegmentInfo {
 	return s.gen.Segments()
 }
 
 // RegisterSegment 登记新号段（三期 B.1，与发码机构对接后配置）。
-func (s *Service) RegisterSegment(seg macode.Segment) error {
+func (s *Service) RegisterSegment(seg cccode.Segment) error {
 	return s.gen.RegisterSegment(seg)
 }
 
@@ -101,7 +101,7 @@ func (s *Service) DailyRegulatoryReport(date string) (model.RegulatoryReport, er
 	}
 	for _, c := range all {
 		rep.TotalNew++
-		if p, perr := macode.Parse(c.MACode); perr == nil {
+		if p, perr := cccode.Parse(c.CCCode); perr == nil {
 			rep.LevelDist[p.Category]++
 		}
 		if c.Status == model.StatusRevoked {
diff --git a/tcs-iptv/internal/service/regulatory_test.go b/tcs-iptv/internal/service/regulatory_test.go
index 02eb66f..eeab1d0 100644
--- a/tcs-iptv/internal/service/regulatory_test.go
+++ b/tcs-iptv/internal/service/regulatory_test.go
@@ -6,15 +6,15 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/tcs-iptv/tcs/internal/chain"
-	"github.com/tcs-iptv/tcs/internal/macode"
+	"github.com/tcs-iptv/tcs/internal/cccode"
 )
 
 func newServiceSX(t *testing.T) *Service {
 	t.Helper()
-	gen := macode.NewGenerator(macode.NewMemoryStore())
-	require.NoError(t, gen.RegisterSegment(macode.Segment{
+	gen := cccode.NewGenerator(cccode.NewMemoryStore())
+	require.NoError(t, gen.RegisterSegment(cccode.Segment{
 		IndustryNode: "8531", OrgNode: "6101", // 陕西
-		Category: macode.CategoryMicroDrama, Start: 1, End: 100, SeqWidth: 7,
+		Category: cccode.CategoryMicroDrama, Start: 1, End: 100, SeqWidth: 7,
 	}))
 	return New(chain.NewMemoryChain(), gen)
 }
@@ -26,7 +26,7 @@ func issueSX(t *testing.T, s *Service) string {
 	require.NoError(t, s.ReviewCSPS(r.ReviewID, true, "rv"))
 	iss, err := s.ApproveAndIssue(chain.RoleRegulator, r.ReviewID, "陕西IPTV运营公司")
 	require.NoError(t, err)
-	return iss.MACode
+	return iss.CCCode
 }
 
 func TestBindFiling(t *testing.T) {
diff --git a/tcs-iptv/internal/service/service.go b/tcs-iptv/internal/service/service.go
index 828637a..4666907 100644
--- a/tcs-iptv/internal/service/service.go
+++ b/tcs-iptv/internal/service/service.go
@@ -10,7 +10,7 @@ import (
 	"time"
 
 	"github.com/tcs-iptv/tcs/internal/chain"
-	"github.com/tcs-iptv/tcs/internal/macode"
+	"github.com/tcs-iptv/tcs/internal/cccode"
 	"github.com/tcs-iptv/tcs/internal/model"
 	"github.com/tcs-iptv/tcs/internal/playback"
 	"github.com/tcs-iptv/tcs/internal/provenance"
@@ -30,7 +30,7 @@ var (
 type Submission struct {
 	Title        string
 	EpisodeCount int
-	Category     string // 内容类目（macode.CategoryXxx），决定发码号段
+	Category     string // 内容类目（cccode.CategoryXxx），决定发码号段
 	FileHash     string
 	MerkleRoot   string
 	Perceptual   string
@@ -50,13 +50,13 @@ type SubmissionResult struct {
 // Service 业务编排器。
 type Service struct {
 	chain   chain.Client
-	gen     *macode.Generator
+	gen     *cccode.Generator
 	pb      *playback.Store
 	prov    *provenance.Store
-	phash   map[string]phashEntry          // maCode -> 感知哈希条目（确权侵权比对）
-	auths   map[string]model.Authorization // maCode -> 授权（F22）
-	black   map[string]bool                // maCode -> 黑名单（跨省复用校验）
-	filings map[string]model.FilingRecord  // maCode -> 备案/网标关联（三期 A.1）
+	phash   map[string]phashEntry          // ccCode -> 感知哈希条目（确权侵权比对）
+	auths   map[string]model.Authorization // ccCode -> 授权（F22）
+	black   map[string]bool                // ccCode -> 黑名单（跨省复用校验）
+	filings map[string]model.FilingRecord  // ccCode -> 备案/网标关联（三期 A.1）
 	rights  map[string]*model.UserRights   // userHash -> 跨屏权益账户（四期 D.1）
 	mu      sync.Mutex
 	seqMu   sync.Mutex
@@ -69,7 +69,7 @@ type reviewItem struct {
 	ContentTwinID string
 	Sub           Submission
 	Status        string
-	MACode        string
+	CCCode        string
 }
 
 // phashEntry 感知哈希注册项，用于确权侵权比对。
@@ -79,7 +79,7 @@ type phashEntry struct {
 }
 
 // New 创建业务服务。
-func New(c chain.Client, gen *macode.Generator) *Service {
+func New(c chain.Client, gen *cccode.Generator) *Service {
 	return &Service{
 		chain: c, gen: gen,
 		pb:      playback.NewStore(),
@@ -107,10 +107,10 @@ func (s *Service) SubmitForReview(sub Submission) (SubmissionResult, error) {
 		return SubmissionResult{}, ErrIncompleteHashPkg
 	}
 	// 防换壳重发（需求2-AC3、需求15-AC5）
-	if maCode, exists := s.chain.HashExists(sub.FileHash); exists {
+	if ccCode, exists := s.chain.HashExists(sub.FileHash); exists {
 		return SubmissionResult{
 			Status:  "rejected",
-			Message: fmt.Sprintf("内容哈希已存在，关联原 MA 码: %s", maCode),
+			Message: fmt.Sprintf("内容哈希已存在，关联原 MA 码: %s", ccCode),
 		}, ErrDuplicateContent
 	}
 
@@ -133,14 +133,14 @@ func (s *Service) SubmitForReview(sub Submission) (SubmissionResult, error) {
 
 // IssueResult 签发结果。
 type IssueResult struct {
-	MACode        string `json:"ma_code"`
+	CCCode        string `json:"ma_code"`
 	ContentTwinID string `json:"content_twin_id"`
 	TxID          string `json:"tx_id"`
-	Certificate   string `json:"certificate"` // MA码+哈希证书（MVP 简化为字符串）
+	Certificate   string `json:"certificate"` // CC码+哈希证书（MVP 简化为字符串）
 }
 
 // ReviewCSPS CSPS 合规审核（发码前）。审核通过后方可发码，体现"审过才发证发码"。
-// 对应需求5（CSPS审核）+ 需求3-AC2（审核通过后生成MA码）。
+// 对应需求5（CSPS审核）+ 需求3-AC2（审核通过后生成CC码）。
 func (s *Service) ReviewCSPS(reviewID string, approved bool, reviewerID string) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -158,7 +158,7 @@ func (s *Service) ReviewCSPS(reviewID string, approved bool, reviewerID string)
 
 // ApproveAndIssue 在 CSPS 审核通过后**生成 MA 码**并强绑定哈希（需求3，模式B 自行发码）。
 // 前置：该送审必须已通过 CSPS 审核（审过才发码）。
-// MA 码由 macode.Generator 按内容类目从号段中原子分配。仅监管主体可调用。
+// MA 码由 cccode.Generator 按内容类目从号段中原子分配。仅监管主体可调用。
 func (s *Service) ApproveAndIssue(role chain.Role, reviewID, issuer string) (IssueResult, error) {
 	s.mu.Lock()
 	item, ok := s.reviews[reviewID]
@@ -179,10 +179,10 @@ func (s *Service) ApproveAndIssue(role chain.Role, reviewID, issuer string) (Iss
 	if err != nil {
 		return IssueResult{}, fmt.Errorf("service: allocate MA code: %w", err)
 	}
-	maCode := issued.MACode
+	ccCode := issued.CCCode
 
 	txID, err := s.chain.IssueMA(role, chain.IssueRequest{
-		MACode:         maCode,
+		CCCode:         ccCode,
 		ContentTwinID:  item.ContentTwinID,
 		MerkleRoot:     item.Sub.MerkleRoot,
 		FileHash:       item.Sub.FileHash,
@@ -202,7 +202,7 @@ func (s *Service) ApproveAndIssue(role chain.Role, reviewID, issuer string) (Iss
 
 	s.mu.Lock()
 	item.Status = model.StatusIssued // 已发码，移出"待发码"队列
-	item.MACode = maCode
+	item.CCCode = ccCode
 	s.mu.Unlock()
 
 	// CP 注册本方映射
@@ -214,18 +214,18 @@ func (s *Service) ApproveAndIssue(role chain.Role, reviewID, issuer string) (Iss
 	})
 
 	// 记录全链路存证（送审→审核→发码）+ 注册感知哈希供确权比对
-	s.prov.Record(model.ProvenanceEvent{MACode: maCode, Node: model.NodeSubmit, HashValue: item.Sub.FileHash, Operator: item.Sub.CPName, Detail: "CP 送审"})
-	s.prov.Record(model.ProvenanceEvent{MACode: maCode, Node: model.NodeCSPSReview, Operator: "CSPS", Detail: "合规审核通过"})
-	s.prov.Record(model.ProvenanceEvent{MACode: maCode, Node: model.NodeIssue, HashValue: item.Sub.FileHash, Operator: issuer, Detail: "发码签发，绑定基准哈希"})
+	s.prov.Record(model.ProvenanceEvent{CCCode: ccCode, Node: model.NodeSubmit, HashValue: item.Sub.FileHash, Operator: item.Sub.CPName, Detail: "CP 送审"})
+	s.prov.Record(model.ProvenanceEvent{CCCode: ccCode, Node: model.NodeCSPSReview, Operator: "CSPS", Detail: "合规审核通过"})
+	s.prov.Record(model.ProvenanceEvent{CCCode: ccCode, Node: model.NodeIssue, HashValue: item.Sub.FileHash, Operator: issuer, Detail: "发码签发，绑定基准哈希"})
 	if item.Sub.Perceptual != "" {
 		s.mu.Lock()
-		s.phash[maCode] = phashEntry{Title: item.Sub.Title, Perceptual: item.Sub.Perceptual}
+		s.phash[ccCode] = phashEntry{Title: item.Sub.Title, Perceptual: item.Sub.Perceptual}
 		s.mu.Unlock()
 	}
 
-	cert := fmt.Sprintf("CERT|%s|%s|%s", maCode, item.Sub.FileHash, item.Sub.MerkleRoot)
+	cert := fmt.Sprintf("CERT|%s|%s|%s", ccCode, item.Sub.FileHash, item.Sub.MerkleRoot)
 	return IssueResult{
-		MACode:        maCode,
+		CCCode:        ccCode,
 		ContentTwinID: item.ContentTwinID,
 		TxID:          txID,
 		Certificate:   cert,
@@ -233,8 +233,8 @@ func (s *Service) ApproveAndIssue(role chain.Role, reviewID, issuer string) (Iss
 }
 
 // Verify 送审文件验真 / CDN 注入校验通用入口（需求4、需求7）。
-func (s *Service) Verify(maCode, fileHash string) (chain.VerifyResult, error) {
-	res, err := s.chain.VerifyHash(maCode, fileHash)
+func (s *Service) Verify(ccCode, fileHash string) (chain.VerifyResult, error) {
+	res, err := s.chain.VerifyHash(ccCode, fileHash)
 	if err != nil {
 		return res, err
 	}
@@ -245,13 +245,13 @@ func (s *Service) Verify(maCode, fileHash string) (chain.VerifyResult, error) {
 }
 
 // QueryMappings 查询 MA 码绑定的三方映射与 CDN 端点（需求11/17）。
-func (s *Service) QueryMappings(maCode string) (chain.MappingsResult, error) {
-	return s.chain.QueryMappings(maCode)
+func (s *Service) QueryMappings(ccCode string) (chain.MappingsResult, error) {
+	return s.chain.QueryMappings(ccCode)
 }
 
-// VerifyEpisode 按集级子标识（MA码#E07）或 MA码+集号 验真单集。
-func (s *Service) VerifyEpisode(maCode string, episode int, fileHash string) (chain.VerifyResult, error) {
-	res, err := s.chain.VerifyEpisodeHash(maCode, episode, fileHash)
+// VerifyEpisode 按集级子标识（CC码#E07）或 CC码+集号 验真单集。
+func (s *Service) VerifyEpisode(ccCode string, episode int, fileHash string) (chain.VerifyResult, error) {
+	res, err := s.chain.VerifyEpisodeHash(ccCode, episode, fileHash)
 	if err != nil {
 		return res, err
 	}
@@ -262,8 +262,8 @@ func (s *Service) VerifyEpisode(maCode string, episode int, fileHash string) (ch
 }
 
 // ListEpisodes 列出某剧的全部集级哈希绑定。
-func (s *Service) ListEpisodes(maCode string) ([]model.HashBinding, error) {
-	return s.chain.ListEpisodes(maCode)
+func (s *Service) ListEpisodes(ccCode string) ([]model.HashBinding, error) {
+	return s.chain.ListEpisodes(ccCode)
 }
 
 // ReviewSummary 送审待办摘要（发码前阶段）。
@@ -275,7 +275,7 @@ type ReviewSummary struct {
 	EpisodeCount  int    `json:"episode_count"`
 	Status        string `json:"status"`
 	CPName        string `json:"cp_name"`
-	MACode        string `json:"ma_code"`
+	CCCode        string `json:"ma_code"`
 }
 
 // ListReviews 列出指定状态的送审待办（用于审核台/发码台队列）。
@@ -292,7 +292,7 @@ func (s *Service) ListReviews(status string) []ReviewSummary {
 			ReviewID: id, ContentTwinID: item.ContentTwinID,
 			Title: item.Sub.Title, Category: item.Sub.Category,
 			EpisodeCount: item.Sub.EpisodeCount, Status: item.Status,
-			CPName: item.Sub.CPName, MACode: item.MACode,
+			CPName: item.Sub.CPName, CCCode: item.CCCode,
 		})
 	}
 	return out
diff --git a/tcs-iptv/internal/service/service_test.go b/tcs-iptv/internal/service/service_test.go
index 4bbe7bc..f93ef9c 100644
--- a/tcs-iptv/internal/service/service_test.go
+++ b/tcs-iptv/internal/service/service_test.go
@@ -7,22 +7,22 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/tcs-iptv/tcs/internal/chain"
-	"github.com/tcs-iptv/tcs/internal/macode"
+	"github.com/tcs-iptv/tcs/internal/cccode"
 )
 
 func newService(t *testing.T) *Service {
 	t.Helper()
-	gen := macode.NewGenerator(macode.NewMemoryStore())
-	require.NoError(t, gen.RegisterSegment(macode.Segment{
+	gen := cccode.NewGenerator(cccode.NewMemoryStore())
+	require.NoError(t, gen.RegisterSegment(cccode.Segment{
 		IndustryNode: "8531", OrgNode: "4401",
-		Category: macode.CategoryMicroDrama, Start: 1, End: 100, SeqWidth: 7,
+		Category: cccode.CategoryMicroDrama, Start: 1, End: 100, SeqWidth: 7,
 	}))
 	return New(chain.NewMemoryChain(), gen)
 }
 
 func sampleSub() Submission {
 	return Submission{
-		Title: "示例微短剧", EpisodeCount: 24, Category: macode.CategoryMicroDrama,
+		Title: "示例微短剧", EpisodeCount: 24, Category: cccode.CategoryMicroDrama,
 		FileHash: "filehash-abc", MerkleRoot: "merkle-abc", Perceptual: "phash-abc",
 		CPMediaID: "FS-MEDIA-77821", CPName: "飞翮信息",
 	}
@@ -30,7 +30,7 @@ func sampleSub() Submission {
 
 func TestSubmit_IncompleteHashRejected(t *testing.T) {
 	s := newService(t)
-	_, err := s.SubmitForReview(Submission{Title: "无哈希", Category: macode.CategoryMicroDrama})
+	_, err := s.SubmitForReview(Submission{Title: "无哈希", Category: cccode.CategoryMicroDrama})
 	assert.ErrorIs(t, err, ErrIncompleteHashPkg)
 }
 
@@ -43,7 +43,7 @@ func TestSubmit_Success(t *testing.T) {
 	assert.Equal(t, "pending", res.Status)
 }
 
-func TestApproveAndIssue_GeneratesMACode(t *testing.T) {
+func TestApproveAndIssue_GeneratesCCCode(t *testing.T) {
 	s := newService(t)
 	sub, err := s.SubmitForReview(sampleSub())
 	require.NoError(t, err)
@@ -52,10 +52,10 @@ func TestApproveAndIssue_GeneratesMACode(t *testing.T) {
 	issued, err := s.ApproveAndIssue(chain.RoleRegulator, sub.ReviewID, "北京市广播电视局")
 	require.NoError(t, err)
 	// 模式B：MA 码由系统按号段生成
-	assert.True(t, macode.IsValid(issued.MACode), "应生成合法 MA 码: %s", issued.MACode)
-	assert.True(t, strings.HasPrefix(issued.MACode, "MA.156.8531.4401/WD/"), "前缀应匹配号段: %s", issued.MACode)
+	assert.True(t, cccode.IsValid(issued.CCCode), "应生成合法 MA 码: %s", issued.CCCode)
+	assert.True(t, strings.HasPrefix(issued.CCCode, "MA.156.8531.4401/WD/"), "前缀应匹配号段: %s", issued.CCCode)
 	assert.NotEmpty(t, issued.TxID)
-	assert.Contains(t, issued.Certificate, issued.MACode)
+	assert.Contains(t, issued.Certificate, issued.CCCode)
 }
 
 func TestApproveAndIssue_OnlyRegulator(t *testing.T) {
@@ -84,11 +84,11 @@ func TestVerify_MatchAndMismatch(t *testing.T) {
 	require.NoError(t, s.ReviewCSPS(sub.ReviewID, true, "rv-1"))
 	issued, _ := s.ApproveAndIssue(chain.RoleRegulator, sub.ReviewID, "issuer")
 
-	res, err := s.Verify(issued.MACode, "filehash-abc")
+	res, err := s.Verify(issued.CCCode, "filehash-abc")
 	require.NoError(t, err)
 	assert.True(t, res.Match)
 
-	_, err = s.Verify(issued.MACode, "tampered")
+	_, err = s.Verify(issued.CCCode, "tampered")
 	assert.ErrorIs(t, err, ErrHashMismatch)
 }
 
@@ -107,5 +107,5 @@ func TestApproveAndIssue_TwoContentsUniqueCodes(t *testing.T) {
 	i2, err := s.ApproveAndIssue(chain.RoleRegulator, sub2.ReviewID, "issuer")
 	require.NoError(t, err)
 
-	assert.NotEqual(t, i1.MACode, i2.MACode, "两条内容应分配不同 MA 码")
+	assert.NotEqual(t, i1.CCCode, i2.CCCode, "两条内容应分配不同 MA 码")
 }
diff --git a/tcs-iptv/internal/service/settlement_test.go b/tcs-iptv/internal/service/settlement_test.go
index a3d7b1f..8459449 100644
--- a/tcs-iptv/internal/service/settlement_test.go
+++ b/tcs-iptv/internal/service/settlement_test.go
@@ -11,24 +11,24 @@ import (
 
 func TestReportPlaybackAndSettle(t *testing.T) {
 	s := newService(t)
-	maCode, _, _ := issueOne(t, s)
+	ccCode, _, _ := issueOne(t, s)
 
 	// 运营商回传播放/购买事件
 	acc, rej := s.ReportPlayback([]model.PlaybackEvent{
-		{MACode: maCode, PlatformID: "CT-SX", EventType: model.EventPlay},
-		{MACode: maCode, PlatformID: "CT-SX", EventType: model.EventPurchase, RevenueCent: 1500},
-		{MACode: maCode, PlatformID: "CM-SX", EventType: model.EventPurchase, RevenueCent: 2500},
+		{CCCode: ccCode, PlatformID: "CT-SX", EventType: model.EventPlay},
+		{CCCode: ccCode, PlatformID: "CT-SX", EventType: model.EventPurchase, RevenueCent: 1500},
+		{CCCode: ccCode, PlatformID: "CM-SX", EventType: model.EventPurchase, RevenueCent: 2500},
 	})
 	assert.Equal(t, 3, acc)
 	assert.Equal(t, 0, rej)
 
 	// 聚合可信播放数据
-	sum := s.PlaybackSummary(maCode)
+	sum := s.PlaybackSummary(ccCode)
 	assert.Equal(t, int64(4000), sum.TotalRevenue)
 	assert.Equal(t, int64(1), sum.TotalPlays)
 
 	// 分账：CP60/平台34/服务费6
-	st, err := s.ComputeSettlement(maCode, "2026-06")
+	st, err := s.ComputeSettlement(ccCode, "2026-06")
 	require.NoError(t, err)
 	assert.Equal(t, int64(4000), st.TotalRevenue)
 	assert.Equal(t, int64(2400), st.CPShare)
@@ -39,20 +39,20 @@ func TestReportPlaybackAndSettle(t *testing.T) {
 
 func TestReportPlayback_RejectsUnknownOrRevoked(t *testing.T) {
 	s := newService(t)
-	maCode, _, _ := issueOne(t, s)
+	ccCode, _, _ := issueOne(t, s)
 
 	// 未知 MA 码被拒
 	acc, rej := s.ReportPlayback([]model.PlaybackEvent{
-		{MACode: "MA.156.8531.6101/WD/不存在", PlatformID: "P", EventType: model.EventPlay},
+		{CCCode: "MA.156.8531.6101/WD/不存在", PlatformID: "P", EventType: model.EventPlay},
 	})
 	assert.Equal(t, 0, acc)
 	assert.Equal(t, 1, rej)
 
 	// 下架后回传被拒（数据归属不可信）
-	_, err := s.Takedown(chain.RoleRegulator, maCode, "违规")
+	_, err := s.Takedown(chain.RoleRegulator, ccCode, "违规")
 	require.NoError(t, err)
 	acc, rej = s.ReportPlayback([]model.PlaybackEvent{
-		{MACode: maCode, PlatformID: "P", EventType: model.EventPlay},
+		{CCCode: ccCode, PlatformID: "P", EventType: model.EventPlay},
 	})
 	assert.Equal(t, 0, acc)
 	assert.Equal(t, 1, rej)
diff --git a/tcs-iptv/internal/sync/sync.go b/tcs-iptv/internal/sync/sync.go
index 7602b82..296195f 100644
--- a/tcs-iptv/internal/sync/sync.go
+++ b/tcs-iptv/internal/sync/sync.go
@@ -23,16 +23,16 @@ import (
 // SyncSource 标识同步数据源接口。
 type SyncSource interface {
 	ListContents(status string) ([]model.Content, error)
-	QueryContent(maCode string) (model.Content, error)
-	QueryMappings(maCode string) (chain.MappingsResult, error)
-	ListEpisodes(maCode string) ([]model.HashBinding, error)
+	QueryContent(ccCode string) (model.Content, error)
+	QueryMappings(ccCode string) (chain.MappingsResult, error)
+	ListEpisodes(ccCode string) ([]model.HashBinding, error)
 }
 
 // SyncSink 标识同步数据汇接口（远端节点实现）。
 type SyncSink interface {
 	UpsertContent(c model.Content) error
-	UpsertBinding(maCode string, b model.HashBinding) error
-	UpsertMapping(maCode string, m model.Mapping) error
+	UpsertBinding(ccCode string, b model.HashBinding) error
+	UpsertMapping(ccCode string, m model.Mapping) error
 }
 
 // ConflictResolver 同步冲突解决策略。
@@ -103,7 +103,7 @@ func (s *SyncService) Sync(req SyncRequest) (SyncResult, error) {
 		} else {
 			if err := s.sink.UpsertContent(c); err != nil {
 				if errors.Is(err, ErrConflict) && req.Resolver == ConflictFail {
-					return result, fmt.Errorf("sync: 冲突 MA 码 %s: %w", c.MACode, err)
+					return result, fmt.Errorf("sync: 冲突 MA 码 %s: %w", c.CCCode, err)
 				}
 				result.Failed++
 				continue
@@ -112,9 +112,9 @@ func (s *SyncService) Sync(req SyncRequest) (SyncResult, error) {
 		result.TotalContents++
 
 		// 同步哈希绑定
-		eps, _ := s.source.ListEpisodes(c.MACode)
+		eps, _ := s.source.ListEpisodes(c.CCCode)
 		for _, b := range eps {
-			if err := s.sink.UpsertBinding(c.MACode, b); err != nil {
+			if err := s.sink.UpsertBinding(c.CCCode, b); err != nil {
 				result.Failed++
 				continue
 			}
@@ -122,9 +122,9 @@ func (s *SyncService) Sync(req SyncRequest) (SyncResult, error) {
 		}
 
 		// 同步映射
-		mr, _ := s.source.QueryMappings(c.MACode)
+		mr, _ := s.source.QueryMappings(c.CCCode)
 		for _, m := range mr.Mappings {
-			if err := s.sink.UpsertMapping(c.MACode, m); err != nil {
+			if err := s.sink.UpsertMapping(c.CCCode, m); err != nil {
 				result.Failed++
 				continue
 			}
@@ -151,16 +151,16 @@ func (cs *ChainSource) ListContents(status string) ([]model.Content, error) {
 }
 
 // QueryContent 查询内容主记录。
-func (cs *ChainSource) QueryContent(maCode string) (model.Content, error) {
-	return cs.Client.QueryContent(maCode)
+func (cs *ChainSource) QueryContent(ccCode string) (model.Content, error) {
+	return cs.Client.QueryContent(ccCode)
 }
 
 // QueryMappings 查询映射。
-func (cs *ChainSource) QueryMappings(maCode string) (chain.MappingsResult, error) {
-	return cs.Client.QueryMappings(maCode)
+func (cs *ChainSource) QueryMappings(ccCode string) (chain.MappingsResult, error) {
+	return cs.Client.QueryMappings(ccCode)
 }
 
 // ListEpisodes 列出集级哈希。
-func (cs *ChainSource) ListEpisodes(maCode string) ([]model.HashBinding, error) {
-	return cs.Client.ListEpisodes(maCode)
+func (cs *ChainSource) ListEpisodes(ccCode string) ([]model.HashBinding, error) {
+	return cs.Client.ListEpisodes(ccCode)
 }
diff --git a/tcs-iptv/internal/sync/sync_test.go b/tcs-iptv/internal/sync/sync_test.go
index 282a5dc..4814c1c 100644
--- a/tcs-iptv/internal/sync/sync_test.go
+++ b/tcs-iptv/internal/sync/sync_test.go
@@ -32,25 +32,25 @@ func (m *memorySink) UpsertContent(c model.Content) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	if m.conflict {
-		if _, exists := m.contents[c.MACode]; exists {
+		if _, exists := m.contents[c.CCCode]; exists {
 			return ErrConflict
 		}
 	}
-	m.contents[c.MACode] = c
+	m.contents[c.CCCode] = c
 	return nil
 }
 
-func (m *memorySink) UpsertBinding(maCode string, b model.HashBinding) error {
+func (m *memorySink) UpsertBinding(ccCode string, b model.HashBinding) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	m.bindings[maCode] = append(m.bindings[maCode], b)
+	m.bindings[ccCode] = append(m.bindings[ccCode], b)
 	return nil
 }
 
-func (m *memorySink) UpsertMapping(maCode string, mp model.Mapping) error {
+func (m *memorySink) UpsertMapping(ccCode string, mp model.Mapping) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	m.mappings[maCode] = append(m.mappings[maCode], mp)
+	m.mappings[ccCode] = append(m.mappings[ccCode], mp)
 	return nil
 }
 
@@ -60,7 +60,7 @@ func TestSyncService_FullSync(t *testing.T) {
 
 	// 在源端发码
 	_, err := src.Client.IssueMA(chain.RoleRegulator, chain.IssueRequest{
-		MACode: "MA.156.8531.6101/WD/20260000001", ContentTwinID: "ctid-sync-001",
+		CCCode: "MA.156.8531.6101/WD/20260000001", ContentTwinID: "ctid-sync-001",
 		FileHash: "fh-sync-001", MerkleRoot: "mr-sync-001",
 		Episodes: []model.EpisodeHash{
 			{Episode: 1, FileSHA256: "fh-sync-001-E1"},
@@ -97,7 +97,7 @@ func TestSyncService_ConflictSkip(t *testing.T) {
 
 	// 源端发码
 	_, err := src.Client.IssueMA(chain.RoleRegulator, chain.IssueRequest{
-		MACode: "MA.156.8531.6101/WD/20260000002", ContentTwinID: "ctid-sync-002",
+		CCCode: "MA.156.8531.6101/WD/20260000002", ContentTwinID: "ctid-sync-002",
 		FileHash: "fh-sync-002", MerkleRoot: "mr-sync-002",
 		Content: model.Content{Title: "冲突测试剧", MAType: "WD", Issuer: "测试局"},
 	})
@@ -105,7 +105,7 @@ func TestSyncService_ConflictSkip(t *testing.T) {
 
 	// 远端预先存在同 MA 码
 	sink.contents["MA.156.8531.6101/WD/20260000002"] = model.Content{
-		MACode: "MA.156.8531.6101/WD/20260000002", Title: "远端已有",
+		CCCode: "MA.156.8531.6101/WD/20260000002", Title: "远端已有",
 	}
 
 	// 冲突跳过策略
@@ -122,14 +122,14 @@ func TestSyncService_ConflictFail(t *testing.T) {
 	sink.conflict = true
 
 	_, err := src.Client.IssueMA(chain.RoleRegulator, chain.IssueRequest{
-		MACode: "MA.156.8531.6101/WD/20260000003", ContentTwinID: "ctid-sync-003",
+		CCCode: "MA.156.8531.6101/WD/20260000003", ContentTwinID: "ctid-sync-003",
 		FileHash: "fh-sync-003", MerkleRoot: "mr-sync-003",
 		Content: model.Content{Title: "冲突Fail测试", MAType: "WD", Issuer: "测试局"},
 	})
 	require.NoError(t, err)
 
 	sink.contents["MA.156.8531.6101/WD/20260000003"] = model.Content{
-		MACode: "MA.156.8531.6101/WD/20260000003", Title: "远端已有",
+		CCCode: "MA.156.8531.6101/WD/20260000003", Title: "远端已有",
 	}
 
 	svc := New(src, sink)
diff --git a/tcs-iptv/scripts/seed_demo.sh b/tcs-iptv/scripts/seed_demo.sh
index 52dfbb4..90eb4d2 100644
--- a/tcs-iptv/scripts/seed_demo.sh
+++ b/tcs-iptv/scripts/seed_demo.sh
@@ -49,7 +49,7 @@ flow() {
   local iss; iss=$(call ak-regulator sk-regulator POST /content/issue \
     "{\"review_id\":\"$rid\",\"issuer\":\"陕西IPTV运营公司\"}")
   local ma cert; ma=$(field "$iss" ma_code); cert=$(field "$iss" certificate)
-  echo "    MA码: $ma"
+  echo "    CC码: $ma"
 
   call ak-reviewer sk-reviewer POST /content/ingest \
     "{\"ma_code\":\"$ma\",\"content_twin_id\":\"$ctid\",\"media_asset_id\":\"SXMEDIA-$fh\",\"lib_name\":\"陕西IPTV媒体资源库\"}" >/dev/null
@@ -58,10 +58,10 @@ flow() {
   local inj; inj=$(call ak-operator sk-operator POST /content/inject \
     "{\"content_twin_id\":\"$ctid\",\"ma_code\":\"$ma\",\"file_sha256\":\"$fh\",\"operator_id\":\"$opid\",\"cdn_endpoint\":\"$cdn\"}")
   echo "    运营商: $opname  注入: $(field "$inj" distribution_id)"
-  echo "$ma" >> /tmp/tcs_demo_macodes.txt
+  echo "$ma" >> /tmp/tcs_demo_cccodes.txt
 }
 
-: > /tmp/tcs_demo_macodes.txt
+: > /tmp/tcs_demo_cccodes.txt
 
 flow "长安少年行" WD "fh-changan-001" \
   "XAQJSL-2026-001" "西安曲江丝路文化传播有限公司" \
@@ -77,7 +77,7 @@ flow "丝路驼铃" DY "fh-silu-003" \
 
 echo ""
 echo "=== 已生成 MA 码（可复制到监管大屏查询）==="
-cat /tmp/tcs_demo_macodes.txt
+cat /tmp/tcs_demo_cccodes.txt
 echo ""
 echo "提示：在 http://localhost:5174「角色工作台 → 监管片库」点详情查看全链路三方映射与集级哈希；"
 echo "      或在「大小屏融合」tab 用上述 MA 码体验跨域解析 / 扫码验真 / 跨屏权益。"
diff --git a/tcs-iptv/web-console/src/App.jsx b/tcs-iptv/web-console/src/App.jsx
index f6c687d..1d79161 100644
--- a/tcs-iptv/web-console/src/App.jsx
+++ b/tcs-iptv/web-console/src/App.jsx
@@ -28,7 +28,7 @@ export default function App() {
           TCS-IPTV 内容可信锁定系统
         </Title>
         <Text style={{ color: '#b3c5ff', marginLeft: 16, whiteSpace: 'nowrap' }}>
-          陕西IPTV运营公司 · MA码+哈希双锚定
+          陕西IPTV运营公司 · CC码+哈希双锚定
         </Text>
         <Menu
           mode="horizontal" theme="dark" selectedKeys={[view]}
diff --git a/tcs-iptv/web-console/src/FlowDemo.jsx b/tcs-iptv/web-console/src/FlowDemo.jsx
index c844cb6..1bd5798 100644
--- a/tcs-iptv/web-console/src/FlowDemo.jsx
+++ b/tcs-iptv/web-console/src/FlowDemo.jsx
@@ -28,7 +28,7 @@ export default function FlowDemo() {
   const [current, setCurrent] = useState(0)
   const [running, setRunning] = useState(false)
   const [logs, setLogs] = useState([])
-  const [ctx, setCtx] = useState({}) // reviewID/ctid/maCode/cert/fileHash/episodeHashes
+  const [ctx, setCtx] = useState({}) // reviewID/ctid/ccCode/cert/fileHash/episodeHashes
   const [done, setDone] = useState(false)
   const [episodes, setEpisodes] = useState([]) // 集级哈希列表
   const [epVerify, setEpVerify] = useState({}) // {episode: 'match'|'mismatch'}
@@ -70,8 +70,8 @@ export default function FlowDemo() {
         break
       case 'issue':
         res = await api.issue({ review_id: shared.reviewID, issuer: '陕西IPTV运营公司' })
-        if (res.ok) { shared.maCode = res.data.data.ma_code; shared.cert = res.data.data.certificate }
-        addLog(step.role, step.title, res.ok, res.ok ? `MA码 ${shared.maCode}` : res.data.message)
+        if (res.ok) { shared.ccCode = res.data.data.ma_code; shared.cert = res.data.data.certificate }
+        addLog(step.role, step.title, res.ok, res.ok ? `CC码 ${shared.ccCode}` : res.data.message)
         break
       case 'csps':
         res = await api.csps({ review_id: shared.reviewID, approved: true, reviewer_id: 'sxiptv-审核01' })
@@ -79,18 +79,18 @@ export default function FlowDemo() {
         break
       case 'ingest':
         res = await api.ingest({
-          ma_code: shared.maCode, content_twin_id: shared.ctid,
+          ma_code: shared.ccCode, content_twin_id: shared.ctid,
           media_asset_id: 'SXMEDIA-' + fileHash, lib_name: '陕西IPTV媒体资源库',
         })
         addLog(step.role, step.title, res.ok, res.ok ? '已入媒资库' : res.data.message)
         break
       case 'publish':
-        res = await api.publish({ ma_code: shared.maCode, certificate: shared.cert })
+        res = await api.publish({ ma_code: shared.ccCode, certificate: shared.cert })
         addLog(step.role, step.title, res.ok, res.ok ? '已发布' : res.data.message)
         break
       case 'inject':
         res = await api.inject({
-          content_twin_id: shared.ctid, ma_code: shared.maCode, file_sha256: fileHash,
+          content_twin_id: shared.ctid, ma_code: shared.ccCode, file_sha256: fileHash,
           operator_id: v.opId, cdn_endpoint: v.cdn,
         })
         addLog(step.role, step.title, res.ok,
@@ -119,11 +119,11 @@ export default function FlowDemo() {
     setCurrent(STEPS.length)
     setCtx(shared); setDone(true); setRunning(false)
     message.success('全流程跑通：审过即锁定，锁定即通行')
-    await loadEpisodes(shared.maCode)
+    await loadEpisodes(shared.ccCode)
   }
 
-  async function loadEpisodes(maCode) {
-    const res = await api.episodes(maCode)
+  async function loadEpisodes(ccCode) {
+    const res = await api.episodes(ccCode)
     if (res.ok) setEpisodes(res.data.data.episodes || [])
   }
 
@@ -131,7 +131,7 @@ export default function FlowDemo() {
   async function verifyEp(ep, correct) {
     const realHash = (ctx.episodeHashes || []).find((e) => e.episode === ep)?.hash
     const submit = correct ? realHash : 'TAMPERED-' + realHash
-    const res = await api.verifyEpisode(ctx.maCode, ep, submit)
+    const res = await api.verifyEpisode(ctx.ccCode, ep, submit)
     const matched = res.ok && res.data.data?.match
     setEpVerify((prev) => ({ ...prev, [ep]: matched ? 'match' : 'mismatch' }))
     if (matched) message.success(`第${ep}集验真通过`)
@@ -139,7 +139,7 @@ export default function FlowDemo() {
   }
 
   async function doTakedown() {
-    const res = await api.takedown(ctx.maCode, '监管演示下架')
+    const res = await api.takedown(ctx.ccCode, '监管演示下架')
     if (res.ok) {
       addLog('regulator', '违规应急下架', true,
         `秒级下架，受影响 CDN: ${(res.data.data.cdn_endpoints || []).join(', ')}`)
@@ -149,7 +149,7 @@ export default function FlowDemo() {
 
   async function doTamperTest() {
     const res = await api.inject({
-      content_twin_id: ctx.ctid, ma_code: ctx.maCode, file_sha256: 'TAMPERED-' + ctx.fileHash,
+      content_twin_id: ctx.ctid, ma_code: ctx.ccCode, file_sha256: 'TAMPERED-' + ctx.fileHash,
       operator_id: 'OP-X', cdn_endpoint: 'cdn://x',
     })
     addLog('operator', '篡改注入测试', !res.ok, res.ok ? '⚠️ 异常：篡改竟通过' : '✅ 已拒绝：' + res.data.message)
@@ -210,7 +210,7 @@ export default function FlowDemo() {
         {done && (
           <Card title={<Space><SafetyCertificateOutlined />赋码结果（双锚定）</Space>} style={{ marginBottom: 16 }}>
             <Descriptions bordered size="small" column={1}>
-              <Descriptions.Item label="MA 码（监管锚点）"><Text strong copyable>{ctx.maCode}</Text></Descriptions.Item>
+              <Descriptions.Item label="MA 码（监管锚点）"><Text strong copyable>{ctx.ccCode}</Text></Descriptions.Item>
               <Descriptions.Item label="文件哈希（技术锚点）">{ctx.fileHash}</Descriptions.Item>
               <Descriptions.Item label="CTID（机器主键）">{ctx.ctid}</Descriptions.Item>
             </Descriptions>
@@ -226,14 +226,14 @@ export default function FlowDemo() {
           <Card
             title={<Space>集级面板<Tag color="purple">一剧一码 · {episodes.length} 集独立哈希</Tag></Space>}
             style={{ marginBottom: 16 }}
-            extra={<Text type="secondary">集级子标识：{ctx.maCode}#E01 …</Text>}
+            extra={<Text type="secondary">集级子标识：{ctx.ccCode}#E01 …</Text>}
           >
             <Table
               size="small" rowKey="episode" pagination={false}
               dataSource={episodes}
               columns={[
                 { title: '集号', dataIndex: 'episode', width: 70, render: (e) => <Tag>第 {e} 集</Tag> },
-                { title: '集级子标识', render: (_, r) => <Text code>{`${ctx.maCode}#E${String(r.episode).padStart(2, '0')}`}</Text> },
+                { title: '集级子标识', render: (_, r) => <Text code>{`${ctx.ccCode}#E${String(r.episode).padStart(2, '0')}`}</Text> },
                 { title: '该集哈希', dataIndex: 'hash_value', ellipsis: true },
                 {
                   title: '验真状态', width: 110, render: (_, r) => {
diff --git a/tcs-iptv/web-console/src/GovernancePanel.jsx b/tcs-iptv/web-console/src/GovernancePanel.jsx
index 1a938e1..6f7c89b 100644
--- a/tcs-iptv/web-console/src/GovernancePanel.jsx
+++ b/tcs-iptv/web-console/src/GovernancePanel.jsx
@@ -14,16 +14,16 @@ const nodeLabel = {
 }
 
 // 分账面板
-function SettlementPanel({ maCode }) {
+function SettlementPanel({ ccCode }) {
   const [sum, setSum] = useState(null)
   const [st, setSt] = useState(null)
   async function load() {
-    const s = await api.playbackSummary(maCode)
+    const s = await api.playbackSummary(ccCode)
     setSum(s.data?.data)
-    const r = await api.settlement(maCode, '2026-06')
+    const r = await api.settlement(ccCode, '2026-06')
     if (r.ok) setSt(r.data.data)
   }
-  useEffect(() => { load() }, [maCode])
+  useEffect(() => { load() }, [ccCode])
   if (!sum) return null
   return (
     <div>
@@ -49,9 +49,9 @@ function SettlementPanel({ maCode }) {
 }
 
 // 追责取证面板
-function AccountabilityPanel({ maCode }) {
+function AccountabilityPanel({ ccCode }) {
   const [rep, setRep] = useState(null)
-  useEffect(() => { api.accountability(maCode).then((r) => setRep(r.data?.data)) }, [maCode])
+  useEffect(() => { api.accountability(ccCode).then((r) => setRep(r.data?.data)) }, [ccCode])
   if (!rep) return null
   return (
     <div>
@@ -74,9 +74,9 @@ function AccountabilityPanel({ maCode }) {
 }
 
 // 确权举证面板
-function EvidencePanel({ maCode }) {
+function EvidencePanel({ ccCode }) {
   const [ev, setEv] = useState(null)
-  useEffect(() => { api.evidence(maCode).then((r) => setEv(r.data?.data)) }, [maCode])
+  useEffect(() => { api.evidence(ccCode).then((r) => setEv(r.data?.data)) }, [ccCode])
   if (!ev) return null
   return (
     <Card size="small" title="版权确权证据链">
@@ -94,7 +94,7 @@ function EvidencePanel({ maCode }) {
 }
 
 // 授权管理面板
-function AuthPanel({ maCode }) {
+function AuthPanel({ ccCode }) {
   const [form] = Form.useForm()
   const [checkResult, setCheckResult] = useState(null)
   async function grant() {
@@ -102,13 +102,13 @@ function AuthPanel({ maCode }) {
     const regions = v.regions ? v.regions.split(',').map((s) => s.trim()).filter(Boolean) : []
     const platforms = v.platforms ? v.platforms.split(',').map((s) => s.trim()).filter(Boolean) : []
     const expiry = v.expiry ? v.expiry.toISOString() : ''
-    const res = await api.authorize(maCode, regions, platforms, expiry)
+    const res = await api.authorize(ccCode, regions, platforms, expiry)
     if (res.ok) message.success('授权已登记')
     else message.error(res.data.message)
   }
   async function check() {
     const v = form.getFieldsValue()
-    const res = await api.authCheck(maCode, v.checkRegion || '', v.checkPlatform || '')
+    const res = await api.authCheck(ccCode, v.checkRegion || '', v.checkPlatform || '')
     setCheckResult(res.data?.data)
   }
   return (
@@ -134,13 +134,13 @@ function AuthPanel({ maCode }) {
   )
 }
 
-export default function GovernancePanel({ maCode }) {
+export default function GovernancePanel({ ccCode }) {
   return (
     <Tabs size="small" items={[
-      { key: 'settle', label: '💰 分账', children: <SettlementPanel maCode={maCode} /> },
-      { key: 'account', label: '⚖️ 追责取证', children: <AccountabilityPanel maCode={maCode} /> },
-      { key: 'evidence', label: '📜 确权举证', children: <EvidencePanel maCode={maCode} /> },
-      { key: 'auth', label: '🔑 授权管理', children: <AuthPanel maCode={maCode} /> },
+      { key: 'settle', label: '💰 分账', children: <SettlementPanel ccCode={ccCode} /> },
+      { key: 'account', label: '⚖️ 追责取证', children: <AccountabilityPanel ccCode={ccCode} /> },
+      { key: 'evidence', label: '📜 确权举证', children: <EvidencePanel ccCode={ccCode} /> },
+      { key: 'auth', label: '🔑 授权管理', children: <AuthPanel ccCode={ccCode} /> },
     ]} />
   )
 }
diff --git a/tcs-iptv/web-console/src/RoleDesk.jsx b/tcs-iptv/web-console/src/RoleDesk.jsx
index 12aa1bd..d9e7268 100644
--- a/tcs-iptv/web-console/src/RoleDesk.jsx
+++ b/tcs-iptv/web-console/src/RoleDesk.jsx
@@ -268,7 +268,7 @@ function LibraryDesk({ tick, onChanged }) {
   const [filter, setFilter] = useState('all')
   const [rows, setRows] = useState([])
   const [loading, setLoading] = useState(false)
-  const [detail, setDetail] = useState(null) // {maCode, mappings, episodes}
+  const [detail, setDetail] = useState(null) // {ccCode, mappings, episodes}
 
   async function load() {
     setLoading(true)
@@ -304,13 +304,13 @@ function LibraryDesk({ tick, onChanged }) {
     })
   }
 
-  function takedownEpisode(maCode, episode) {
+  function takedownEpisode(ccCode, episode) {
     Modal.confirm({
       title: `集级下架 · 第 ${episode} 集`,
-      content: `只下架《${maCode}#E${String(episode).padStart(2, '0')}》本集，整剧其他集继续流通。确认？`,
+      content: `只下架《${ccCode}#E${String(episode).padStart(2, '0')}》本集，整剧其他集继续流通。确认？`,
       okText: '下架本集', okType: 'danger', cancelText: '取消',
       onOk: async () => {
-        const res = await api.takedownEpisode(maCode, episode, '监管片库集级下架')
+        const res = await api.takedownEpisode(ccCode, episode, '监管片库集级下架')
         if (res.ok) {
           message.success(`第 ${episode} 集已下架`)
           await viewDetail(detail.content) // 刷新弹窗
@@ -326,8 +326,8 @@ function LibraryDesk({ tick, onChanged }) {
     else message.error(res.data.message || '恢复失败')
   }
 
-  async function restoreEpisode(maCode, episode) {
-    const res = await api.restoreEpisode(maCode, episode)
+  async function restoreEpisode(ccCode, episode) {
+    const res = await api.restoreEpisode(ccCode, episode)
     if (res.ok) {
       message.success('第 ' + episode + ' 集已恢复上架')
       await viewDetail(detail.content)
@@ -420,7 +420,7 @@ function LibraryDesk({ tick, onChanged }) {
             </Card>
           </>
             ) },
-            { key: 'gov', label: '权益与治理', children: <GovernancePanel maCode={detail.content.ma_code} /> },
+            { key: 'gov', label: '权益与治理', children: <GovernancePanel ccCode={detail.content.ma_code} /> },
           ]} />
         )}
       </Modal>
diff --git a/tcs-iptv/web-console/src/ScreenFusion.jsx b/tcs-iptv/web-console/src/ScreenFusion.jsx
index 3ffe959..2781713 100644
--- a/tcs-iptv/web-console/src/ScreenFusion.jsx
+++ b/tcs-iptv/web-console/src/ScreenFusion.jsx
@@ -32,14 +32,14 @@ function ScreenTags({ screens }) {
 
 // ============ 跨域解析网关（C.1/C.2）============
 function ResolvePanel() {
-  const [maCode, setMaCode] = useState('')
+  const [ccCode, setCcCode] = useState('')
   const [res, setRes] = useState(null)
   const [loading, setLoading] = useState(false)
 
   async function doResolve() {
-    if (!maCode) return message.warning('请输入 MA 码（支持集级子标识 #E03）')
+    if (!ccCode) return message.warning('请输入 MA 码（支持集级子标识 #E03）')
     setLoading(true)
-    const r = await api.resolve(maCode.trim())
+    const r = await api.resolve(ccCode.trim())
     setLoading(false)
     if (r.ok) setRes(r.data.data)
     else { setRes(null); message.error(r.data.message || '解析失败') }
@@ -50,7 +50,7 @@ function ResolvePanel() {
     <Card size="small" title={<Space><GlobalOutlined />MA 跨域解析网关 · 同一码三屏统一解析</Space>}>
       <Space.Compact style={{ width: '100%', maxWidth: 640 }}>
         <Input placeholder="如 MA.156.8531.6101/WD/20260000021 或 ...#E03"
-          value={maCode} onChange={(e) => setMaCode(e.target.value)} onPressEnter={doResolve} />
+          value={ccCode} onChange={(e) => setCcCode(e.target.value)} onPressEnter={doResolve} />
         <Button type="primary" loading={loading} onClick={doResolve}>解析</Button>
       </Space.Compact>
 
@@ -89,14 +89,14 @@ function ResolvePanel() {
 
 // ============ 扫码验真（B.2）============
 function ScanVerifyPanel() {
-  const [maCode, setMaCode] = useState('')
+  const [ccCode, setCcCode] = useState('')
   const [res, setRes] = useState(null)
   const [loading, setLoading] = useState(false)
 
   async function doScan() {
-    if (!maCode) return message.warning('请输入/扫描 MA 码')
+    if (!ccCode) return message.warning('请输入/扫描 MA 码')
     setLoading(true)
-    const r = await api.scanVerify(maCode.trim())
+    const r = await api.scanVerify(ccCode.trim())
     setLoading(false)
     if (r.ok) setRes(r.data.data)
     else { setRes(null); message.error(r.data.message || '验真失败') }
@@ -112,8 +112,8 @@ function ScanVerifyPanel() {
   return (
     <Card size="small" title={<Space><ScanOutlined />用户扫码验真 · 防盗版</Space>}>
       <Space.Compact style={{ width: '100%', maxWidth: 640 }}>
-        <Input placeholder="模拟扫码：粘贴 MA 码" value={maCode}
-          onChange={(e) => setMaCode(e.target.value)} onPressEnter={doScan} />
+        <Input placeholder="模拟扫码：粘贴 MA 码" value={ccCode}
+          onChange={(e) => setCcCode(e.target.value)} onPressEnter={doScan} />
         <Button type="primary" icon={<ScanOutlined />} loading={loading} onClick={doScan}>扫码验真</Button>
       </Space.Compact>
 
@@ -140,7 +140,7 @@ function ScanVerifyPanel() {
 
 // ============ 跨屏权益通兑（D.1）============
 function RightsPanel() {
-  const [maCode, setMaCode] = useState('')
+  const [ccCode, setCcCode] = useState('')
   const [userHash, setUserHash] = useState('user-demo-001')
   const [buyScreen, setBuyScreen] = useState('iptv')
   const [verifyScreen, setVerifyScreen] = useState('app')
@@ -148,14 +148,14 @@ function RightsPanel() {
   const [verifyRes, setVerifyRes] = useState(null)
 
   async function doBuy() {
-    if (!maCode) return message.warning('请输入 MA 码')
-    const r = await api.purchase(maCode.trim(), userHash, buyScreen)
+    if (!ccCode) return message.warning('请输入 MA 码')
+    const r = await api.purchase(ccCode.trim(), userHash, buyScreen)
     if (r.ok) { setBuyRes(r.data.data); message.success(`已在「${screenMeta[buyScreen].label}」购买`) }
     else message.error(r.data.message || '购买失败')
   }
   async function doVerify() {
-    if (!maCode) return message.warning('请输入 MA 码')
-    const r = await api.verifyRights(maCode.trim(), userHash, verifyScreen)
+    if (!ccCode) return message.warning('请输入 MA 码')
+    const r = await api.verifyRights(ccCode.trim(), userHash, verifyScreen)
     if (r.ok) setVerifyRes(r.data.data)
     else message.error(r.data.message || '核验失败')
   }
@@ -166,8 +166,8 @@ function RightsPanel() {
     <Card size="small" title={<Space><ShoppingOutlined />跨屏权益通兑 · 一次购买全屏通看</Space>}>
       <Space direction="vertical" style={{ width: '100%' }}>
         <Space wrap>
-          <Input addonBefore="MA 码" style={{ width: 380 }} value={maCode}
-            onChange={(e) => setMaCode(e.target.value)} placeholder="已发布的 MA 码" />
+          <Input addonBefore="MA 码" style={{ width: 380 }} value={ccCode}
+            onChange={(e) => setCcCode(e.target.value)} placeholder="已发布的 MA 码" />
           <Input addonBefore="用户" style={{ width: 220 }} value={userHash}
             onChange={(e) => setUserHash(e.target.value)} />
         </Space>
diff --git a/tcs-iptv/web-console/src/api.js b/tcs-iptv/web-console/src/api.js
index 1735b0e..f56b872 100644
--- a/tcs-iptv/web-console/src/api.js
+++ b/tcs-iptv/web-console/src/api.js
@@ -53,30 +53,30 @@ export const api = {
   publish: (body) => request('reviewer', 'POST', '/content/publish', body),
   inject: (body) => request('operator', 'POST', '/content/inject', body),
   // 监管功能
-  verify: (maCode, fileHash) => request('regulator', 'POST', '/content/verify', { ma_code: maCode, file_sha256: fileHash }),
-  mappings: (maCode) => request('regulator', 'GET', '/content/mappings?ma_code=' + encodeURIComponent(maCode)),
-  takedown: (maCode, reason) => request('regulator', 'POST', '/content/takedown', { ma_code: maCode, reason }),
-  takedownEpisode: (maCode, episode, reason) => request('regulator', 'POST', '/content/takedown-episode', { ma_code: maCode, episode, reason }),
-  restore: (maCode) => request('regulator', 'POST', '/content/restore', { ma_code: maCode }),
-  restoreEpisode: (maCode, episode) => request('regulator', 'POST', '/content/restore-episode', { ma_code: maCode, episode }),
+  verify: (ccCode, fileHash) => request('regulator', 'POST', '/content/verify', { ma_code: ccCode, file_sha256: fileHash }),
+  mappings: (ccCode) => request('regulator', 'GET', '/content/mappings?ma_code=' + encodeURIComponent(ccCode)),
+  takedown: (ccCode, reason) => request('regulator', 'POST', '/content/takedown', { ma_code: ccCode, reason }),
+  takedownEpisode: (ccCode, episode, reason) => request('regulator', 'POST', '/content/takedown-episode', { ma_code: ccCode, episode, reason }),
+  restore: (ccCode) => request('regulator', 'POST', '/content/restore', { ma_code: ccCode }),
+  restoreEpisode: (ccCode, episode) => request('regulator', 'POST', '/content/restore-episode', { ma_code: ccCode, episode }),
   // 集级粒度（一剧一码 + 集级哈希）
-  episodes: (maCode) => request('regulator', 'GET', '/content/episodes?ma_code=' + encodeURIComponent(maCode)),
-  verifyEpisode: (maCode, episode, fileHash) => request('regulator', 'POST', '/content/verify-episode', { ma_code: maCode, episode, file_sha256: fileHash }),
+  episodes: (ccCode) => request('regulator', 'GET', '/content/episodes?ma_code=' + encodeURIComponent(ccCode)),
+  verifyEpisode: (ccCode, episode, fileHash) => request('regulator', 'POST', '/content/verify-episode', { ma_code: ccCode, episode, file_sha256: fileHash }),
   // 工作队列（多角色工作台）
   reviews: (role, status) => request(role, 'GET', '/content/reviews?status=' + status),
   list: (role, status) => request(role, 'GET', '/content/list?status=' + status),
   // 二期：分账/追责/确权/授权/跨省/追更/回传
   playback: (platformId, batch) => request('operator', 'POST', '/data/playback', { platform_id: platformId, batch }),
-  playbackSummary: (maCode) => request('regulator', 'GET', '/data/playback-summary?ma_code=' + encodeURIComponent(maCode)),
-  settlement: (maCode, period) => request('regulator', 'POST', '/settlement/compute', { ma_code: maCode, period }),
-  accountability: (maCode) => request('regulator', 'GET', '/content/accountability?ma_code=' + encodeURIComponent(maCode)),
-  evidence: (maCode) => request('regulator', 'GET', '/content/evidence?ma_code=' + encodeURIComponent(maCode)),
-  authorize: (maCode, regions, platforms, expiryAt) => request('regulator', 'POST', '/content/authorize', { ma_code: maCode, regions, platforms, expiry_at: expiryAt }),
-  authCheck: (maCode, region, platform) => request('regulator', 'POST', '/content/auth-check', { ma_code: maCode, region, platform }),
-  crossProvince: (maCode, fileHash, province) => request('regulator', 'POST', '/content/cross-province', { ma_code: maCode, file_sha256: fileHash, province }),
+  playbackSummary: (ccCode) => request('regulator', 'GET', '/data/playback-summary?ma_code=' + encodeURIComponent(ccCode)),
+  settlement: (ccCode, period) => request('regulator', 'POST', '/settlement/compute', { ma_code: ccCode, period }),
+  accountability: (ccCode) => request('regulator', 'GET', '/content/accountability?ma_code=' + encodeURIComponent(ccCode)),
+  evidence: (ccCode) => request('regulator', 'GET', '/content/evidence?ma_code=' + encodeURIComponent(ccCode)),
+  authorize: (ccCode, regions, platforms, expiryAt) => request('regulator', 'POST', '/content/authorize', { ma_code: ccCode, regions, platforms, expiry_at: expiryAt }),
+  authCheck: (ccCode, region, platform) => request('regulator', 'POST', '/content/auth-check', { ma_code: ccCode, region, platform }),
+  crossProvince: (ccCode, fileHash, province) => request('regulator', 'POST', '/content/cross-province', { ma_code: ccCode, file_sha256: fileHash, province }),
   // 四期：大小屏融合（跨域解析/扫码验真/跨屏权益）
-  resolve: (maCode) => request('regulator', 'GET', '/content/resolve?ma_code=' + encodeURIComponent(maCode)),
-  scanVerify: (maCode) => request('operator', 'POST', '/content/scan-verify', { ma_code: maCode }),
-  purchase: (maCode, userHash, screen) => request('operator', 'POST', '/rights/purchase', { ma_code: maCode, user_hash: userHash, screen }),
-  verifyRights: (maCode, userHash, screen) => request('operator', 'POST', '/rights/verify', { ma_code: maCode, user_hash: userHash, screen }),
+  resolve: (ccCode) => request('regulator', 'GET', '/content/resolve?ma_code=' + encodeURIComponent(ccCode)),
+  scanVerify: (ccCode) => request('operator', 'POST', '/content/scan-verify', { ma_code: ccCode }),
+  purchase: (ccCode, userHash, screen) => request('operator', 'POST', '/rights/purchase', { ma_code: ccCode, user_hash: userHash, screen }),
+  verifyRights: (ccCode, userHash, screen) => request('operator', 'POST', '/rights/verify', { ma_code: ccCode, user_hash: userHash, screen }),
 }
diff --git a/方案对照报告.md b/方案对照报告.md
index 47851f8..b7a0d2b 100644
--- a/方案对照报告.md
+++ b/方案对照报告.md
@@ -1,7 +1,7 @@
 # IPTV 系统融合 MA 码方案 — 代码实现对照报告
 
 > 生成日期：2026-06-30
-> 对照文档：`IPTV系统融合MA码方案介绍.md`
+> 对照文档：`IPTV系统融合CC码方案介绍.md`
 > 代码仓库：`tcs-iptv/`
 > 总体匹配度：**100%**（方案全部要求已实现），部分功能**超出方案要求**
 
@@ -33,7 +33,7 @@
 
 | 方案要求 | 代码实现 | 状态 |
 |---------|---------|------|
-| MA 生成 | `macode.Generator.Allocate()` 按类目从号段原子分配 | ✅ 满足 |
+| MA 生成 | `cccode.Generator.Allocate()` 按类目从号段原子分配 | ✅ 满足 |
 | Hash 登记 | `chain.IssueMA` 强绑定 + `chain.RegisterHashBinding` 追加绑定 | ✅ 满足 |
 | 标识查询 — 根据 MA 查询 | `GET /content/mappings` + `GET /catalog/query-by-ma` | ✅ 满足 |
 | 标识查询 — 根据 Hash 查询 | `GET /content/query-by-hash` + `GET /catalog/query-by-hash` | ✅ 满足 |
@@ -95,7 +95,7 @@
 
 | 方案要求 | 代码实现 | 状态 |
 |---------|---------|------|
-| 生成 MA 统一标识 | `macode.Generator.Allocate` → `chain.IssueMA` | ✅ 满足 |
+| 生成 MA 统一标识 | `cccode.Generator.Allocate` → `chain.IssueMA` | ✅ 满足 |
 | 生成或登记内容 Hash | `IssueMA` 强绑定 FileHash + PerceptualHash + 集级哈希 | ✅ 满足 |
 | 建立 MA 与 Hash 的映射关系 | `hash_binding` 表 + `hashIndex` 内存索引 | ✅ 满足 |
 | 建立 MA 与片库文件 ID 的映射关系 | `RegisterMapping(PartyReviewer, mediaAssetID)` | ✅ 满足 |
@@ -133,7 +133,7 @@
 
 | 方案要求 | 代码实现 | 状态 |
 |---------|---------|------|
-| 引入 MA 统一标识和 Hash 内容指纹 | `macode.Generator` + `chain.IssueMA` + `hash_binding` | ✅ 满足 |
+| 引入 MA 统一标识和 Hash 内容指纹 | `cccode.Generator` + `chain.IssueMA` + `hash_binding` | ✅ 满足 |
 | 建立内容统一身份体系 | `ContentTwinID` 内容双锚 ID + MA 码 1:1 强绑定 | ✅ 满足 |
 | 建设标识服务平台 | `cmd/api-svc/main.go` 完整服务 | ✅ 满足 |
 | 建设目录库 | `internal/catalog` + `cmd/catalog-svc` 独立服务 | ✅ 满足 |
@@ -155,7 +155,7 @@
 
 | 方案要求 | 代码实现 | 状态 |
 |---------|---------|------|
-| 制定全国统一 MA 编码规则 | `macode.Segment` 号段管理 + `RegisterSegment` + `ParseMACode` 解析 | ✅ 满足 |
+| 制定全国统一 MA 编码规则 | `cccode.Segment` 号段管理 + `RegisterSegment` + `ParseCCCode` 解析 | ✅ 满足 |
 | 建设全国目录中心 | `internal/nationalcatalog` 包 + `NationalCatalog` 服务 | ✅ 满足 |
 | 省级目录库 ↔ 全国目录中心数据同步机制 | `SyncService` 全量/增量同步 + `NationalCatalog.SyncFromProvince` | ✅ 满足 |
 | 各省内容编码与全国统一 MA 映射同步 | `SyncSource`/`SyncSink` 接口 + 省级数据聚合 | ✅ 满足 |
@@ -187,7 +187,7 @@
 
 | 超出项 | 代码实现 | 说明 |
 |--------|---------|------|
-| **跨域解析网关（大小屏融合）** | `Service.Resolve` + `ParseMACode` 六段式解析 | 方案未提及 IPTV/OTT/APP 跨屏身份互通，已实现统一解析 |
+| **跨域解析网关（大小屏融合）** | `Service.Resolve` + `ParseCCCode` 六段式解析 | 方案未提及 IPTV/OTT/APP 跨屏身份互通，已实现统一解析 |
 | **扫码验真** | `Service.ScanVerify` | 方案未提及用户侧扫码验真防盗版，已实现 |
 | **跨屏权益通兑** | `Service.RecordPurchase` + `Service.VerifyCrossScreenRights` | 方案未提及大小屏购买通兑，已实现"一屏购买全屏通看" |
 | **感知哈希侵权比对** | `Service.MatchInfringement` 汉明距离比对 | 方案仅提及"内容查重"，已实现感知哈希相似度检索 |
@@ -225,7 +225,7 @@
 | `internal/sync/` | 标识同步服务 | 标识服务 |
 | `internal/nationalcatalog/` | 全国目录中心 | 第三阶段 |
 | `internal/monitor/` | Prometheus 监控 | 系统管理 |
-| `internal/macode/` | MA 码生成器 | 标识服务 |
+| `internal/cccode/` | MA 码生成器 | 标识服务 |
 | `internal/provenance/` | 全链路存证 | 验真服务 + 系统管理 |
 | `internal/playback/` | 播放数据存储与分账 | 第四阶段 |
 | `internal/hash/` | 哈希工具（Merkle 树、感知哈希） | 标识服务 |
@@ -283,4 +283,4 @@
 | 第四阶段 | 10 项要求 | 10 项全部实现 | 100% |
 | **超出项** | — | **20 项超出实现** | — |
 
-**总体评价**：代码实现完整覆盖了 `IPTV系统融合MA码方案介绍.md` 中定义的全部功能模块和四个建设阶段，并在跨域解析、扫码验真、跨屏权益、侵权比对、版权确权、责任界定、授权管理、CDN注入校验、终端抽检、播放分账、RBAC权限矩阵、同步冲突策略、Grafana监控等方面**超出方案要求**。
+**总体评价**：代码实现完整覆盖了 `IPTV系统融合CC码方案介绍.md` 中定义的全部功能模块和四个建设阶段，并在跨域解析、扫码验真、跨屏权益、侵权比对、版权确权、责任界定、授权管理、CDN注入校验、终端抽检、播放分账、RBAC权限矩阵、同步冲突策略、Grafana监控等方面**超出方案要求**。
diff --git a/系统建设报价方案.md b/系统建设报价方案.md
index 3f12557..643a840 100644
--- a/系统建设报价方案.md
+++ b/系统建设报价方案.md
@@ -1,7 +1,7 @@
 # IPTV 系统融合 MA 码 — 系统建设报价方案
 
 > 编制日期：2026-06-30
-> 依据：`IPTV系统融合MA码方案介绍.md` + `方案对照报告.md`（代码实现已 100% 匹配方案）
+> 依据：`IPTV系统融合CC码方案介绍.md` + `方案对照报告.md`（代码实现已 100% 匹配方案）
 > 报价币种：人民币（万元）
 
 ---
@@ -28,7 +28,7 @@
 
 | 模块 | 子功能 | 代码实现 | 人月 | 金额（万元） |
 |------|--------|---------|------|-------------|
-| **标识服务模块** | MA 生成 + Hash 登记 | `macode.Generator` + `chain.IssueMA` | 2 | 8 |
+| **标识服务模块** | MA 生成 + Hash 登记 | `cccode.Generator` + `chain.IssueMA` | 2 | 8 |
 | | 四维度标识查询 | `QueryByMA/Hash/ProvincialCode/LibraryFileID` | 1.5 | 6 |
 | | 标识映射管理 | `RegisterMapping` 三方编码映射 | 1 | 4 |
 | | 目录库写入与查询 | `chain.Client` + `internal/catalog` | 1 | 4 |
@@ -131,8 +131,8 @@
 
 | 模块 | 子功能 | 代码实现 | 人月 | 金额（万元） |
 |------|--------|---------|------|-------------|
-| **全国 MA 编码体系** | 全国号段规划与分配 | `macode.Segment` 多省号段管理 | 2 | 8 |
-| | MA 码解析网关 | `ParseMACode` 六段式解析 | 1 | 4 |
+| **全国 MA 编码体系** | 全国号段规划与分配 | `cccode.Segment` 多省号段管理 | 2 | 8 |
+| | MA 码解析网关 | `ParseCCCode` 六段式解析 | 1 | 4 |
 | | 编码规则国标对接 | 与 GB/T 33915 对齐 | 1.5 | 6 |
 | **大小屏融合（四期）** | 跨域解析网关 | `Resolve` IPTV/OTT/APP 跨屏 | 1.5 | 6 |
 | | 扫码验真 | `ScanVerify` 用户侧防盗版 | 1 | 4 |