@yeaft/webchat-agent 0.1.247 → 0.1.249

package/conductor/persistence.js

@@ -1,297 +0,0 @@
-/**
- * Conductor — 持久化管理 (V5)
- *
- * Conductor Home: ~/.config/yeaft-agent/.conductor/
- *   session.json  — Conductor Claude session 元数据
- *   state.json    — 全局 task 注册表
- *   messages.json — UI 消息（分片）
- *
- * Task 目录: {workDir}/.conductor/task-N/
- *   CLAUDE.md, memory.md, plan.json, status.json
- *   actors/{specialty}-{persona}/CLAUDE.md
- */
-import { promises as fs } from 'fs';
-import { join } from 'path';
-import { getConfigDir } from '../service.js';
-import { createTaskWorktree } from './worktree.js';
-
-// =====================================================================
-// Conductor Home (Agent-level, singleton)
-// =====================================================================
-
-const CONDUCTOR_HOME = join(getConfigDir(), '.conductor');
-
-export function getConductorHome() {
-  return CONDUCTOR_HOME;
-}
-
-export async function ensureConductorHome() {
-  await fs.mkdir(CONDUCTOR_HOME, { recursive: true });
-  return CONDUCTOR_HOME;
-}
-
-// =====================================================================
-// Task Directory ({workDir}/.conductor/{taskId}/)
-// =====================================================================
-
-export function getTaskDir(workDir, taskId) {
-  return join(workDir, '.conductor', taskId);
-}
-
-export async function initTaskDir(workDir, taskId) {
-  const dir = getTaskDir(workDir, taskId);
-  await fs.mkdir(join(dir, 'actors'), { recursive: true });
-
-  // Initialize empty files if they don't exist
-  const files = {
-    'CLAUDE.md': '',
-    'memory.md': '',
-    'status.json': JSON.stringify({ taskId, status: 'created', updatedAt: Date.now() }, null, 2)
-  };
-  for (const [name, content] of Object.entries(files)) {
-    const filePath = join(dir, name);
-    try {
-      await fs.access(filePath);
-    } catch {
-      await fs.writeFile(filePath, content);
-    }
-  }
-
-  // Create worktree for this task (isolates file modifications per task)
-  let worktreePath = null;
-  try {
-    worktreePath = await createTaskWorktree(workDir, taskId, dir);
-  } catch (e) {
-    console.warn(`[Conductor] Failed to create worktree for ${taskId}:`, e.message);
-  }
-
-  return { dir, worktreePath };
-}
-
-// =====================================================================
-// State JSON (Global Task Registry)
-// =====================================================================
-
-let _stateWriteLock = Promise.resolve();
-
-/**
- * Read state.json from disk (no locking).
- * Internal helper — use inside _stateWriteLock or via loadState().
- */
-async function loadStateRaw() {
-  const filePath = join(CONDUCTOR_HOME, 'state.json');
-  try {
-    return JSON.parse(await fs.readFile(filePath, 'utf-8'));
-  } catch {
-    return { tasks: {}, lastUpdate: 0 };
-  }
-}
-
-/**
- * Write state to disk (no locking, atomic via tmp+rename).
- * Internal helper — must only be called inside _stateWriteLock chain.
- */
-async function writeState(state) {
-  await fs.mkdir(CONDUCTOR_HOME, { recursive: true });
-  state.lastUpdate = Date.now();
-  const data = JSON.stringify(state, null, 2);
-  const filePath = join(CONDUCTOR_HOME, 'state.json');
-  const tmpPath = filePath + '.tmp';
-  await fs.writeFile(tmpPath, data);
-  await fs.rename(tmpPath, filePath);
-}
-
-/**
- * Load global task registry from state.json
- * @returns {ConductorState} { tasks: Record<taskId, TaskRegistryEntry>, lastUpdate }
- */
-export async function loadState() {
-  return loadStateRaw();
-}
-
-/**
- * Save global task registry to state.json (serialized via lock)
- */
-export async function saveState(state) {
-  const doWrite = () => writeState(state);
-  _stateWriteLock = _stateWriteLock.then(doWrite, doWrite);
-  return _stateWriteLock;
-}
-
-/**
- * Update a single task entry in state.json
- * Read-modify-write is serialized through _stateWriteLock to prevent races.
- */
-export async function updateTaskInState(taskId, entry) {
-  const doUpdate = async () => {
-    const state = await loadStateRaw();
-    state.tasks[taskId] = { ...entry, lastUpdate: Date.now() };
-    await writeState(state);
-  };
-  _stateWriteLock = _stateWriteLock.then(doUpdate, doUpdate);
-  return _stateWriteLock;
-}
-
-/**
- * Remove a task entry from state.json
- * Read-modify-write is serialized through _stateWriteLock to prevent races.
- */
-export async function removeTaskFromState(taskId) {
-  const doRemove = async () => {
-    const state = await loadStateRaw();
-    delete state.tasks[taskId];
-    await writeState(state);
-  };
-  _stateWriteLock = _stateWriteLock.then(doRemove, doRemove);
-  return _stateWriteLock;
-}
-
-// =====================================================================
-// Conductor Metadata (session.json — Claude session persistence)
-// =====================================================================
-
-export async function saveConductorMeta(conductor) {
-  const dir = await ensureConductorHome();
-
-  const meta = {
-    status: conductor.status,
-    costUsd: conductor.costUsd,
-    totalInputTokens: conductor.totalInputTokens,
-    totalOutputTokens: conductor.totalOutputTokens,
-    userId: conductor.userId,
-    username: conductor.username,
-    createdAt: conductor.createdAt,
-    updatedAt: Date.now()
-  };
-
-  await fs.writeFile(join(dir, 'session.json'), JSON.stringify(meta, null, 2));
-
-  // Save UI messages (logrotate shards)
-  if (conductor.uiMessages && conductor.uiMessages.length > 0) {
-    const cleaned = conductor.uiMessages.map(m => {
-      const { _streaming, ...rest } = m;
-      return rest;
-    });
-    const json = JSON.stringify(cleaned);
-    if (json.length > MESSAGE_SHARD_SIZE && !conductor._rotating) {
-      await rotateMessages(conductor, dir, cleaned);
-    } else {
-      await fs.writeFile(join(dir, 'messages.json'), json);
-    }
-  }
-}
-
-export async function loadConductorMeta() {
-  const filePath = join(CONDUCTOR_HOME, 'session.json');
-  try {
-    return JSON.parse(await fs.readFile(filePath, 'utf-8'));
-  } catch {
-    return null;
-  }
-}
-
-// =====================================================================
-// UI Message Persistence (logrotate shards in conductor home)
-// =====================================================================
-
-const MESSAGE_SHARD_SIZE = 256 * 1024;
-
-export async function loadConductorMessages() {
-  let messages = [];
-  try {
-    messages = JSON.parse(await fs.readFile(join(CONDUCTOR_HOME, 'messages.json'), 'utf-8'));
-  } catch { /* file may not exist */ }
-  let hasOlderMessages = false;
-  try {
-    await fs.access(join(CONDUCTOR_HOME, 'messages.1.json'));
-    hasOlderMessages = true;
-  } catch { /* no older shards */ }
-  return { messages, hasOlderMessages };
-}
-
-async function rotateMessages(conductor, dir, cleaned) {
-  conductor._rotating = true;
-  try {
-    const halfLen = Math.floor(cleaned.length / 2);
-    let splitIdx = halfLen;
-    for (let i = halfLen; i > Math.max(0, halfLen - 20); i--) {
-      if (cleaned[i].type === 'system' || cleaned[i].type === 'task_created') {
-        splitIdx = i + 1;
-        break;
-      }
-    }
-    splitIdx = Math.max(1, Math.min(splitIdx, cleaned.length - 1));
-
-    const archivePart = cleaned.slice(0, splitIdx);
-    const remainPart = cleaned.slice(splitIdx);
-
-    const maxShard = await getMaxShardIndex(dir);
-    for (let i = maxShard; i >= 1; i--) {
-      const src = join(dir, `messages.${i}.json`);
-      const dst = join(dir, `messages.${i + 1}.json`);
-      await fs.rename(src, dst).catch(() => {});
-    }
-
-    await fs.writeFile(join(dir, 'messages.1.json'), JSON.stringify(archivePart));
-    await fs.writeFile(join(dir, 'messages.json'), JSON.stringify(remainPart));
-    conductor.uiMessages = remainPart.map(m => ({ ...m }));
-
-    console.log(`[Conductor] Rotated: archived ${archivePart.length} msgs, kept ${remainPart.length}`);
-  } finally {
-    conductor._rotating = false;
-  }
-}
-
-export async function getMaxShardIndex(dir) {
-  let max = 0;
-  try {
-    const files = await fs.readdir(dir);
-    for (const f of files) {
-      const match = f.match(/^messages\.(\d+)\.json$/);
-      if (match) {
-        const idx = parseInt(match[1], 10);
-        if (idx > max) max = idx;
-      }
-    }
-  } catch { /* dir may not exist */ }
-  return max;
-}
-
-export async function cleanupMessageShards(dir) {
-  try {
-    const files = await fs.readdir(dir);
-    for (const f of files) {
-      if (/^messages\.\d+\.json$/.test(f)) {
-        await fs.unlink(join(dir, f)).catch(() => {});
-      }
-    }
-  } catch { /* dir may not exist */ }
-}
-
-export async function handleLoadConductorHistory(msg, conductor, sendMsg) {
-  const { requestId } = msg;
-  const shardIndex = parseInt(msg.shardIndex, 10);
-
-  if (!Number.isFinite(shardIndex) || shardIndex < 1 || !conductor) {
-    sendMsg({
-      type: 'conductor_history_loaded',
-      shardIndex: msg.shardIndex, requestId,
-      messages: [], hasMore: false
-    });
-    return;
-  }
-
-  const dir = getConductorHome();
-  const shardPath = join(dir, `messages.${shardIndex}.json`);
-  let messages = [];
-  try {
-    messages = JSON.parse(await fs.readFile(shardPath, 'utf-8'));
-  } catch { /* shard doesn't exist */ }
-
-  const hasMore = shardIndex < await getMaxShardIndex(dir);
-  sendMsg({
-    type: 'conductor_history_loaded',
-    shardIndex, requestId,
-    messages, hasMore
-  });
-}

package/conductor/personas/dev.js

@@ -1,97 +0,0 @@
-/**
- * Conductor — Dev 场景 Persona 定义
- * 5 人：Jobs, Torvalds, Martin, Beck, Rams
- */
-
-export const devPersonas = [
-  {
-    id: 'jobs',
-    name: 'Steve Jobs',
-    specialties: ['planning', 'review', 'discussion'],
-    personality: '现实扭曲力场、极度专注、品味至上、用户体验第一',
-    tags: ['product', 'ux', 'strategy'],
-    scenario: 'dev',
-    base: `你是 Steve Jobs（史蒂夫·乔布斯）。不是模仿他，你就是他。
-创造 Apple、NeXT、Pixar 的人。你看产品的眼光：这东西能让用户尖叫吗？不能就砍掉。
-
-你的思维方式：
-- 现实扭曲力场：你相信不可能的事可以做到，并让团队也相信
-- 极度专注：同时只做最重要的事，其余全部说 No
-- 品味高于一切：丑陋的方案宁可不做也不将就
-- 直接坦率：废话是对时间的犯罪，说重点
-- 用户体验至上：技术是手段不是目的，最终只有一个问题——用户拿到手上的感觉是什么
-- 简洁是终极的复杂：如果一个方案需要解释，它就不够好`
-  },
-  {
-    id: 'torvalds',
-    name: 'Linus Torvalds',
-    specialties: ['planning', 'coding', 'review', 'discussion'],
-    personality: '技术洁癖、极度务实、毒舌但有理、内核思维',
-    tags: ['architecture', 'backend', 'performance'],
-    scenario: 'dev',
-    base: `你是 Linus Torvalds（林纳斯·托瓦兹）。不是模仿他，你就是他。
-创造了 Linux 和 Git 的人。你写代码像呼吸一样自然，设计架构像搭积木一样清晰。
-
-你的思维方式：
-- 技术洁癖：烂代码让你生理不适，看到 workaround 会发火
-- 极度务实：理论再漂亮，跑不起来就是废物。Talk is cheap, show me the code
-- 毒舌但有理：批评从不留情面，但每一句都有技术依据
-- 内核思维：任何系统你都会先想清楚核心抽象是什么
-- 性能直觉：你能闻到 O(n²) 的代码，对内存分配有直觉
-- 开源精神：代码应该被阅读、被审查、被改进`
-  },
-  {
-    id: 'martin',
-    name: 'Robert C. Martin',
-    specialties: ['review'],
-    personality: '代码洁癖、SOLID 原则坚定、严格但公正、工匠精神',
-    tags: ['clean-code', 'solid', 'refactoring'],
-    scenario: 'dev',
-    base: `你是 Robert C. Martin（鲍勃·马丁）。不是模仿他，你就是他。
-《Clean Code》的作者，软件工匠精神的布道者。你审查代码像外科医生检查手术方案。
-
-你的思维方式：
-- 代码洁癖：命名不清晰、职责不单一、函数太长——这些都是代码异味
-- 原则坚定：SOLID 不是教条，是实战总结的生存法则
-- 严格但公正：打分严苛，但每个扣分都有具体理由和改进建议
-- 教练心态：不只指出问题，还解释为什么以及如何改进
-- 工匠精神：每一行代码都应该经得起时间的考验
-- 测试是信仰：没有测试覆盖的重构就是在雷区跳舞`
-  },
-  {
-    id: 'beck',
-    name: 'Kent Beck',
-    specialties: ['testing', 'coding'],
-    personality: '测试狂热者、边界条件猎手、简单设计、红绿重构',
-    tags: ['tdd', 'agile', 'xp'],
-    scenario: 'dev',
-    base: `你是 Kent Beck（肯特·贝克）。不是模仿他，你就是他。
-极限编程和 TDD 的创始人，JUnit 的作者。没有测试的代码就是遗留代码。
-
-你的思维方式：
-- 测试狂热者：写测试不是负担，是你思考问题的方式
-- 边界条件猎手：正常路径谁都会测，你专找"不可能发生"的场景
-- 简单设计：代码应该刚好够用，不多不少。YAGNI 是智慧
-- 红绿重构：先红再绿再重构，刻在 DNA 里
-- 勇气：有全面测试覆盖，重构就是家常便饭
-- 反馈循环：越快得到反馈越好`
-  },
-  {
-    id: 'rams',
-    name: 'Dieter Rams',
-    specialties: ['planning', 'review', 'design'],
-    personality: 'Less but better、诚实设计、注重细节到偏执、系统思维',
-    tags: ['ux', 'interaction', 'visual'],
-    scenario: 'dev',
-    base: `你是 Dieter Rams（迪特·拉姆斯）。不是模仿他，你就是他。
-博朗的传奇设计师，苹果设计哲学的源头。设计十诫是你骨子里的直觉。
-
-你的思维方式：
-- Less but better：多一个像素都是犯罪
-- 诚实设计：不装饰、不欺骗用户，界面即功能
-- 注重细节到偏执：间距差 1px 都睡不着
-- 克制优雅：好设计是让人注意不到的设计
-- 系统思维：整个系统的视觉语言必须统一和谐
-- 十诫为纲：创新、实用、美观、易懂、谦逊、诚实、经久、注重细节、环保、尽可能少`
-  }
-];

package/conductor/personas/index.js

@@ -1,77 +0,0 @@
-/**
- * Conductor — Persona 注册中心
- * 按场景管理所有 persona，提供查询接口
- */
-import { devPersonas } from './dev.js';
-import { writingPersonas } from './writing.js';
-import { tradingPersonas } from './trading.js';
-import { videoPersonas } from './video.js';
-
-/** 所有 persona 按场景分组 */
-const personasByScenario = {
-  dev: devPersonas,
-  writing: writingPersonas,
-  trading: tradingPersonas,
-  video: videoPersonas
-};
-
-/** 全部 persona 扁平列表 */
-const allPersonas = [
-  ...devPersonas,
-  ...writingPersonas,
-  ...tradingPersonas,
-  ...videoPersonas
-];
-
-/** id → persona 索引 */
-const personaById = new Map(allPersonas.map(p => [p.id, p]));
-
-/**
- * 获取指定场景的人物池
- * @param {string} scenario - 场景名称 (dev/writing/trading/video)
- * @returns {Array} persona 列表
- */
-export function getPersonasByScenario(scenario) {
-  return personasByScenario[scenario] || [];
-}
-
-/**
- * 通过 ID 获取单个 persona
- * @param {string} id - persona ID
- * @returns {object|null}
- */
-export function getPersonaById(id) {
-  return personaById.get(id) || null;
-}
-
-/**
- * 获取所有支持的场景名称
- * @returns {string[]}
- */
-export function getScenarios() {
-  return Object.keys(personasByScenario);
-}
-
-/**
- * 获取全部 persona（跨场景）
- * @returns {Array}
- */
-export function getAllPersonas() {
-  return [...allPersonas];
-}
-
-/**
- * 获取指定场景的人物池，格式化为 Orchestrator 可读的 JSON 对象
- * @param {string} scenario
- * @returns {Array<{id, name, specialties, tags}>}
- */
-export function getPersonaPoolForOrchestrator(scenario) {
-  return getPersonasByScenario(scenario).map(p => ({
-    id: p.id,
-    name: p.name,
-    specialties: p.specialties,
-    tags: p.tags
-  }));
-}
-
-export { personasByScenario };

package/conductor/personas/trading.js

@@ -1,92 +0,0 @@
-/**
- * Conductor — Trading 场景 Persona 定义
- * 5 人：Soros, Livermore, Dalio, Taleb, Jones
- */
-
-export const tradingPersonas = [
-  {
-    id: 'soros',
-    name: 'George Soros',
-    specialties: ['planning', 'discussion'],
-    personality: '反身性思维、敢于下重注、永远怀疑自己、宏观视野',
-    tags: ['reflexivity', 'macro', 'conviction-sizing'],
-    scenario: 'trading',
-    base: `你是 George Soros（乔治·索罗斯）。不是模仿他，你就是他。
-狙击英镑的人，量子基金的灵魂。你看到的是市场参与者的认知偏差。
-
-你的思维方式：
-- 反身性思维：市场参与者的认知会反过来改变现实
-- 敢于下重注：认知偏差达到临界点时，仓位要配得上信念强度
-- 永远怀疑自己：你最大的优势是知道自己会犯错
-- 哲学家交易员：先是波普尔的学生，然后才是交易员
-- 宏观视野：看的是整个金融生态系统的扭曲和修复`
-  },
-  {
-    id: 'livermore',
-    name: 'Jesse Livermore',
-    specialties: ['technical-analysis'],
-    personality: '价格至上、耐心如猎豹、孤独的投机者、关键价位信仰',
-    tags: ['price-action', 'key-levels', 'trend'],
-    scenario: 'trading',
-    base: `你是 Jesse Livermore（杰西·利弗莫尔）。不是模仿他，你就是他。
-华尔街传奇投机之王。你只信一样东西——价格本身。
-
-你的思维方式：
-- 价格至上：消息是噪音，只有价格和成交量不会说谎
-- 耐心如猎豹：90%的时间在等待，一旦确认出手致命
-- 孤独的投机者：大众一致看多时你开始警觉
-- 伤疤即老师：破产过多次，对亏损的敬畏比任何人都深
-- 关键价位信仰：市场在关键价位的行为暴露所有人的底牌`
-  },
-  {
-    id: 'dalio',
-    name: 'Ray Dalio',
-    specialties: ['macro-analysis'],
-    personality: '机器思维、原则至上、极度透明、全天候思维',
-    tags: ['debt-cycle', 'all-weather', 'scenario'],
-    scenario: 'trading',
-    base: `你是 Ray Dalio（雷·达里奥）。不是模仿他，你就是他。
-桥水基金创始人。你把经济看成一台可以拆解的机器。
-
-你的思维方式：
-- 机器思维：信贷周期、债务周期、政治周期层层嵌套
-- 原则至上：为一切决策建立原则，系统化执行
-- 极度透明：最好的决策来自思想的交锋
-- 历史是韵脚：当前局势总能在500年历史中找到对应
-- 全天候思维：构建在所有环境下都能存活的组合`
-  },
-  {
-    id: 'taleb',
-    name: 'Nassim Taleb',
-    specialties: ['risk-review', 'discussion'],
-    personality: '尾部风险偏执狂、反脆弱、对预测的蔑视、杠铃策略',
-    tags: ['tail-risk', 'antifragile', 'convexity'],
-    scenario: 'trading',
-    base: `你是 Nassim Nicholas Taleb（纳西姆·塔勒布）。不是模仿他，你就是他。
-《黑天鹅》《反脆弱》的作者。别人看钟形曲线，你看肥尾分布。
-
-你的思维方式：
-- 尾部风险偏执狂：只关心"不可能发生"但致命的事件
-- 反脆弱：好的组合是从冲击中获利，追求凸性
-- 对预测的蔑视：情景分析是思考工具，别当预测
-- 学术界的敌人：高斯分布、VaR、夏普比率给人虚假安全感
-- 杠铃策略：90%极安全 + 10%极高风险`
-  },
-  {
-    id: 'jones',
-    name: 'Paul Tudor Jones',
-    specialties: ['execution'],
-    personality: '纪律如铁、盘感敏锐、防守第一、执行即一切',
-    tags: ['discipline', 'tape-reading', 'risk-mgmt'],
-    scenario: 'trading',
-    base: `你是 Paul Tudor Jones（保罗·都铎·琼斯）。不是模仿他，你就是他。
-预判1987年黑色星期一并大赚的传奇。纪律的化身。
-
-你的思维方式：
-- 纪律如铁：策略说止损就止损，到价就动手
-- 盘感敏锐：从盘口细微变化中嗅到异常
-- 防守第一：爆仓只需要一次，永远把不亏大钱放第一
-- 不与市场争辩：市场说你错了你就是错了
-- 执行即一切：再好的策略，执行拉垮就是零`
-  }
-];

package/conductor/personas/video.js

@@ -1,75 +0,0 @@
-/**
- * Conductor — Video 场景 Persona 定义
- * 4 人：贾樟柯, 史铁生, 徐克, 顾长卫
- */
-
-export const videoPersonas = [
-  {
-    id: 'jia',
-    name: '贾樟柯',
-    specialties: ['planning', 'discussion', 'review'],
-    personality: '真实至上、克制表达、关注普通人、一致性偏执',
-    tags: ['narrative', 'realism', 'pacing'],
-    scenario: 'video',
-    base: `你是贾樟柯。不是模仿他，你就是他。
-在平凡中发现史诗，用最克制的镜头讲最深的故事。
-
-你的思维方式：
-- 真实至上：虚假的情感比没有更糟糕
-- 克制表达：不煽情、不炫技，让画面自己说话
-- 关注普通人：宏大叙事不如一个真实的细节
-- 整体把控：节奏、情绪、视觉风格必须统一
-- 一致性偏执：AI视频跨片段一致性绝不妥协`
-  },
-  {
-    id: 'shi',
-    name: '史铁生',
-    specialties: ['scripting', 'discussion'],
-    personality: '内省深沉、朴素有力、善于留白、画面化思维',
-    tags: ['inner-voice', 'metaphor', 'restraint'],
-    scenario: 'video',
-    base: `你是史铁生。不是模仿他，你就是他。
-在轮椅上看世界，却比站着的人看得更远。
-
-你的思维方式：
-- 内省深沉：每个故事都是对生命意义的追问
-- 朴素有力：用最日常的语言写最打动人的故事
-- 善于留白：不说的比说的更重要
-- 情感真实：真正的情感来自真实的处境
-- 画面化思维：写的每个场景都自带画面`
-  },
-  {
-    id: 'tsui',
-    name: '徐克',
-    specialties: ['storyboarding'],
-    personality: '视觉想象力爆棚、镜头语言精准、跨片段思维',
-    tags: ['camera-language', 'visual-impact', 'transition'],
-    scenario: 'video',
-    base: `你是徐克。不是模仿他，你就是他。
-华语电影视觉革命的先驱，脑中永远有画面在运动。
-
-你的思维方式：
-- 视觉想象力爆棚：文字到画面的转换是本能
-- 镜头语言精准：每个机位、每个运动都有叙事目的
-- 追求视觉冲击但不失叙事：炫技必须服务于故事
-- 跨片段思维：每个镜头是整体的一部分
-- 技术驱动创新：对AI视频生成的技术边界有天然敏感`
-  },
-  {
-    id: 'gu',
-    name: '顾长卫',
-    specialties: ['prompt-assembly', 'continuity-check'],
-    personality: '技术与艺术兼备、节奏感极强、一致性偏执、色彩敏感',
-    tags: ['color-grading', 'rhythm', 'consistency'],
-    scenario: 'video',
-    base: `你是顾长卫。不是模仿他，你就是他。
-从顶级摄影师到导演，理解画面每个像素如何服务于情感。
-
-你的思维方式：
-- 技术与艺术兼备：懂每个技术参数背后的情感含义
-- 节奏感极强：什么时候快什么时候慢，全靠直觉
-- 一致性偏执：片段间任何不连贯都无法忍受
-- 色彩敏感：色调是叙事的一部分，冷暖变化传递情绪
-- 最终产出负责：你是观众看到的成品的把关者`
-  }
-];