diff --git a/.agent/skills/science-video-pipeline/SKILL.md b/.agent/skills/science-video-pipeline/SKILL.md
index e1e6a1690..b26e7cbac 100644
--- a/.agent/skills/science-video-pipeline/SKILL.md
+++ b/.agent/skills/science-video-pipeline/SKILL.md
@@ -18,8 +18,8 @@ allowed-tools: Read, Write, Edit, Glob, Grep, Bash
 | ③ 逐字稿 | narration.md ★单一事实源 | [03](../../../apps/negentropy-influence/pipeline/skills/03-narration.md) | `pipeline.py build` | `build_narration.py` 通过 |
 | ④⑤ 双重校验 + 分镜 | 真实性回溯 + 易懂性；beat 覆盖性 | [04](../../../apps/negentropy-influence/pipeline/skills/04-verification.md) / [05](../../../apps/negentropy-influence/pipeline/skills/05-storyboard.md) | `pipeline.py check`（+`--check-scenes`） | RISKY=0；覆盖率无缺句 |
 | ⑥ TTS 配音 | 本人音色克隆（IndexTTS-2.5） | [07](../../../apps/negentropy-influence/pipeline/skills/07-tts-voice.md) | `pipeline.py tts --plan` | refs 指纹门 + 试听 + ETA |
-| ⑦ Remotion 场景 | 代码动画实现 | [06](../../../apps/negentropy-influence/pipeline/skills/06-remotion-implementation.md) | `tsc --noEmit` | 七条渲染红线 |
-| ⑧ 草渲 + 抽帧 QA | 半分辨率快速迭代 | [08](../../../apps/negentropy-influence/pipeline/skills/08-render-qa.md) | `pipeline.py render` + `qa` | 自动体检零 FAIL |
+| ⑦ Remotion 场景 | 代码动画实现（动效走 `src/motion/` 运动模型，分镜动效列 `@动词` 标注） | [06](../../../apps/negentropy-influence/pipeline/skills/06-remotion-implementation.md) | `tsc --noEmit` + `node --test scripts/motion.test.ts` | 七条渲染红线 + 运动层铁律 |
+| ⑧ 草渲 + 抽帧 QA | 半分辨率快速迭代（`--beat-heads` 入场瞬态补盲；重制回归 `--compare`） | [08](../../../apps/negentropy-influence/pipeline/skills/08-render-qa.md) | `pipeline.py render` + `qa` | 自动体检零 FAIL |
 | ⑨ 终渲 + 交付 | 1080p30 + srt/vtt | [09](../../../apps/negentropy-influence/pipeline/skills/09-final-render.md) | `render --final` + `captions` | 实测时长在预算窗 |
 
 ## 关键不变量
@@ -30,6 +30,6 @@ allowed-tools: Read, Write, Edit, Glob, Grep, Bash
 - **证据分级**：B 型信源里「他人对闭源产品源码的分析」属三级证据，口播必须带归属句，
   不得表述为产品既成事实；活数据（行数、总量、star 数）不进口播。
 - 每集 `pipeline.toml` 是可执行参数的唯一来源；README 不复制命令行参数。
-- 时序常数只在 `video/src/timing.json`（timing.ts 与 Python 共读）。
+- 时序常数只在 `video/src/timing.json`（timing.ts 与 Python 共读）；运动语汇（时长/缓动/弹簧/错峰）只在 `video/src/motion/`（frozen，改 = 模板 + 8 集同步）。
 - 声音样本是生物特征：不入库（`voices/refs.toml` 只存指纹），试听后即删。
 - 新集脚手架与复用边界（Python 集中 SSOT / Remotion 复制不共享）见 [pipeline/README.md](../../../apps/negentropy-influence/pipeline/README.md)。
diff --git a/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/package.json b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/package.json
index 83b2d0536..33258e8bf 100644
--- a/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/package.json
+++ b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/package.json
@@ -19,10 +19,5 @@
   "devDependencies": {
     "@types/react": "^19.0.0",
     "typescript": "^5.6.0"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild"
-    ]
   }
 }
diff --git a/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/pnpm-workspace.yaml b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/pnpm-workspace.yaml
index f2686ac7d..add822dbe 100644
--- a/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/pnpm-workspace.yaml
+++ b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/pnpm-workspace.yaml
@@ -1,4 +1,9 @@
-# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的唯一理由。
+# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的首要理由。
 # pnpm 12 起仅靠 `--ignore-workspace` 不够：pnpm 仍会沿 packageManager 向上锚定到仓库根，
 # 用本工程的解析结果覆写根 pnpm-lock.yaml（overrides 全丢）且当场不报错。见 ISSUE-175。
 packages: []
+# pnpm 12 的构建脚本许可（package.json 的 pnpm.onlyBuiltDependencies 已不被读取，
+# 静默忽略会使安装以 ERR_PNPM_IGNORED_BUILDS 中断、node_modules 半残）。键名与取值
+# 与 `pnpm approve-builds esbuild --yes` 实际写入的形态逐字一致——勿改回旧键名。
+allowBuilds:
+  esbuild: true
diff --git a/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/scripts/motion.test.ts b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/scripts/motion.test.ts
new file mode 100644
index 000000000..5e29cab52
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/scripts/motion.test.ts
@@ -0,0 +1,141 @@
+/**
+ * 运动层纯函数单测——`node --test scripts/motion.test.ts`（Node ≥ 23.6 原生跑 TS）。
+ *
+ * 刻意放在 video/ 而非 src/：tsconfig include 只有 src（frozen，不为测试改动），
+ * 而本文件 import 需带 .ts 后缀（Node ESM 解析规则）——tsc 若收编会因
+ * allowImportingTsExtensions 未开而报错。src/ 的类型覆盖由 tsc --noEmit 全量保证，
+ * 本文件只测纯函数行为，不做类型承重。
+ *
+ * 只 import 纯模块（tokens/window/schedule——零 remotion/react 依赖）：
+ * hooks 是它们的薄包装，行为由 MotionGallery 目视 + 场景抽帧覆盖。
+ */
+import {strict as assert} from 'node:assert';
+import test from 'node:test';
+
+import {DUR, EASING_CP, EXIT_FACTOR, SAFE_TOP_Y, SPRING, clampRiseDist, dampingRatio, overshootPeak} from '../src/motion/tokens.ts';
+import {beatProgress, clamp01, progress, revealCharCount, win} from '../src/motion/window.ts';
+import {schedule} from '../src/motion/schedule.ts';
+
+// ── tokens ────────────────────────────────────────────────────────────
+
+test('时长标尺在 30fps 下相邻档可辨（≥1 帧差）', () => {
+  const v = Object.values(DUR) as number[];
+  for (let i = 1; i < v.length; i++) {
+    assert.ok(v[i] - v[i - 1] >= 1, `第 ${i} 档与前一档同帧数（伪选择）`);
+  }
+  assert.ok(v.length === 6);
+});
+
+test('ζ→过冲换算钉死：snap 轻过冲、settle 零过冲（直抄 dampingRatio 的反例护栏）', () => {
+  const zSnap = dampingRatio(SPRING.snap);
+  const zSettle = dampingRatio(SPRING.settle);
+  assert.ok(zSnap > 0.4 && zSnap < 0.9, `snap ζ=${zSnap}`);
+  // Mp = exp(-πζ/√(1-ζ²)) 是超出幅度；峰值 = 1 + Mp（ζ=0.6 → 峰值 ≈1.095）
+  assert.ok(overshootPeak(zSnap) > 1.02 && overshootPeak(zSnap) < 1.2, `snap 峰值 ${overshootPeak(zSnap)}`);
+  assert.ok(zSettle > 1, 'settle 须过阻尼');
+  assert.equal(overshootPeak(zSettle), 1);
+  // 反例：把设计系统的 ζ 当 damping 直填（0.8）→ ζ≈0.04、峰值≈1.88 暴力弹跳
+  const wrong = dampingRatio({damping: 0.8, stiffness: 100, mass: 1});
+  assert.ok(overshootPeak(wrong) > 1.8, `直抄 ζ 的峰值=${overshootPeak(wrong)}，必须被此断言抓住`);
+});
+
+test('缓动控制点合法（CSS 规则 x∈[0,1]，且 x(t) 数值单调——可作函数求值）', () => {
+  for (const cp of Object.values(EASING_CP)) {
+    const [x1, , x2] = cp;
+    assert.ok(x1 >= 0 && x1 <= 1 && x2 >= 0 && x2 <= 1, `x 越界：${cp}`);
+    // x1<x2 是充分不必要（M3 standard (0.2,0,0,1) 的 x2<x1 仍单调）——判据用导数采样
+    for (let i = 0; i <= 50; i++) {
+      const t = i / 50;
+      const dx =
+        3 * (1 - t) ** 2 * x1 + 6 * (1 - t) * t * (x2 - x1) + 3 * t * t * (1 - x2);
+      assert.ok(dx > -1e-9, `x(t) 非单调 @t=${t}：${cp}`);
+    }
+  }
+});
+
+test('出场快于入场系数与安全带口径为常量', () => {
+  assert.equal(EXIT_FACTOR, 0.4);
+  assert.equal(SAFE_TOP_Y, 920);
+});
+
+test('clampRiseDist：自下方入场行程不探进字幕安全带', () => {
+  assert.equal(clampRiseDist(120, 836), 84, 'ISSUE-170 实测几何：rest 836 → 行程封顶 84');
+  assert.equal(clampRiseDist(40, 836), 40, '未超限不动');
+  assert.equal(clampRiseDist(120, 960), 0, '落位已在安全带内 → 零行程（退化但安全）');
+});
+
+// ── window ────────────────────────────────────────────────────────────
+
+test('clamp01 / progress / win 的钳制语义', () => {
+  assert.equal(clamp01(-1), 0);
+  assert.equal(clamp01(2), 1);
+  assert.equal(progress(10, 10, 10), 0, '起点为 0');
+  assert.equal(progress(20, 10, 10), 1, '终点为 1');
+  assert.equal(progress(5, 10, 10), 0, '窗外前钳 0');
+  assert.equal(progress(99, 10, 10), 1, '窗外后钳 1');
+  assert.equal(win(0.5, [0.25, 0.75]), 0.5);
+  assert.equal(win(0.1, [0.25, 0.75]), 0);
+  assert.equal(win(0.9, [0.25, 0.75]), 1);
+  assert.equal(beatProgress(0, -30, 90), 1 / 3);
+});
+
+test('逐字揭示：cps 按实际 fps 换算并向下取整，framesPerChar 保持固定帧间隔', () => {
+  assert.equal(revealCharCount(29, 60, 12), 5);
+  assert.equal(revealCharCount(30, 60, 12), 6);
+  assert.equal(revealCharCount(30, 24, 12, 3), 10);
+  assert.equal(revealCharCount(30, 120, 12, 3), 10);
+});
+
+// ── schedule ──────────────────────────────────────────────────────────
+
+test('fit 模式：末项恰在窗口末完成、不外溢', () => {
+  const p = schedule(5, {dur: 10, fit: {total: 90}});
+  const last = p.starts[4] + p.dur;
+  assert.ok(last <= 90 + 1, `末项 ${last} 外溢`);
+  assert.ok(last >= 89, `末项 ${last} 未到窗口末`);
+});
+
+test('fit 装不下时缩子项时长，不外溢窗口（优先级：不外溢 > 最小步长 > 子项时长）', () => {
+  // total 30 时 (30-12)/7≈2.57 ≥ minStride=2 仍装得下；压到 24 才触发缩时长
+  const p = schedule(8, {dur: 12, fit: {total: 24}});
+  const last = p.starts[7] + p.dur;
+  assert.ok(last <= 24, `末项 ${last} 外溢`);
+  assert.ok(p.dur >= 3, '子项时长跌破下限');
+  assert.ok(p.dur < 12, '装不下却未缩子项时长');
+});
+
+test('fit 窗口连 1 帧子项也容不下时显式拒绝，不返回外溢计划', () => {
+  assert.throws(() => schedule(8, {dur: 12, fit: {total: 5}}), /fit\.total=5.*8/);
+});
+
+test('fit 可行极限先牺牲子项时长，仍完整落在窗口内', () => {
+  const p = schedule(8, {dur: 12, fit: {total: 8}});
+  assert.equal(p.dur, 1);
+  assert.equal(p.starts[7] + p.dur, 8);
+});
+
+test('lag 模式：Manim 语义 start[i] = i·dur·lag', () => {
+  const p = schedule(3, {dur: 10, lag: 0.5});
+  assert.deepEqual(p.starts, [0, 5, 10]);
+  assert.deepEqual(schedule(3, {dur: 10, lag: 0}).starts, [0, 0, 0], 'lag=0 须同刻齐动');
+});
+
+test('stride 模式与三选一守卫', () => {
+  assert.deepEqual(schedule(3, {dur: 5, stride: 4}).starts, [0, 4, 8]);
+  assert.throws(() => schedule(3, {dur: 5, stride: 4, lag: 1}));
+  assert.throws(() => schedule(3, {dur: 5, lag: 1, fit: {total: 40}}));
+});
+
+test('最小步长与空集', () => {
+  assert.deepEqual(schedule(0, {dur: 5, stride: 4}), {starts: [], dur: 5});
+  const p = schedule(2, {dur: 5, stride: 0}); // 非法步长 → 抬到下限
+  assert.ok(p.starts[1] - p.starts[0] >= 1);
+});
+
+test('起点取整且单调不减', () => {
+  const p = schedule(6, {dur: 7, fit: {total: 53}});
+  for (let i = 1; i < p.starts.length; i++) {
+    assert.ok(p.starts[i] >= p.starts[i - 1], '起点须单调不减');
+    assert.ok(Number.isInteger(p.starts[i]));
+  }
+});
diff --git a/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/gallery.tsx b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/gallery.tsx
new file mode 100644
index 000000000..a71737133
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/gallery.tsx
@@ -0,0 +1,265 @@
+/** MotionGallery——运动层的评审面（独立 Remotion 入口，不经 Root.tsx）。
+ *
+ * 用法（在 video/ 目录，.bin 直调防污染根 workspace）：
+ *   ./node_modules/.bin/remotion still src/motion/gallery.tsx MotionGallery \
+ *       out/motion-gallery.png --frame=30
+ *
+ * 全部模型 × 变体一屏可渲：秒级出图，供 token 校准轮逐格目视。
+ * 色板为本文件内字面量（dev 工具面，不进成片、不读 theme——保持 frozen 跨系列共享）。
+ */
+import React from 'react';
+import {AbsoluteFill, Composition, registerRoot} from 'remotion';
+import {
+  useAccelTravel,
+  useBreathe,
+  useCount,
+  useDim,
+  useDraw,
+  useEnter,
+  useFadeOut,
+  useFlowDash,
+  useImpulse,
+  usePushIn,
+  useReveal,
+  useShake,
+  useStagger,
+  useTravel,
+} from './hooks';
+
+const COLS = 5;
+const CW = 340;
+const CH = 230;
+const GAP = 18;
+
+/** dev 工具面字面量色板（与各集 theme 底座同值但刻意独立声明——不读 theme）。 */
+const C = {
+  bg: '#0E1116',
+  panel: '#171C26',
+  border: '#2A3242',
+  text: '#F2F5FA',
+  dim: '#9AA7B8',
+  core: '#D97757',
+  mech: '#64C4C0',
+  deny: '#EF6461',
+};
+
+/** 单元格壳：定位 + 角标。 */
+const Cell: React.FC<{i: number; name: string; children: React.ReactNode}> = ({i, name, children}) => (
+  <div
+    style={{
+      position: 'absolute',
+      left: 72 + (i % COLS) * (CW + GAP),
+      top: 96 + Math.floor(i / COLS) * (CH + GAP),
+      width: CW,
+      height: CH,
+      background: C.panel,
+      border: `2px solid ${C.border}`,
+      borderRadius: 12,
+    }}
+  >
+    <div
+      style={{
+        position: 'absolute',
+        inset: '28px 0 34px 0',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+      }}
+    >
+      {children}
+    </div>
+    <div style={{position: 'absolute', left: 12, bottom: 8, fontFamily: 'monospace', fontSize: 15, color: C.dim}}>
+      {name}
+    </div>
+  </div>
+);
+
+const Box: React.FC<{color?: string; w?: number; h?: number; style?: React.CSSProperties}> = ({
+  color = C.core,
+  w = 200,
+  h = 80,
+  style,
+}) => <div style={{width: w, height: h, background: C.panel, border: `2px solid ${color}`, borderRadius: 10, ...style}} />;
+
+// ── 每格一个组件：hooks 各归其位（Rules of Hooks 的最简守法形态） ────────
+
+const EnterCell: React.FC<{kind: Parameters<typeof useEnter>[0]}> = ({kind}) => {
+  const e = useEnter(kind, {});
+  return <Box style={{opacity: e.opacity, transform: e.transform}} />;
+};
+
+const StaggerCell: React.FC = () => {
+  const ps = useStagger(5, {dur: 5, fit: {total: 60}});
+  return (
+    <div style={{display: 'flex', gap: 10}}>
+      {ps.map((p, i) => (
+        <div
+          key={i}
+          style={{
+            width: 34,
+            height: 80,
+            background: C.panel,
+            border: `2px solid ${C.mech}`,
+            borderRadius: 8,
+            opacity: p,
+            transform: `translateY(${(1 - p) * 14}px)`,
+          }}
+        />
+      ))}
+    </div>
+  );
+};
+
+const DrawCell: React.FC = () => {
+  const d = useDraw(0, 24);
+  return (
+    <svg width={280} height={110}>
+      <path {...d} d="M10 90 C 90 10, 190 100, 270 20" stroke={C.core} strokeWidth={5} fill="none" strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ImpulseCell: React.FC = () => {
+  const g = useImpulse({dur: 30, peak: 1});
+  return (
+    <div
+      style={{
+        width: 90,
+        height: 90,
+        borderRadius: '50%',
+        background: C.core,
+        opacity: 0.3 + 0.7 * g,
+        boxShadow: `0 0 ${10 + 30 * g}px ${C.core}`,
+      }}
+    />
+  );
+};
+
+const BreatheCell: React.FC = () => {
+  const b = useBreathe({period: 30});
+  return (
+    <svg width={160} height={110}>
+      <circle cx={80} cy={55} r={40} fill="none" stroke={C.mech} strokeWidth={5} opacity={b} />
+    </svg>
+  );
+};
+
+const TravelCell: React.FC = () => {
+  const t = useTravel({cx: 140, cy: 55, r: 42, secPerLap: 3});
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} />
+      <circle cx={t.x} cy={t.y} r={9} fill={C.core} />
+    </svg>
+  );
+};
+
+const AccelCell: React.FC = () => {
+  const t = useAccelTravel({cx: 140, cy: 55, r: 42, durs: [28, 20, 14], at: 4});
+  const heat = `rgb(${217 + Math.round(38 * t.heat)}, ${119 - Math.round(60 * t.heat)}, ${87 - Math.round(20 * t.heat)})`;
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} strokeDasharray="4 6" />
+      <circle cx={t.x} cy={t.y} r={9} fill={heat} />
+    </svg>
+  );
+};
+
+const CountCell: React.FC = () => {
+  const v = useCount({to: 255, dur: 40});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 44, color: C.text, fontVariantNumeric: 'tabular-nums'}}>
+      {Math.round(v)}
+    </div>
+  );
+};
+
+const RevealCell: React.FC = () => {
+  const s = useReveal('while (true) { think(); act(); }', {cps: 14});
+  const blink = useBreathe({period: 16, amp: 0.5, base: 0.5});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 20, color: C.text, whiteSpace: 'nowrap'}}>
+      {s}
+      <span style={{opacity: blink}}>▍</span>
+    </div>
+  );
+};
+
+const PushInCell: React.FC = () => {
+  const t = usePushIn(0, {scale: 0.12});
+  return <Box w={160} h={90} color={C.mech} style={{transform: t}} />;
+};
+
+const DimCell: React.FC = () => {
+  const dim = useDim({at: 40, to: 0.35});
+  return (
+    <div style={{display: 'flex', gap: 12}}>
+      <Box w={64} h={80} style={{opacity: dim}} />
+      <Box w={64} h={80} color={C.core} />
+      <Box w={64} h={80} style={{opacity: dim}} />
+    </div>
+  );
+};
+
+const FlowCell: React.FC = () => {
+  const f = useFlowDash({period: 24});
+  return (
+    <svg width={280} height={60}>
+      <line x1={10} y1={30} x2={270} y2={30} stroke={C.mech} strokeWidth={5} {...f} strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ShakeCell: React.FC = () => {
+  const x = useShake({at: 10, amp: 5, decay: true, dur: 40});
+  return <Box w={150} h={80} color={C.deny} style={{transform: `translateX(${x}px)`}} />;
+};
+
+const FadeCell: React.FC = () => {
+  const op = useFadeOut(90, {frames: 36});
+  return (
+    <div style={{position: 'relative', width: 220, height: 90}}>
+      <Box w={220} h={90} color={C.core} style={{position: 'absolute', inset: 0}} />
+      <div style={{position: 'absolute', inset: 0, background: '#000', opacity: 1 - op}} />
+    </div>
+  );
+};
+
+const CELLS: Array<[string, React.ReactNode]> = [
+  ['enter:fall', <EnterCell kind="fall" />],
+  ['enter:rise', <EnterCell kind="rise" />],
+  ['enter:slideL', <EnterCell kind="slideL" />],
+  ['enter:pop', <EnterCell kind="pop" />],
+  ['enter:flyIn', <EnterCell kind="flyIn" />],
+  ['enter:fade', <EnterCell kind="fade" />],
+  ['stagger×5 fit60', <StaggerCell />],
+  ['draw 24f', <DrawCell />],
+  ['impulse 30f', <ImpulseCell />],
+  ['breathe p30', <BreatheCell />],
+  ['travel 3s/lap', <TravelCell />],
+  ['accelTravel', <AccelCell />],
+  ['count→255', <CountCell />],
+  ['reveal 14cps', <RevealCell />],
+  ['pushIn .12', <PushInCell />],
+  ['dim .35@40', <DimCell />],
+  ['flowDash p24', <FlowCell />],
+  ['shake decay', <ShakeCell />],
+  ['fadeOut 36f', <FadeCell />],
+];
+
+const MotionGallery: React.FC = () => (
+  <AbsoluteFill style={{background: C.bg}}>
+    <div style={{position: 'absolute', left: 72, top: 44, fontFamily: 'monospace', fontSize: 24, color: C.text}}>
+      MotionGallery · 30fps · 120f
+    </div>
+    {CELLS.map(([name, node], i) => (
+      <Cell key={name} i={i} name={name}>
+        {node}
+      </Cell>
+    ))}
+  </AbsoluteFill>
+);
+
+registerRoot(() => (
+  <Composition id="MotionGallery" component={MotionGallery} width={1920} height={1080} fps={30} durationInFrames={120} defaultProps={{}} />
+));
diff --git a/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/hooks.ts b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/hooks.ts
new file mode 100644
index 000000000..f87b8a129
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/hooks.ts
@@ -0,0 +1,303 @@
+/** 运动模型（hooks）——分镜「动效」列动词到帧数学的唯一映射。
+ *
+ * 设计约束（违反任何一条即失去本层存在意义）：
+ * 1. hooks 返回数值 / CSS 片段，不渲染 DOM——FadeUp 式包装组件打不进 svg/<g>/
+ *    absolute 布局，是「组件存在却零调用」的实测根因；数值可落进任意 JSX。
+ * 2. 弹簧一律吃局部帧（frame - at）：spring() 每次调用从第 0 帧重模拟，喂全局帧
+ *    会让长片末帧每个 spring 跑两万余次迭代。
+ * 3. effects（不透明度/颜色）永不吃弹簧——一律时长+缓动（tokens 的二分不变量）。
+ * 4. 不读 theme：颜色一律经参数传入（frozen 跨系列共享的前提）。
+ * 5. `at` 锚点一律来自句边界（rel(beat, '句id')），禁写死帧数。
+ */
+import {Easing, interpolate, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {
+  DUR,
+  EASING_CP,
+  SPRING,
+  clampRiseDist,
+  type DurToken,
+  type EasingToken,
+  type SpringPreset,
+} from './tokens';
+import {progress, revealCharCount} from './window';
+import {schedule, type ScheduleOpts} from './schedule';
+
+/** 帧数解析：token 或直接帧数；缺省用 def。 */
+export const frames = (d: number | DurToken | undefined, def: number): number =>
+  d === undefined ? def : typeof d === 'number' ? d : DUR[d];
+
+/** 缓动令牌 → Remotion 缓动函数（linear 直通）。 */
+export const easeF = (t: EasingToken): ((x: number) => number) =>
+  t === 'linear'
+    ? Easing.linear
+    : Easing.bezier(
+        ...(EASING_CP[t] as [number, number, number, number]),
+      );
+
+/** 缓动后的 0..1 进度（各模型共用的原子）。 */
+const eased = (
+  frame: number,
+  at: number,
+  dur: number,
+  e: EasingToken,
+): number => interpolate(progress(frame, at, dur), [0, 1], [0, 1], {easing: easeF(e)});
+
+/** 缓动数值进度——「clamped 0→1 手写 interpolate」惯用形的统一替身：
+ *  时机值走 token，缓动默认 standard（线性原版会被这一档替换——质量提升点之一）。 */
+export function useProgress(
+  at: number,
+  dur: number | DurToken = DUR.f5,
+  easing: EasingToken = 'standard',
+): number {
+  const frame = useCurrentFrame();
+  return eased(frame, at, frames(dur, DUR.f5), easing);
+}
+
+/** 弹簧数值进度（驱动几何量/位移；effects 通道用 useProgress——tokens 二分不变量）。
+ *  局部帧 + 可选 durationInFrames 截停（防窗口外余振；缺省不设上限，与既有手写等价）。 */
+export function useSpring(
+  preset: SpringPreset,
+  o: {at?: number; dur?: number | DurToken} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const cfg: Parameters<typeof spring>[0] = {
+    frame: frame - (o.at ?? 0),
+    fps,
+    config: SPRING[preset],
+  };
+  if (o.dur !== undefined) {
+    cfg.durationInFrames = frames(o.dur, DUR.f5);
+  }
+  return spring(cfg);
+}
+
+// ── 入场（enter：落下/上浮/滑入/弹出/飞入/淡入） ────────────────────────
+
+export type EnterKind = 'fall' | 'rise' | 'slideL' | 'slideR' | 'pop' | 'flyIn' | 'fade';
+export type EnterOpts = {
+  /** 句边界锚（局部帧）。 */
+  at?: number;
+  dur?: number | DurToken;
+  easing?: EasingToken;
+  /** 空间通道用弹簧（位移类才有意义；fade/pop 无效）。 */
+  springPreset?: SpringPreset;
+  /** 位移像素（fall/rise/slide*；缺省 30）。 */
+  dist?: number;
+  /** rise 专用：落位态底边 y——行程经 clampRiseDist 钳进字幕安全带之上。 */
+  restBottom?: number;
+};
+export type EnterStyle = {opacity: number; transform: string};
+
+export function useEnter(kind: EnterKind, o: EnterOpts = {}): EnterStyle {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const at = o.at ?? 0;
+  const dur = frames(o.dur, DUR.f4);
+  let dist = o.dist ?? 30;
+  if (kind === 'rise' && o.restBottom !== undefined) {
+    dist = clampRiseDist(dist, o.restBottom);
+  }
+  // effects 通道：纯缓动、略快于空间通道（元素先「看见」再「落位」）
+  const opacity = progress(frame, at, Math.max(2, Math.round(dur * 0.8)));
+  // spatial 通道：可选弹簧（局部帧 + durationInFrames 截停，防窗口外余振）
+  const p = o.springPreset
+    ? spring({
+        frame: frame - at,
+        fps,
+        config: SPRING[o.springPreset],
+        durationInFrames: dur,
+      })
+    : eased(frame, at, dur, o.easing ?? 'standard');
+  const inv = 1 - p;
+  const t: string[] = [];
+  if (kind === 'fall') t.push(`translateY(${-inv * dist}px)`);
+  if (kind === 'rise') t.push(`translateY(${inv * dist}px)`);
+  if (kind === 'slideL') t.push(`translateX(${-inv * dist}px)`);
+  if (kind === 'slideR') t.push(`translateX(${inv * dist}px)`);
+  if (kind === 'pop') t.push(`scale(${0.9 + 0.1 * p})`);
+  if (kind === 'flyIn') t.push(`scale(${0.6 + 0.4 * p})`);
+  return {opacity, transform: t.length ? t.join(' ') : 'none'};
+}
+
+// ── 序列错峰（stagger：依次/逐行/逐条/逐格） ───────────────────────────
+
+export type StaggerOpts = ScheduleOpts & {at?: number; easing?: EasingToken};
+
+/** 返回 n 个 0..1 进度——第 i 项随编排依次入场。 */
+export function useStagger(n: number, o: StaggerOpts = {}): number[] {
+  const frame = useCurrentFrame();
+  const {at = 0, easing = 'standard'} = o;
+  const plan = schedule(n, o);
+  return plan.starts.map((s) => eased(frame, at + s, plan.dur, easing));
+}
+
+// ── 描线（draw：红线三由构造保证——只产 pathLength 归一化三元组） ────────
+
+export type DrawProps = {pathLength: 1; strokeDasharray: 1; strokeDashoffset: number};
+
+export function useDraw(at: number, dur: number | DurToken = DUR.f5): DrawProps {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(dur, DUR.f5), 'decelerate');
+  return {pathLength: 1, strokeDasharray: 1, strokeDashoffset: 1 - p};
+}
+
+// ── 脉冲 / 呼吸（glow 语法：impulse=一次性强调，breathe=持续辉光） ───────
+
+/** 一次性冲击：sin(πp) 包络，起于 0 归于 0，峰值 peak。 */
+export function useImpulse(o: {at?: number; dur?: number | DurToken; peak?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const p = progress(frame, o.at ?? 0, frames(o.dur, DUR.f5));
+  return Math.sin(Math.PI * p) * (o.peak ?? 1);
+}
+
+/** 持续呼吸（原 0.55+0.45·sin(frame/K) 散写的收敛；period 帧一周期——注意与
+ *  原除数 K 的换算 period = 2πK，如 sin(frame/26) → period 163）。offset 为相位
+ *  平移（错峰辉光的 per-index 形态）。 */
+export function useBreathe(
+  o: {period?: number; amp?: number; base?: number; offset?: number} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {amp = 0.45, base = 0.55, period = 26, offset = 0} = o;
+  return base + amp * Math.sin((2 * Math.PI * (frame - offset)) / period);
+}
+
+// ── 巡游（travel：环形为主；absorb 原 useRingDot 与加速绕行累加器克隆） ──
+
+export type TravelPos = {x: number; y: number; angle: number};
+
+/** 匀速环形巡游（angle 单位度，-90 = 12 点方向起）。 */
+export function useTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  secPerLap?: number;
+  offset?: number;
+}): TravelPos {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const lap = (frame / (fps * (o.secPerLap ?? 2.5)) + (o.offset ?? 0)) % 1;
+  const a = -90 + lap * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), angle: a};
+}
+
+/** 加速绕行：逐圈时长 durs[]（如 [40,30,22,16]），跑完全部圈后冻结在终点。
+ *  heat 0..1 随圈数推进（「失控感」的配色偏移系数）。 */
+export function useAccelTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  durs: number[];
+  at?: number;
+  heatPerLap?: number;
+}): {x: number; y: number; heat: number} {
+  const frame = useCurrentFrame();
+  let t = Math.max(0, frame - (o.at ?? 0));
+  let lap = 0;
+  while (lap < o.durs.length && t >= o.durs[lap]) {
+    t -= o.durs[lap];
+    lap += 1;
+  }
+  const within = lap >= o.durs.length ? 1 : t / o.durs[lap];
+  const heat = Math.min(1, lap / (o.heatPerLap ?? o.durs.length));
+  const a = -90 + within * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), heat};
+}
+
+// ── 计数 / 水位（meter 语法；显示层自行 Math.round / toFixed） ──────────
+
+export function useCount(o: {
+  from?: number;
+  to: number;
+  at?: number;
+  dur?: number | DurToken;
+  ease?: EasingToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {from = 0, to, at = 0} = o;
+  const p = eased(frame, at, frames(o.dur, DUR.f6), o.ease ?? 'standard');
+  return from + (to - from) * p;
+}
+
+// ── 打字机 / 逐字流出（type；Terminal 之外的泛化） ──────────────────────
+
+export function useReveal(
+  text: string,
+  o: {at?: number; cps?: number; framesPerChar?: number} = {},
+): string {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const elapsed = Math.max(0, frame - (o.at ?? 0));
+  const n = revealCharCount(elapsed, fps, o.cps ?? 12, o.framesPerChar);
+  return text.slice(0, Math.min(text.length, n));
+}
+
+// ── 镜头推近（pushIn 语法：beat 切换的镜头语言，替代纯淡入） ────────────
+
+export function usePushIn(at: number, o: {scale?: number; dur?: number | DurToken} = {}): string {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(o.dur, DUR.f5), 'decelerate');
+  return `scale(${1 + (o.scale ?? 0.06) * p})`;
+}
+
+// ── 压暗 / 提亮（emphasis 反向：让主体从群像中浮出） ─────────────────────
+
+/** 返回目标透明度系数（1 = 原；to 0.4 即压暗到 40%）。 */
+export function useDim(o: {at: number; to?: number; dur?: number | DurToken}): number {
+  const frame = useCurrentFrame();
+  const p = eased(frame, o.at, frames(o.dur, DUR.f4), 'standard');
+  return 1 + ((o.to ?? 0.4) - 1) * p;
+}
+
+// ── 流光（flow 语法：连线上的行进虚线） ─────────────────────────────────
+
+/** 返回可直接展开到 <line>/<path> 的描边属性（像素 dasharray——与 draw 的
+ *  pathLength 归一化描线是两个正交特性，勿混用于同一元素：红线三）。 */
+export function useFlowDash(o: {
+  dash?: number;
+  gap?: number;
+  /** 帧速率：每 period 帧行进一个 dash+gap 周期。 */
+  period?: number;
+}): {strokeDasharray: string; strokeDashoffset: number} {
+  const frame = useCurrentFrame();
+  const {dash = 10, gap = 14, period = 40} = o;
+  return {
+    strokeDasharray: `${dash} ${gap}`,
+    strokeDashoffset: -(frame * (dash + gap)) / period,
+  };
+}
+
+// ── 抖动（错误/故障语义；收敛 P2/P3 两处克隆） ──────────────────────────
+
+/** 返回 translateX 像素值。active 缺省 true；decay=true 时按 dur 衰减归零。 */
+export function useShake(o: {
+  at: number;
+  active?: boolean;
+  amp?: number;
+  /** 相位分母（原手写 /1.6、/2.2 的口径）。 */
+  freq?: number;
+  decay?: boolean;
+  dur?: number | DurToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {amp = 3, freq = 1.6} = o;
+  const t = frame - o.at;
+  if (o.active === false || t < 0) {
+    return 0;
+  }
+  if (o.decay) {
+    const env = 1 - progress(frame, o.at, frames(o.dur, DUR.f5));
+    return amp * env * Math.sin(t / freq);
+  }
+  return amp * Math.sin(t / freq);
+}
+
+// ── 片尾渐黑（红线四：从 beat 总时长推导，勿用末句时长） ────────────────
+
+export function useFadeOut(durationInFrames: number, o: {frames?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const f = o.frames ?? 36; // 1.2s
+  return 1 - progress(frame, durationInFrames - f, f);
+}
diff --git a/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/index.ts b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/index.ts
new file mode 100644
index 000000000..97fd22a5c
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/index.ts
@@ -0,0 +1,5 @@
+/** 运动层门面——场景代码统一 `import {...} from '../motion'`。 */
+export * from './tokens';
+export * from './window';
+export * from './schedule';
+export * from './hooks';
diff --git a/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/schedule.ts b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/schedule.ts
new file mode 100644
index 000000000..5703e3315
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/schedule.ts
@@ -0,0 +1,65 @@
+/** 错峰编排（stagger）纯函数——收敛手写 `frame - i*N`（跨 8 集约 356 处、
+ *  步长 K∈{2,3,4,5,6,8,10} 任意取值、无节奏标尺）。
+ *
+ * 三种模式（互斥，参数即文档）：
+ * - stride：固定步长（与旧手写行为一致——迁移期的保守选项）；
+ * - lag：Manim LaggedStart 语义 start[i] = i·dur·lagRatio（0 = 同刻齐动，1 = 首尾相接）；
+ * - fit：n 个子项恰好装进窗口 total（末项恰在窗口末完成——「随句推进」的首选）。
+ *
+ * 钳制优先级（motion.test.ts 钉死，自左向右）：不外溢窗口 > 最小步长 > 子项时长。
+ * 窗口属于 beat 时间轴，外溢会踩进下一 beat；装不下时先缩子项时长，连 1 帧
+ * 子项都无法错开时显式抛错，不返回违反 fit 契约的计划。
+ */
+export type ScheduleOpts = {
+  /** 子项时长（帧；缺省 DUR.f3=5——「快速子项」档）。 */
+  dur?: number;
+  /** 模式一：固定步长。 */
+  stride?: number;
+  /** 模式二：lag 比率（Manim lag_ratio）。 */
+  lag?: number;
+  /** 模式三：拟装入的窗口总长（帧）。 */
+  fit?: {total: number};
+  /** 相邻起点期望下限，默认 2 帧；fit 紧窗时可按优先级退至 1 帧。 */
+  minStride?: number;
+  /** 子项时长期望下限，默认 3 帧；fit 为守住窗口可退至 1 帧。 */
+  minDur?: number;
+};
+export type Schedule = {starts: number[]; dur: number};
+
+export function schedule(n: number, o: ScheduleOpts): Schedule {
+  const minStride = o.minStride ?? 2;
+  const minDur = o.minDur ?? 3;
+  const modes = [o.stride !== undefined, o.lag !== undefined, o.fit !== undefined].filter(
+    Boolean,
+  ).length;
+  if (modes > 1) {
+    throw new Error('schedule: stride / lag / fit 三选一');
+  }
+  let dur = Math.max(minDur, o.dur ?? 5);
+  if (n <= 0) {
+    return {starts: [], dur};
+  }
+  let stride: number;
+  if (o.fit) {
+    const total = Math.max(1, o.fit.total);
+    if (n > 1 && total < n) {
+      throw new Error(
+        `schedule: fit.total=${total} 无法容纳 ${n} 个至少 1 帧且起点间隔至少 1 帧的子项`,
+      );
+    }
+    dur = Math.min(dur, total);
+    stride = n === 1 ? 0 : (total - dur) / (n - 1);
+    const targetStride = Math.max(1, minStride);
+    if (n > 1 && stride < targetStride) {
+      // 先缩时长争取期望步长；仍不足时牺牲步长，但至少保留 1 帧先后。
+      dur = Math.max(1, Math.min(dur, total - targetStride * (n - 1)));
+      stride = (total - dur) / (n - 1);
+    }
+  } else if (o.lag !== undefined) {
+    stride = dur * o.lag;
+  } else {
+    stride = o.stride ?? minStride;
+  }
+  stride = Math.max(n === 1 || o.lag === 0 ? 0 : 1, stride);
+  return {starts: Array.from({length: n}, (_, i) => Math.round(i * stride)), dur};
+}
diff --git a/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/tokens.ts b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/tokens.ts
new file mode 100644
index 000000000..457448260
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/tokens.ts
@@ -0,0 +1,87 @@
+/** 运动令牌——时长标尺 / 缓动曲线 / 弹簧手感 的单一事实源。
+ *
+ * 只放纯数据与纯函数：不 import remotion、不读 theme（颜色一律经参数注入）——
+ * 这是本层能以 frozen 档跨两个系列共享的前提（两系列 theme token 名已分叉：
+ * CC 用 core/mech/deny、SE 用 danger），判据同 test_chrome_motifs_only_read_base_theme_tokens。
+ *
+ * 取值依据（勿凭感觉改；改前先在本集校准轮逐幕目视复测，依据写回此处注释）：
+ * - 时长六档取 IBM Carbon DTCG（70/110/150/240/400/700ms）@30fps 四舍五入。
+ *   弃 Material 十六档：30fps 量化下其 15 个相邻对里 6 对落进同一帧数（伪选择）。
+ * - 缓动控制点取 Material 3 标准三件；曲线本体在 hooks.ts 经 Remotion Easing.bezier 求值。
+ * - 弹簧预设锚定本仓实测手感：settle=200 即既有 9/10 调用点的惯用值（延续成片观感），
+ *   snap=12 来自 P4「插头咬合」的过冲；ζ 与过冲峰值的关系由 motion.test.ts 用
+ *   Mp = exp(-πζ/√(1-ζ²)) 钉死。
+ * - effects 不变量：不透明度/颜色永不过冲——effects 类动画一律时长+缓动，
+ *   弹簧只用于空间位移（M3 spatial/effects 二分的落地）。
+ */
+
+/** 时长标尺（帧 @30fps）。叙事节拍（4–8s）不用此表——那是 window/schedule 的职责。 */
+export const DUR = {
+  /** 70ms：微反馈（辉光起点、光标） */
+  f1: 2,
+  /** 110ms：快速子项（列表错峰的单项时长） */
+  f2: 3,
+  /** 150ms：标准入场 */
+  f3: 5,
+  /** 200ms：强调入场 */
+  f4: 7,
+  /** 400ms：大位移 / 镜头推近 / 描线 */
+  f5: 12,
+  /** 700ms：幕级大动作（少用） */
+  f6: 21,
+} as const;
+export type DurToken = keyof typeof DUR;
+
+/** 缓动令牌。 */
+export type EasingToken = 'standard' | 'decelerate' | 'accelerate' | 'linear';
+
+/** 贝塞尔控制点（x1,y1,x2,y2）；linear 无控制点。 */
+export const EASING_CP: Record<
+  Exclude<EasingToken, 'linear'>,
+  readonly [number, number, number, number]
+> = {
+  // M3 standard：入场默认
+  standard: [0.2, 0, 0, 1],
+  // M3 decelerate：强减速（大位移入场、镜头推近）
+  decelerate: [0.05, 0.7, 0.1, 1],
+  // M3 accelerate：出场加速
+  accelerate: [0.3, 0, 0.8, 0.15],
+};
+
+/** 弹簧预设（直传 Remotion spring config；ζ = c/(2√(k·m))）。 */
+export type SpringPreset = 'settle' | 'settleSoft' | 'snap';
+export const SPRING: Record<SpringPreset, {damping: number; stiffness: number; mass: number}> = {
+  // ζ≈10：无过冲平滑滑入——本仓主流手感（既有场景 9/10 处 damping 200）
+  settle: {damping: 200, stiffness: 100, mass: 1},
+  // ζ≈8.5：更绵一点（P0/P1 既有 180/170 档的收敛）
+  settleSoft: {damping: 170, stiffness: 100, mass: 1},
+  // ζ≈0.6：轻微过冲（咬合/弹入——原 P4 damping 12）
+  snap: {damping: 12, stiffness: 100, mass: 1},
+};
+
+/** 阻尼比 ζ。设计系统文档普遍给 ζ（无量纲），Remotion 取阻尼系数 c——直抄会得
+ *  ζ≈0.02 的暴力弹跳且能通过渲染体检，这是迁移期最高风险项（单测钉死）。 */
+export const dampingRatio = (s: {
+  damping: number;
+  stiffness: number;
+  mass: number;
+}): number => s.damping / (2 * Math.sqrt(s.stiffness * s.mass));
+
+/** 欠阻尼弹簧的峰值位置（1 = 恰好到终点不过冲；ζ ≥ 1 恒 1）。
+ *  Mp = exp(-πζ/√(1-ζ²)) 是超出终点的幅度，峰值 = 1 + Mp。 */
+export const overshootPeak = (zeta: number): number =>
+  zeta >= 1 ? 1 : 1 + Math.exp((-Math.PI * zeta) / Math.sqrt(1 - zeta * zeta));
+
+/** 出场快于入场的系数（MDC 实测 400ms 入 / 150ms 出 ≈ 0.375，取 0.4 禁手填）。 */
+export const EXIT_FACTOR = 0.4;
+
+/** 字幕安全带上沿：1080 - qa_frames.SUBTITLE_BAND_PX(160)，与体检口径同源。 */
+export const SAFE_TOP_Y = 920;
+
+/** 自下方入场的行程安全钳制：落位态底边 restBottom 之上才是可用的进场空间。
+ *  ISSUE-170 的手工逐卡反算收敛于此——该缺陷类从「评审抽帧抓」变「构造不可能」。 */
+export const clampRiseDist = (
+  dist: number,
+  restBottom: number,
+  safeTop: number = SAFE_TOP_Y,
+): number => Math.max(0, Math.min(dist, safeTop - restBottom));
diff --git a/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/window.ts b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/window.ts
new file mode 100644
index 000000000..69bd59c7a
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-concurrency-video/video/src/motion/window.ts
@@ -0,0 +1,43 @@
+/** 运动窗口纯函数——「父级持有绝对时间，子动画只是父进度上的窗口」。
+ *
+ * 这是 audio-first 时序与可复用运动模型兼容的核心机制：beat 的绝对帧来自
+ * beatWindow()（数据源是 TTS 实测 manifest），子动画不写死帧数、只声明自己在
+ * beat 进度上的 [start, end] 窗口 ⇒ 旁白实测时长变化时全部窗口自动重定时，
+ * 「写死帧数与口播脱钩」缺陷类（skills/08 实录）由构造消灭。
+ *
+ * 语义借 MDC TransitionUtils.lerp(startFraction, endFraction)：窗外钳制端点。
+ * 本模块零依赖（不 import remotion / theme）——frozen 跨系列共享与 node 单测的前提。
+ */
+
+/** 钳制到 [0,1]——一切进度的唯一出口，防负值/超 1 渗进 transform。 */
+export const clamp01 = (x: number): number => (x < 0 ? 0 : x > 1 ? 1 : x);
+
+/** 子动画窗口：父进度 p(0..1) 在 [s,e] 片段上的局部进度。 */
+export const win = (p: number, w: readonly [number, number]): number =>
+  clamp01((p - w[0]) / (w[1] - w[0]));
+
+/** beat 进度：局部帧 → 该 beat 的 0..1 进度。 */
+export const beatProgress = (
+  frame: number,
+  from: number,
+  durationInFrames: number,
+): number => clamp01((frame - from) / Math.max(1, durationInFrames));
+
+/** 帧域进度：[at, at+dur] 上的 0..1（dur ≤ 0 视作 1，防除零）。 */
+export const progress = (frame: number, at: number, dur: number): number =>
+  clamp01((frame - at) / Math.max(1, dur));
+
+/** 已过帧数 → 可见字符数；cps 随实际 fps 换算，显式帧间隔不受 fps 影响。 */
+export const revealCharCount = (
+  elapsedFrames: number,
+  fps: number,
+  cps: number,
+  framesPerChar?: number,
+): number => {
+  const elapsed = Math.max(0, elapsedFrames);
+  const count =
+    framesPerChar === undefined
+      ? Math.floor((elapsed / fps) * cps)
+      : Math.floor(elapsed / Math.max(1, framesPerChar));
+  return Math.max(0, count);
+};
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/README.md b/apps/negentropy-influence/episodes/claude-code-explained-video/README.md
index 232a779ca..17985c03a 100644
--- a/apps/negentropy-influence/episodes/claude-code-explained-video/README.md
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/README.md
@@ -1,7 +1,7 @@
 # 《执行层：一个循环，就是全部》
 
 > 系列「Claude Code Harness Engineering」首作（发布顺序 SSOT：[../series.json](../../series.json)；口播永不携带集数序号）。
-> **改造状态（2026-08-23）**：Harness Engineering 改造版——口播 v-next 已定稿、场景组件已升级、配音完成（167 句全缓存，`tts --plan` 待合成 0）；草渲交付待审（终渲未启动）。
+> **改造状态（2026-09-03 运动层重制）**：全片动效收敛至 frozen 运动层（`video/src/motion/`，跨集共享「怎么动」）；HarnessStack 系列装置落地（P0 开场落板+顶边常驻条+P6 收尾）；配音全量重合成（音频版本库入库，改稿只重配变更句）。
 > 选题：开源课程 [Learn Claude Code](https://learn.shareai.run/zh/s01/) 的「工具与执行」四章
 > —— s01 Agent Loop / s02 Tool Use / s03 Permission / s04 Hooks。
 > 形态：1080p30 横屏，代码动画图解 + 本人音色克隆旁白，无真人出镜、无 BGM。
@@ -11,17 +11,17 @@
 
 | 项 | 状态 |
 |---|---|
-| 逐字稿 | ✅ 170 句 / 4048 字 / 7 幕 |
+| 逐字稿 | ✅ 167 句 / 3979 字 / 7 幕（原「170 句/4048 字」为勘误——narration.json 实测口径） |
 | 分镜 | ✅ 39 镜，`check_script` 覆盖性 FAIL 0 |
 | 信源取证 | ✅ 12 条双轨信源入清单（8 条仓库 @ 固定提交 + 4 条站点），`source_ledger verify` FAIL 0 |
 | 场景实现 | ✅ 7 幕 / 39 镜，`tsc --noEmit` 通过；39 镜逐镜抽帧复检无黑帧、无重复帧 |
-| 配音 | ✅ 170/170 句，`sunny-steady` + `me-bright.wav`（`.engine` 签名 `indextts\|sunny-steady\|54b699cce97f`）；纯语音 13.20 分钟，**实测语速 307 字/分**；合成墙钟 2.1 h；2026-08-22 缓存随 `--update` 迁移复验 `tts --plan`：**待合成 0 句 / 已缓存 170 句**（画面优化零重合成）|
-| 时长双口径门 | ✅ 估算 14.5 分钟（4048 字 ÷ 280）· **实测含时距 14.2 分钟**，均落预算窗 13.0–14.6；`check` FAIL 0 WARN 0 |
-| 字幕 | ✅ `out/captions.srt` + `.vtt`，各 170 cue |
+| 配音 | ✅ 167/167 句，`sunny-steady` + `me-bright.wav`（`.engine` 签名 `indextts\|sunny-steady\|54b699cce97f`）；纯语音 12.95 分钟（2026-09-03 全量重合成，墙钟 1.6 h——旧缓存随 worktree 遗失，本次入库**音频版本库** `~/Library/Application Support/negentropy-influence/tts-store`，跨工作区改稿只重配变更句，回收幂等已 e2e 验证）|
+| 时长双口径门 | ✅ 估算 14.2 分钟（3979 字 ÷ 280）· **实测含时距 13.98 分钟**（838.8 秒 / 25164 帧；TTS 复跑漂移 -478 帧属正常 nondeterminism），均落预算窗 13.0–14.6；`check --check-scenes --check-motion` FAIL 0 WARN 0 |
+| 字幕 | ✅ `out/captions.srt` + `.vtt`，各 167 cue |
 | 主题对比度 | ✅ `--check-theme` FAIL 0（core 6.06 / mech 9.18 / deny 6.00 : 1，全过 4.5:1） |
 | 尾幕渐黑 | ✅ 末 beat 中部 0.085 → 前 24 帧 0.056 → 末帧 0.012，窗口贴合 beat 结尾（无提前收尾的长黑屏） |
-| 草渲 + 抽帧 QA | ✅ 25642 帧 / 6.0 分钟；7 幕 FAIL 0（WARN 1 为刻意设计：p6-06/07 信源卡停留；p0 画面凝住为 0-A 的 `freezeCursorAt` 设计，冻结帧指纹检测豁免） |
-| **终渲交付** | ✅ `out/final.mp4` **14:14.73** · 1920×1080 @30fps · h264 yuvj420p 201kb/s · aac 189kb/s · 42.6 MB（42,621,158 字节；末次重渲 7.9 分钟）<br>时长**可复算**：`total_duration_in_frames(narration.json, timing.json)` = 25642 帧 @30fps = 854.73s。narration / manifest / timing.json 本轮零改动 ⇒ 画面优化不改变时长，此数与首次交付一致<br>终渲全分辨率七幕抽帧 **FAIL 0 · WARN 1**（p0-09/10 帧指纹相同 = 0-D 标题卡跨两句静止，刻意）<br>**2026-08-22 画面优化版**（narration 与配音零改动，纯 tier-i 视觉增强 + `--update` 走查）：P6 三挂件卡物理咬合上环 + 信源卡增站点/双钉/实测口径诚实行；P0 走秒芯片（凝住即停）、轮次钢印 01/02/03、载荷箭头（命令/输出）；P5 环第 6 次出场 + 20–28 行实测基准带；1-D 诚实角注（站点教学版仍按停止标记）；3-C 三判定小抄（allow/ask/deny 各带载荷）；`📣`/`⚠` emoji 全部替换为绘制图形<br>**同日评审四修**（逐帧抽帧实证，见下方「评审修复」）：6-A 挂件卡文字朝向与落位、6-A 挂件卡**入场瞬态**压字幕安全带、5-B 基准带锚点与标注避让、3-C 小抄不再遮挡闸门名。末次重渲 473s，七幕抽帧复检 **FAIL 0 · WARN 1**（仍为 0-D 刻意静止） |
+| 草渲 + 抽帧 QA | ✅ 25164 帧；七幕中点 + **beat 头部连抽**（39 镜 × 4 帧，ISSUE-170 入场瞬态补盲）+ 末 6 句全量 **FAIL 0 · WARN 0**；A/B 对拍（基线=重制前代码、同 manifest）：167 帧中仅 2 帧 >5%（p0-01/p6-08 = HarnessStack 新装置），其余 ≤1.5% 且全部归因（顶边常驻条 / SceneTag 移位右上 / 令牌化缓动 / 硬门改淡入）|
+| **终渲交付** | ✅ `out/final.mp4` **13:58.80**（838.8 秒 / 25164 帧，与草渲同 manifest 同帧数）· 1920×1080 @30fps · 43.6 MB；`cover.png` = 标题卡帧 1031<br>时长**可复算**：`total_duration_in_frames(narration.json, timing.json)` = 25164 帧 @30fps = 838.8s<br>终渲全分辨率七幕抽帧 **FAIL 0 · WARN 1**（p0-09/10 帧指纹相同 = 0-D 标题卡跨两句静止，刻意）<br>**2026-08-22 画面优化版**（narration 与配音零改动，纯 tier-i 视觉增强 + `--update` 走查）：P6 三挂件卡物理咬合上环 + 信源卡增站点/双钉/实测口径诚实行；P0 走秒芯片（凝住即停）、轮次钢印 01/02/03、载荷箭头（命令/输出）；P5 环第 6 次出场 + 20–28 行实测基准带；1-D 诚实角注（站点教学版仍按停止标记）；3-C 三判定小抄（allow/ask/deny 各带载荷）；`📣`/`⚠` emoji 全部替换为绘制图形<br>**同日评审四修**（逐帧抽帧实证，见下方「评审修复」）：6-A 挂件卡文字朝向与落位、6-A 挂件卡**入场瞬态**压字幕安全带、5-B 基准带锚点与标注避让、3-C 小抄不再遮挡闸门名。末次重渲 473s，七幕抽帧复检 **FAIL 0 · WARN 1**（仍为 0-D 刻意静止） |
 | 交付件 | ✅ `final.mp4` + `captions.srt` + `captions.vtt` + `cover.png`（标题卡帧，1920×1080） |
 
 > 音画同步的验证方式：配音期间**分幕**用已合成的真实时长重算 beat 帧位并逐镜抽帧复检
@@ -44,9 +44,7 @@
 | 5-B `P5Stack.tsx` | 「20–28 行实测带」悬在 core 段上方约 60px | 带体锚在区间**上界** + `+90` 比柱底实距多 45px | 锚到下界 `yFor(20) + BAR_BASE`；标注移到带右侧（原位置撞四柱的 loop 行数） |
 | 3-C `P3Gates.tsx` | 闸门名「拒绝表 / 规则匹配」被 allow/ask/deny 小抄完全盖住 | 小抄 `top: 150` 与 `GateRouter` 的 `y - h - 18`（本幕 y≈243）相交 | 小抄整体上移到 `top: 56`，收在闸柱之上 |
 
-> 同轮修正两处**失实的交付数字**：时长 14:12.52 → **14:14.73**（narration / timing.json
-> 本轮零改动，`total_duration_in_frames` 复算恒为 25642 帧，画面改动不可能改变时长）；
-> 终渲抽帧 WARN 0 → **WARN 1**（0-D 标题卡跨两句静止，刻意）。这正是 ISSUE-168 的形态：
+> 同轮还将终渲抽帧 WARN 0 修正为 **WARN 1**（0-D 标题卡跨两句静止，刻意）。这正是 ISSUE-168 的形态：
 > 旧 `--scene` 单值 store 只查末幕，出来的「WARN 0」与「全幕通过」不可区分。
 
 ## 目录结构
@@ -63,6 +61,8 @@
 | `scripts/*.py` | 薄包装，转发到 [`../../pipeline/scripts/`](../../pipeline/scripts/) |
 | [video/](./video/) | Remotion 独立 pnpm 工程 |
 | `video/src/components/motifs.tsx` | 本集五个视觉母题（终端 / 环形循环 / 分发表 / 闸门 / 插槽） |
+| `video/src/motion/` | ★frozen 运动层（令牌/窗口/编排/12 运动模型 hooks——规格见 [skills/06 运动层](../../pipeline/skills/06-remotion-implementation.md)） |
+| `video/src/components/harness-stack.tsx` | 系列身份装置（P0 开场栈 / 顶边常驻条 / P6 收尾栈；层数据派生自 series.json） |
 | `out/` | 渲染产物（gitignored） |
 
 ## 复现流水线
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/script/storyboard.md b/apps/negentropy-influence/episodes/claude-code-explained-video/script/storyboard.md
index e23b84237..05b9accc0 100644
--- a/apps/negentropy-influence/episodes/claude-code-explained-video/script/storyboard.md
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/script/storyboard.md
@@ -13,72 +13,72 @@
 
 | 镜 | 句区间 | 画面 | 动效 |
 |---|---|---|---|
-| 0-A | p0-01..02 | 全屏终端窗口（`panel` 底 + `panelBorder` 框），顶栏三个灰点。命令打完光标变灰凝住；右侧对话框浮出 | 终端打字机（每字 2 帧）；命令打完后光标**停止闪烁并变灰**，画面凝住 0.6s；p0-02 三轮「复制→粘贴→回车→回贴」搬运弧线**加速**塞满灰色残影（节奏比旧版快一倍） |
-| 0-B | p0-03..05 | 全部搬运残影瞬间收束成一条外框线，包住一枚「模型」内核——**命名帧**：外框即Harness | 外框自四面向内合拢包住内核（spring）；「Harness」二字落框（serif 大字），英文 agentic harness 进角标；p0-05 官方引文条压上（"Claude Code is the harness, Claude is the model" 中英并列淡入） |
-| 0-C | p0-06..07 | Harness供给图：外框上长出五根辐条（文件 / 命令 / 权限 / 记忆 / 护栏），内侧连着模型内核 | p0-06 五根辐条逐根点亮（`mech` 辉光各 8 帧）；「记忆」那根先灰并浮「后面拆」小标；p0-07 外框整体轻旋一次，片名标题卡压入（`core` 色细线自中心向两侧生长） |
+| 0-A | p0-01..02 | 全屏终端窗口（`panel` 底 + `panelBorder` 框），顶栏三个灰点。命令打完光标变灰凝住；右侧对话框浮出 | 终端打字机（每字 2 帧）；命令打完后光标**停止闪烁并变灰**，画面凝住 0.6s；p0-02 三轮「复制→粘贴→回车→回贴」搬运弧线**加速**塞满灰色残影（节奏比旧版快一倍） ；`@stagger` `@progress`（系列栈落板错峰 + 搬运弧线等速行程——机械感是主题，用纯 progress） |
+| 0-B | p0-03..05 | 全部搬运残影瞬间收束成一条外框线，包住一枚「模型」内核——**命名帧**：外框即Harness | 外框自四面向内合拢包住内核（spring）；「Harness」二字落框（serif 大字），英文 agentic harness 进角标；p0-05 官方引文条压上（"Claude Code is the harness, Claude is the model" 中英并列淡入） ；`@spring` `@breathe` `@progress`（命名帧合拢为本集豁免运动层的签名镜头，弹簧直接驱动几何） |
+| 0-C | p0-06..07 | Harness供给图：外框上长出五根辐条（文件 / 命令 / 权限 / 记忆 / 护栏），内侧连着模型内核 | p0-06 五根辐条逐根点亮（`mech` 辉光各 8 帧）；「记忆」那根先灰并浮「后面拆」小标；p0-07 外框整体轻旋一次，片名标题卡压入（`core` 色细线自中心向两侧生长） ；`@stagger` `@spring` `@progress` |
 
 ## P1 一个循环，就是全部
 
 | 镜 | 句区间 | 画面 | 动效 |
 |---|---|---|---|
-| 1-A | p1-01..07 | **环形循环**（全片视觉锚）：`core` 色闭合轨道居中，轨道上四个节点「问模型 / 看回答 / 执行工具 / 填回结果」。右侧分出一支「停机」出口 | 轨道用 `interpolate` 描线成形（0→1，1.2s）；一个 `core` 光点沿轨匀速巡游（周期 2.5s）；讲到「有」时工具节点 `mech` 辉光脉冲一次并让光点继续，讲到「没有」时光点滑出到「停机」出口并定格 |
-| 1-B | p1-08..12 | 环形循环缩至左侧 40%，右侧展开五步编号列表 + 一个 `messages[]` 面板 | 五步逐句点亮（每句一条，`FadeUp` 12px）；每点亮一步，`messages[]` 面板**长高一格**并压入一个色块（用户句=dim / 模型回答=core / 工具结果=mech）；第五步点亮后一条弧线从列表尾弹回第二步 |
-| 1-C | p1-13..16 | 全屏代码卡：`agent_loop` 的真实骨架（mono，约 12 行精简版），右下角计数「23」 | 代码逐行渲染（每行 3 帧）；「二十三行」时行号列整体 `core` 辉光一次，计数器从 0 滚动到 23；p1-15/16 时画面左右分屏——左「模型：决定」右「脚手架：执行」，中间一条竖线 |
-| 1-D | p1-17..24 | 上半：模型回答的字符流从左向右逐字流出，其中一段 `mech` 色的「工具调用」块提前出现；下半：一个「停止原因」标记牌仍显示「进行中」，滞后一拍才翻牌 | 字符流以 12 字/秒流动；工具调用块出现时 `mech` 辉光；标记牌**延迟 25 帧**才翻转（视觉化「不可靠」）；p1-22 时标记牌打上 `deny` 色斜叉；p1-24 金句卡 `serif` 居中淡入 |
-| 1-E | p1-25..29 | **三相环升级**：主环上浮现三个相位标签（收集 / 行动 / 验证）交融旋转；一只「手」图标随时可插入环上任意点；右侧十格抽屉墙以角标清单形式一闪 | 三个相位标签沿环依次点亮并**保持同时可见**（交融感，非硬阶段）；p1-27 手图标落向环上一节点、环上光点被拨偏一档（人可打断）；p1-28/29 十格抽屉墙快速亮起（20ms/格）后整体退至 40% 亮度、State 字段清单进角标 |
-| 1-F | p1-30..32 | 环形循环的「停机」出口分岔成五条细支线，各标一个退出原因；随后五条支线淡为 `dim`，只留主环 | 支线逐条以 `interpolate` 描线（每句一条）；p1-32 时五条支线亮度降到 30% 并后移，主环 `core` 亮度不变——「它们是保护装置，不是骨架」 |
+| 1-A | p1-01..07 | **环形循环**（全片视觉锚）：`core` 色闭合轨道居中，轨道上四个节点「问模型 / 看回答 / 执行工具 / 填回结果」。右侧分出一支「停机」出口 | 轨道用 `interpolate` 描线成形（0→1，1.2s）；一个 `core` 光点沿轨匀速巡游（周期 2.5s）；讲到「有」时工具节点 `mech` 辉光脉冲一次并让光点继续，讲到「没有」时光点滑出到「停机」出口并定格 ；`@progress`（描线 decelerate + 出口滑出） |
+| 1-B | p1-08..12 | 环形循环缩至左侧 40%，右侧展开五步编号列表 + 一个 `messages[]` 面板 | 五步逐句点亮（每句一条，`FadeUp` 12px）；每点亮一步，`messages[]` 面板**长高一格**并压入一个色块（用户句=dim / 模型回答=core / 工具结果=mech）；第五步点亮后一条弧线从列表尾弹回第二步 ；`@stagger`（五步非均匀锚点显式五行） |
+| 1-C | p1-13..16 | 全屏代码卡：`agent_loop` 的真实骨架（mono，约 12 行精简版），右下角计数「23」 | 代码逐行渲染（每行 3 帧）；「二十三行」时行号列整体 `core` 辉光一次，计数器从 0 滚动到 23；p1-15/16 时画面左右分屏——左「模型：决定」右「脚手架：执行」，中间一条竖线 ；`@progress` |
+| 1-D | p1-17..24 | 上半：模型回答的字符流从左向右逐字流出，其中一段 `mech` 色的「工具调用」块提前出现；下半：一个「停止原因」标记牌仍显示「进行中」，滞后一拍才翻牌 | 字符流以 12 字/秒流动；工具调用块出现时 `mech` 辉光；标记牌**延迟 25 帧**才翻转（视觉化「不可靠」）；p1-22 时标记牌打上 `deny` 色斜叉；p1-24 金句卡 `serif` 居中淡入 ；`@progress`（打字机保持内联：按 toolIdx 分色切片） |
+| 1-E | p1-25..29 | **三相环升级**：主环上浮现三个相位标签（收集 / 行动 / 验证）交融旋转；一只「手」图标随时可插入环上任意点；右侧十格抽屉墙以角标清单形式一闪 | 三个相位标签沿环依次点亮并**保持同时可见**（交融感，非硬阶段）；p1-27 手图标落向环上一节点、环上光点被拨偏一档（人可打断）；p1-28/29 十格抽屉墙快速亮起（20ms/格）后整体退至 40% 亮度、State 字段清单进角标 ；`@stagger` `@spring` |
+| 1-F | p1-30..32 | 环形循环的「停机」出口分岔成五条细支线，各标一个退出原因；随后五条支线淡为 `dim`，只留主环 | 支线逐条以 `interpolate` 描线（每句一条）；p1-32 时五条支线亮度降到 30% 并后移，主环 `core` 亮度不变——「它们是保护装置，不是骨架」 ；`@stagger` |
 
 ## P2 加一个工具，只改一行
 
 | 镜 | 句区间 | 画面 | 动效 |
 |---|---|---|---|
-| 2-A | p2-01..04 | 环形循环留在左上角（缩小但**同色同线宽**）。主体是终端：模型的意图气泡「读这个文件」旁边，笨拙地拼出一条命令 | 意图气泡与命令行之间画一条「翻译」箭头，箭头上叠一个 `deny` 色的小计数「+1 层」；p2-02 打出两条拼接命令（读/写各一条）；p2-04 时命令里一个字符被高亮成 `deny` 并抖动（拼错） |
-| 2-B | p2-05..06 | 五张工具卡横排弹出（panel 底 + 编号，反枚举）+ 卡下官方五类分区标注；两个虚线空槽（执行/网页——官方地图另有） | 卡片 spring 弹入（仅编号染 mech）；分区小字浮现；两空槽淡入（`panelBorder` 虚线）；角标「官方内置五类：文件/搜索/执行/网页/代码智能」 |
-| 2-C | p2-07..10 | **字典分发表**：两列表格，左列工具名（mono），右列处理函数名。旁边一个前台号码簿的极简图形 | p2-07 表格框线描出；p2-08 逐行填入（每行 4 帧）；p2-09 一个「来电」光点从左飞入命中某一行 → 整行推入 `mech` 辉光 → 右列函数名弹出；p2-10 表格底部**多出一行空槽**，一条新映射滑入落槽 |
-| 2-D | p2-11..13 | 左右并置两段代码（前后两版），仅执行那一行不同 | 两段代码同时淡入，**逐行做同色对齐比对**；唯一不同的那一行左侧打 `mech` 竖标并整行高亮，其余行降到 40% 亮度；p2-13 时左上角环形循环 `core` 脉冲一次（强调"它没动"） |
-| 2-E | p2-14..16 | 模型一次吐出四个工具调用卡，排成一列等待 | 四张卡以 80ms 间隔落入队列；p2-15 左右分屏：左侧「排队」四卡依次亮（串行），右侧「并行」前三卡同时亮；p2-16 画面中央压入一行提示条（`core` 描边） |
-| 2-F | p2-17..24 | **真值表**：三列（工具 / 只读 / 能并行），五行（读文件、找文件、`ls`、`rm`、建任务） | p2-17 先只显示「只读」列并全部打勾（符合直觉）；p2-19 时 `ls` 与 `rm` 两行的「能并行」列**结论分岔**——`ls` 打 `mech` 勾、`rm` 打 `deny` 叉，两行之间画一条对撞线；p2-20 两行工具名同时闪一次（同名不同命）；p2-22 建任务行的「只读」叉与「能并行」勾同时亮起（更绕的反例）；p2-24 金句卡 |
-| 2-G | p2-25..26 | 一排五个工具调用块按原顺序排列，上方落下分组括号 | 括号自左向右扫描落位：前三块归入一个 `mech` 组（组内三块**同时**脉冲=并行），中间一块单独成组（单独脉冲=串行），末块再一组；组与组之间画顺序箭头 |
-| 2-H | p2-27..31 | 一个「输出」长条超出边框 → 变成文件图标 + 预览卡；随后「读文件」工具被单独框出并标「不许落盘」 | p2-27 长条超框部分被裁切并飞成文件图标；p2-29「读文件」卡外框变 `core` 并挂一枚「∞」标记；p2-30/31 形成**闭合循环箭头**（读→落盘→读→落盘），箭头每绕一圈加速一档、颜色向 `deny` 偏移，绕四圈后整体定格并压入「转不出来」字样 |
+| 2-A | p2-01..04 | 环形循环留在左上角（缩小但**同色同线宽**）。主体是终端：模型的意图气泡「读这个文件」旁边，笨拙地拼出一条命令 | 意图气泡与命令行之间画一条「翻译」箭头，箭头上叠一个 `deny` 色的小计数「+1 层」；p2-02 打出两条拼接命令（读/写各一条）；p2-04 时命令里一个字符被高亮成 `deny` 并抖动（拼错） ；`@progress` `@shake`（拼错抖动） |
+| 2-B | p2-05..06 | 五张工具卡横排弹出（panel 底 + 编号，反枚举）+ 卡下官方五类分区标注；两个虚线空槽（执行/网页——官方地图另有） | 卡片 spring 弹入（仅编号染 mech）；分区小字浮现；两空槽淡入（`panelBorder` 虚线）；角标「官方内置五类：文件/搜索/执行/网页/代码智能」 ；`@stagger` `@progress`（五卡弹入走 NumberedCard 的 motif 弹簧） |
+| 2-C | p2-07..10 | **字典分发表**：两列表格，左列工具名（mono），右列处理函数名。旁边一个前台号码簿的极简图形 | p2-07 表格框线描出；p2-08 逐行填入（每行 4 帧）；p2-09 一个「来电」光点从左飞入命中某一行 → 整行推入 `mech` 辉光 → 右列函数名弹出；p2-10 表格底部**多出一行空槽**，一条新映射滑入落槽 ；`@stagger` `@progress`（来电光点终点锚定 14f 显式时长） |
+| 2-D | p2-11..13 | 左右并置两段代码（前后两版），仅执行那一行不同 | 两段代码同时淡入，**逐行做同色对齐比对**；唯一不同的那一行左侧打 `mech` 竖标并整行高亮，其余行降到 40% 亮度；p2-13 时左上角环形循环 `core` 脉冲一次（强调"它没动"） ；`@progress` |
+| 2-E | p2-14..16 | 模型一次吐出四个工具调用卡，排成一列等待 | 四张卡以 80ms 间隔落入队列；p2-15 左右分屏：左侧「排队」四卡依次亮（串行），右侧「并行」前三卡同时亮；p2-16 画面中央压入一行提示条（`core` 描边） ；`@stagger`（队列弹簧为 map 内纯 spring+SPRING） |
+| 2-F | p2-17..24 | **真值表**：三列（工具 / 只读 / 能并行），五行（读文件、找文件、`ls`、`rm`、建任务） | p2-17 先只显示「只读」列并全部打勾（符合直觉）；p2-19 时 `ls` 与 `rm` 两行的「能并行」列**结论分岔**——`ls` 打 `mech` 勾、`rm` 打 `deny` 叉，两行之间画一条对撞线；p2-20 两行工具名同时闪一次（同名不同命）；p2-22 建任务行的「只读」叉与「能并行」勾同时亮起（更绕的反例）；p2-24 金句卡 ；`@impulse` `@stagger`（频闪标签包络淡入淡出） |
+| 2-G | p2-25..26 | 一排五个工具调用块按原顺序排列，上方落下分组括号 | 括号自左向右扫描落位：前三块归入一个 `mech` 组（组内三块**同时**脉冲=并行），中间一块单独成组（单独脉冲=串行），末块再一组；组与组之间画顺序箭头 ；`@stagger`（分组括号时点非均匀，走 prop） |
+| 2-H | p2-27..31 | 一个「输出」长条超出边框 → 变成文件图标 + 预览卡；随后「读文件」工具被单独框出并标「不许落盘」 | p2-27 长条超框部分被裁切并飞成文件图标；p2-29「读文件」卡外框变 `core` 并挂一枚「∞」标记；p2-30/31 形成**闭合循环箭头**（读→落盘→读→落盘），箭头每绕一圈加速一档、颜色向 `deny` 偏移，绕四圈后整体定格并压入「转不出来」字样 ；`@accelTravel` `@progress`（加速绕行累加器→模型，heat 驱动偏色） |
 
 ## P3 执行之前，先过闸门
 
 | 镜 | 句区间 | 画面 | 动效 |
 |---|---|---|---|
-| 3-A | p3-01..06 | 五张工具卡回归，其中四张外面套着一个 `mech` 色的「工作目录」框，跑命令那张**在框外** | p3-02 框线描出并把四张卡收进去，第五张卡留在框外并轻微抖动；p3-04 该卡吐出一条 `deny` 色命令，命令文字放大并使画面整体压暗一档；p3-05 环形循环的执行节点照常亮起（"老老实实替它执行"的反讽）；p3-06 一道竖线从顶部落下 |
-| 3-B | p3-07..09 | **闸门路由**成形：请求从左侧进入，前方三道竖闸依次落下（1 号 `deny` 描边、2 号 `mech`、3 号 `mech` 虚线） | 三道闸门以 `spring` 自上落下（每句一道）；p3-08 第一道闸门上浮出四个禁令词；p3-09 一个请求光点撞上第一道闸门被**反弹回左侧**并碎成 `deny` 色粒子 |
-| 3-C | p3-10..13 | 第二、三道闸门工作：一个请求穿过一道被标记，停在第三道前等待；另一个请求三道全过直接抵达执行口 | p3-10/11 请求光点穿过一闸后头顶浮出「看情况」标签；p3-12 第三道闸门前画面**整体降速并压暗**，弹出「工具名 + 参数」审批卡与 y/N 光标；p3-13 另一条通路上一个光点畅通无阻直达执行口，并在轨迹上留下 `core` 尾迹 |
-| 3-D | p3-14..19 | 拒绝表代码卡（mono，七个字符串）居中；随后表下方浮出原话引用 | p3-15 代码卡逐行渲染；p3-16/17 表的边框由 `deny` 变为 `dim` 虚线（"示意"而非"边界"的视觉降级）；p3-18 表右侧生成三条变体写法，逐条**绕过**表框飞向执行口；p3-19 金句卡 `serif` 居中 |
-| 3-E | p3-20..24 | 四个结果徽标呈四宫格：放行（`core`）、拒绝（`deny`）、问你（`mech`）、不表态（`dim` 描边） | p3-21 前三格先亮（对应三道闸门），第四格空着并有呼吸描边；p3-23 第四格亮起「不表态」；p3-24 从第四格拉出一条弧线**回连到「问你」格**，弧线上压「兜底」二字 |
-| 3-F | p3-25..29 | **官方求值顺序流水线**：拒绝 → 询问 → 放行 三站闸门横排，一枚请求光点沿轨道行进 | 三站以 spring 落下（顺序点亮，每站 7 帧）；「头一个命中，就出局」横幅压上；p3-27 光点在拒绝站被截获、`deny` 辉光 + 「出局」标签；p3-28 右下浮「裸名 deny → 整件工具从模型身上消失」（Bash 加删除线） |
-| 3-G | p3-30..35 | **auto 分类器视野分屏**：五行记录自上而下滚入（辩解 / 工具结果 / 调用描述 / 用户消息 / 裸命令），前三行被划除，末两行金色高亮 | p3-31 五行逐条滚入；p3-32 前三行依次划除并各浮移除理由；p3-33 末两行染 `core` 高亮 + 「只看这两条」；p3-34 反例帧：一条伪装「用户早就批准了」的文本飞向视野、被 `deny` 色边界弹回；p3-35 金句压底 + 遥测角标（93%，官方 2026-03） |
+| 3-A | p3-01..06 | 五张工具卡回归，其中四张外面套着一个 `mech` 色的「工作目录」框，跑命令那张**在框外** | p3-02 框线描出并把四张卡收进去，第五张卡留在框外并轻微抖动；p3-04 该卡吐出一条 `deny` 色命令，命令文字放大并使画面整体压暗一档；p3-05 环形循环的执行节点照常亮起（"老老实实替它执行"的反讽）；p3-06 一道竖线从顶部落下 ；`@progress` `@shake` |
+| 3-B | p3-07..09 | **闸门路由**成形：请求从左侧进入，前方三道竖闸依次落下（1 号 `deny` 描边、2 号 `mech`、3 号 `mech` 虚线） | 三道闸门以 `spring` 自上落下（每句一道）；p3-08 第一道闸门上浮出四个禁令词；p3-09 一个请求光点撞上第一道闸门被**反弹回左侧**并碎成 `deny` 色粒子 ；`@stagger` `@progress`（三闸 spring 落下走 SPRING） |
+| 3-C | p3-10..13 | 第二、三道闸门工作：一个请求穿过一道被标记，停在第三道前等待；另一个请求三道全过直接抵达执行口 | p3-10/11 请求光点穿过一闸后头顶浮出「看情况」标签；p3-12 第三道闸门前画面**整体降速并压暗**，弹出「工具名 + 参数」审批卡与 y/N 光标；p3-13 另一条通路上一个光点畅通无阻直达执行口，并在轨迹上留下 `core` 尾迹 ；`@progress`（审批卡淡入替代瞬现） |
+| 3-D | p3-14..19 | 拒绝表代码卡（mono，七个字符串）居中；随后表下方浮出原话引用 | p3-15 代码卡逐行渲染；p3-16/17 表的边框由 `deny` 变为 `dim` 虚线（"示意"而非"边界"的视觉降级）；p3-18 表右侧生成三条变体写法，逐条**绕过**表框飞向执行口；p3-19 金句卡 `serif` 居中 ；`@stagger` `@progress`（三条绕过变体错峰） |
+| 3-E | p3-20..24 | 四个结果徽标呈四宫格：放行（`core`）、拒绝（`deny`）、问你（`mech`）、不表态（`dim` 描边） | p3-21 前三格先亮（对应三道闸门），第四格空着并有呼吸描边；p3-23 第四格亮起「不表态」；p3-24 从第四格拉出一条弧线**回连到「问你」格**，弧线上压「兜底」二字 ；`@progress` `@breathe`（兜底弧描线内联合规红线三） |
+| 3-F | p3-25..29 | **官方求值顺序流水线**：拒绝 → 询问 → 放行 三站闸门横排，一枚请求光点沿轨道行进 | 三站以 spring 落下（顺序点亮，每站 7 帧）；「头一个命中，就出局」横幅压上；p3-27 光点在拒绝站被截获、`deny` 辉光 + 「出局」标签；p3-28 右下浮「裸名 deny → 整件工具从模型身上消失」（Bash 加删除线） ；`@stagger` `@progress`（三站 rail 结构保留 bespoke） |
+| 3-G | p3-30..35 | **auto 分类器视野分屏**：五行记录自上而下滚入（辩解 / 工具结果 / 调用描述 / 用户消息 / 裸命令），前三行被划除，末两行金色高亮 | p3-31 五行逐条滚入；p3-32 前三行依次划除并各浮移除理由；p3-33 末两行染 `core` 高亮 + 「只看这两条」；p3-34 反例帧：一条伪装「用户早就批准了」的文本飞向视野、被 `deny` 色边界弹回；p3-35 金句压底 + 遥测角标（93%，官方 2026-03） ；`@stagger` `@progress` |
 
 ## P4 挂在循环上，不写进循环里
 
 | 镜 | 句区间 | 画面 | 动效 |
 |---|---|---|---|
-| 4-A | p4-01..04 | 环形循环恢复居中（`core`，仍同色同线宽）。右侧列出三条「想加的东西」 | p4-02/03 三条需求以 `FadeUp` 依次浮现；p4-04 三条需求各射出一支箭头**扎进环形循环内部**，环的线宽被撑粗一档并出现 `deny` 色应力点 |
-| 4-B | p4-05..07 | 退化的循环代码卡：循环体内被塞进五行杂活 | 五行以每句 2 行的节奏插入，每插入一行代码卡**整体下移**并把最外层的 `while` 挤出可视区；p4-06 结束时代码卡边框变 `deny` 虚线；p4-07 金句卡覆盖上层 |
-| 4-C | p4-08..12 | 代码卡收回，五行杂活被「拔」出循环、变成五张回调卡浮在环外；环恢复原线宽 | p4-08 五行代码逐行飞出环外并变形为卡片（0.5s 形变）；p4-09/10 环外浮出「时机 → 函数列表」两列表格；p4-11/12 环与卡片之间出现四个插座图形，一张卡片「啪」地插入（`spring` 过冲 + 插入瞬间 `mech` 闪一帧） |
-| 4-D | p4-13..19 | **插槽注册板**：环形循环外围四个插槽，按一整轮的时间顺序分布在环的四个方位 | 四个插槽逐句亮起并各插入对应回调卡：p4-14 入口槽（补背景信息的卡片飞入并在消息上加一小块 `mech` 补丁）；p4-15/16 执行前槽——**P3 的三道闸门整体缩小、平移进这个槽**（跨幕视觉呼应），环上原本的检查标记同时消失；p4-17 执行后槽；p4-18/19 停机前槽亮 `core`，卡片返回一句话 → 一条回流箭头把它送回环的入口，环重新转起来 |
-| 4-E | p4-20..22 | 四个插槽同时点亮，环上标出四个时机点；环本身刻意**不加任何装饰** | 四点沿环依次脉冲一圈（顺时针，各 8 帧）；p4-21 环上只浮出四个极简的喇叭图标（"只喊一声"）；p4-22 金句卡；金句期间环继续匀速转动，不做任何强调动效——用"无动效"表达"故意保持无聊" |
-| 4-F | p4-23..25 | **31 事件 × 三层嵌套**（官方口径）：外层会话框（一次）套中层回合框（×N）套内层工具调用链（工具前→执行→工具后→整批落定）；右栏异步事件网格；右下计数徽章 | 外层成形→中层边框闪两下浮 ×N→内层虚线框内一个光点沿四节点链循环跑（80 帧一圈）；右栏 6 个异步事件逐条打出；计数从 0 滚到 31（官方文档事件表逐行计数） |
-| 4-G1 | p4-27..31 | **六道闸门流水线**（官方 SDK 权限判定图）：hook/deny/ask/settings/mode/默认 六站横排，两端 Execute/Blocked 终点 | 轨道描出→一枚「我批了」光点出发→行至 deny 站被截入 Blocked（`deny` 辉光+冲击波）；p4-31 切全放行模式重跑、光点仍在 deny 站被截 + 「全放行模式也一样：拒绝压得住」 |
-| 4-G2 | p4-32..34 | **印章对撞**（保留高潮母题）：「我批了」印章 vs 「禁止/询问」印章 + 单向箭头 | 印章落下对撞、持续抵抗抖动；单向箭头（只允许「加限制」方向）；金句卡「扩展点能加限制，不能解除限制」收口 |
-| 4-H | p4-35..37 | 「别停」插槽与环的一段形成小闭环，反复自激；随后一枚标记落下把闭环打断 | p4-36 小闭环连转三圈，每圈提速一档、边缘 `deny` 色渐强（自激失控感）；p4-37 一枚 `core` 色方形标记从上落下嵌入闭环，第四圈行进到标记处被**截断**，整体归于静止 |
+| 4-A | p4-01..04 | 环形循环恢复居中（`core`，仍同色同线宽）。右侧列出三条「想加的东西」 | p4-02/03 三条需求以 `FadeUp` 依次浮现；p4-04 三条需求各射出一支箭头**扎进环形循环内部**，环的线宽被撑粗一档并出现 `deny` 色应力点 ；`@stagger` `@progress`（辐条应力辉光 Math.max 钳制） |
+| 4-B | p4-05..07 | 退化的循环代码卡：循环体内被塞进五行杂活 | 五行以每句 2 行的节奏插入，每插入一行代码卡**整体下移**并把最外层的 `while` 挤出可视区；p4-06 结束时代码卡边框变 `deny` 虚线；p4-07 金句卡覆盖上层 ；`@progress`（量化舞台刻意离散） |
+| 4-C | p4-08..12 | 代码卡收回，五行杂活被「拔」出循环、变成五张回调卡浮在环外；环恢复原线宽 | p4-08 五行代码逐行飞出环外并变形为卡片（0.5s 形变）；p4-09/10 环外浮出「时机 → 函数列表」两列表格；p4-11/12 环与卡片之间出现四个插座图形，一张卡片「啪」地插入（`spring` 过冲 + 插入瞬间 `mech` 闪一帧） ；`@spring` `@stagger` `@progress`（插头咬合 = snap 轻过冲） |
+| 4-D | p4-13..19 | **插槽注册板**：环形循环外围四个插槽，按一整轮的时间顺序分布在环的四个方位 | 四个插槽逐句亮起并各插入对应回调卡：p4-14 入口槽（补背景信息的卡片飞入并在消息上加一小块 `mech` 补丁）；p4-15/16 执行前槽——**P3 的三道闸门整体缩小、平移进这个槽**（跨幕视觉呼应），环上原本的检查标记同时消失；p4-17 执行后槽；p4-18/19 停机前槽亮 `core`，卡片返回一句话 → 一条回流箭头把它送回环的入口，环重新转起来 ；`@stagger` `@progress`（插槽点亮） |
+| 4-E | p4-20..22 | 四个插槽同时点亮，环上标出四个时机点；环本身刻意**不加任何装饰** | 四点沿环依次脉冲一圈（顺时针，各 8 帧）；p4-21 环上只浮出四个极简的喇叭图标（"只喊一声"）；p4-22 金句卡；金句期间环继续匀速转动，不做任何强调动效——用"无动效"表达"故意保持无聊" ；`@progress`（刻意零动效的「无聊」表达） |
+| 4-F | p4-23..25 | **31 事件 × 三层嵌套**（官方口径）：外层会话框（一次）套中层回合框（×N）套内层工具调用链（工具前→执行→工具后→整批落定）；右栏异步事件网格；右下计数徽章 | 外层成形→中层边框闪两下浮 ×N→内层虚线框内一个光点沿四节点链循环跑（80 帧一圈）；右栏 6 个异步事件逐条打出；计数从 0 滚到 31（官方文档事件表逐行计数） ；`@stagger` `@progress`（六格异步事件墙） |
+| 4-G1 | p4-27..31 | **六道闸门流水线**（官方 SDK 权限判定图）：hook/deny/ask/settings/mode/默认 六站横排，两端 Execute/Blocked 终点 | 轨道描出→一枚「我批了」光点出发→行至 deny 站被截入 Blocked（`deny` 辉光+冲击波）；p4-31 切全放行模式重跑、光点仍在 deny 站被截 + 「全放行模式也一样：拒绝压得住」 ；`@stagger` `@progress`（六站管线 rail 保留 bespoke） |
+| 4-G2 | p4-32..34 | **印章对撞**（保留高潮母题）：「我批了」印章 vs 「禁止/询问」印章 + 单向箭头 | 印章落下对撞、持续抵抗抖动；单向箭头（只允许「加限制」方向）；金句卡「扩展点能加限制，不能解除限制」收口 ；`@progress`（对撞冲击波为周期包络，保留内联） |
+| 4-H | p4-35..37 | 「别停」插槽与环的一段形成小闭环，反复自激；随后一枚标记落下把闭环打断 | p4-36 小闭环连转三圈，每圈提速一档、边缘 `deny` 色渐强（自激失控感）；p4-37 一枚 `core` 色方形标记从上落下嵌入闭环，第四圈行进到标记处被**截断**，整体归于静止 ；`@accelTravel` `@progress`（自激闭环→模型，精确一致） |
 
 ## P5 四层叠起来是什么
 
 | 镜 | 句区间 | 画面 | 动效 |
 |---|---|---|---|
-| 5-A | p5-01..06 | 四层横向卡片：循环（`core` 实心）/ 分发表 / 闸门 / 插槽（后三者 `mech` 描边）；卡片上方 p5-05 落下**官方四件套标尺**（循环 / 工具 / 上下文管理 / 护栏） | 四张卡逐句自下弹入并水平排开；p5-05 标尺自上淡入落位；p5-06 三根竖连线把本集三层接到对应格（循环↔循环、分发表↔工具、插口↔护栏），「上下文管理」格虚线空置 + 「空着 · 后面拆」小标；随后第一张卡**留在原地并加实底**，后三张同时上浮 8px 并转为半透明——"骨架 vs 挂件"的视觉分层 |
-| 5-B | p5-07..10 | **四级台阶**：四段柱体高度递增（141/191/241/255），每根柱子内部有一段等高的 `core` 色块 | p5-08/09 四根柱体自左向右逐根升起（`spring`），柱顶数字滚动到位；p5-10 时四根柱子里的 `core` 色块**同时描出**——四段高度肉眼相同且色值相同，柱体其余部分降到 30% 亮度 |
-| 5-C | p5-11..14 | 环形循环回到画面中央（第五次出现，仍完全同色同线宽），执行节点位置换过四次写法的四个标签轮播 | p5-11/12 环上四个节点依次脉冲一圈；p5-13/14 执行节点上方的标签以 0.4s 间隔翻牌四次（写死命令 → 查表 → 闸门 → 插槽），**环本身一帧未变**；末尾金句卡 |
-| 5-D | p5-15..19 | 回到 P0 的终端画面（同构图），但这次命令自己跑了起来、输出自动回流；末尾英文原句金句卡 | p5-16 P0 的灰色搬运轨迹以 `core` 色重画一次（这次是自动的）；人形剪影淡出；p5-18 四层结构在终端外围合拢成一个壳；p5-19 英文原句 `serif` 与中文并列淡入 |
+| 5-A | p5-01..06 | 四层横向卡片：循环（`core` 实心）/ 分发表 / 闸门 / 插槽（后三者 `mech` 描边）；卡片上方 p5-05 落下**官方四件套标尺**（循环 / 工具 / 上下文管理 / 护栏） | 四张卡逐句自下弹入并水平排开；p5-05 标尺自上淡入落位；p5-06 三根竖连线把本集三层接到对应格（循环↔循环、分发表↔工具、插口↔护栏），「上下文管理」格虚线空置 + 「空着 · 后面拆」小标；随后第一张卡**留在原地并加实底**，后三张同时上浮 8px 并转为半透明——"骨架 vs 挂件"的视觉分层 ；`@progress`（四卡阵 stagger 为 map 内纯 spring+SPRING） |
+| 5-B | p5-07..10 | **四级台阶**：四段柱体高度递增（141/191/241/255），每根柱子内部有一段等高的 `core` 色块 | p5-08/09 四根柱体自左向右逐根升起（`spring`），柱顶数字滚动到位；p5-10 时四根柱子里的 `core` 色块**同时描出**——四段高度肉眼相同且色值相同，柱体其余部分降到 30% 亮度 ；`@progress`（基准带实测数据驱动） |
+| 5-C | p5-11..14 | 环形循环回到画面中央（第五次出现，仍完全同色同线宽），执行节点位置换过四次写法的四个标签轮播 | p5-11/12 环上四个节点依次脉冲一圈；p5-13/14 执行节点上方的标签以 0.4s 间隔翻牌四次（写死命令 → 查表 → 闸门 → 插槽），**环本身一帧未变**；末尾金句卡 ；`@progress`（翻牌离散保持内联） |
+| 5-D | p5-15..19 | 回到 P0 的终端画面（同构图），但这次命令自己跑了起来、输出自动回流；末尾英文原句金句卡 | p5-16 P0 的灰色搬运轨迹以 `core` 色重画一次（这次是自动的）；人形剪影淡出；p5-18 四层结构在终端外围合拢成一个壳；p5-19 英文原句 `serif` 与中文并列淡入 ；`@progress` |
 
 ## P6 收尾
 
 | 镜 | 句区间 | 画面 | 动效 |
 |---|---|---|---|
-| 6-A | p6-01..04 | 壳的四层分别点亮并各配一句短标签（手脚 / 工具 / 底线 / 发挥） | 四层以每句一层的节奏点亮，点亮时对应标签 `FadeUp`；四层齐亮后整体轻微收拢一次（呼吸） |
-| 6-B | p6-05..08 | 信源卡四行（官方文档+取数日期 / 工程博客 / 源码分析已逐处标注 / 数字均为实测口径）+ 版本护栏行 → 系列身份卡 + **下期预告卡**（标题只在画面；series.json 派生硬编码，规则 8 对账） → **渐黑** | 信源卡逐行浮现（mono 小字）；系列身份卡 `serif` 淡入；下期卡 `panel` 底描边框浮现（「下期 · 规划层」+ 标题）；**渐黑窗口从本 beat 的总时长推导**（`beatDurationInFrames`，红线四），末 1.2s 线性压暗到全黑 |
+| 6-A | p6-01..04 | 壳的四层分别点亮并各配一句短标签（手脚 / 工具 / 底线 / 发挥） | 四层以每句一层的节奏点亮，点亮时对应标签 `FadeUp`；四层齐亮后整体轻微收拢一次（呼吸） ；`@progress`（径向滑入时程钳制 SAFE_TOP_Y——ISSUE-170 结构化） |
+| 6-B | p6-05..08 | 信源卡四行（官方文档+取数日期 / 工程博客 / 源码分析已逐处标注 / 数字均为实测口径）+ 版本护栏行 → 系列身份卡 + **下期预告卡**（标题只在画面；series.json 派生硬编码，规则 8 对账） → **渐黑** | 信源卡逐行浮现（mono 小字）；系列身份卡 `serif` 淡入；下期卡 `panel` 底描边框浮现（「下期 · 规划层」+ 标题）；**渐黑窗口从本 beat 的总时长推导**（`beatDurationInFrames`，红线四），末 1.2s 线性压暗到全黑 ；`@spring` `@stagger` `@fadeOut`（渐黑窗口从 beat 总时长推导——红线四） |
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/package.json b/apps/negentropy-influence/episodes/claude-code-explained-video/video/package.json
index ca5fe3297..7f7d020ed 100644
--- a/apps/negentropy-influence/episodes/claude-code-explained-video/video/package.json
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/package.json
@@ -19,10 +19,5 @@
   "devDependencies": {
     "@types/react": "^19.0.0",
     "typescript": "^5.6.0"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild"
-    ]
   }
 }
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/pnpm-workspace.yaml b/apps/negentropy-influence/episodes/claude-code-explained-video/video/pnpm-workspace.yaml
index f2686ac7d..add822dbe 100644
--- a/apps/negentropy-influence/episodes/claude-code-explained-video/video/pnpm-workspace.yaml
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/pnpm-workspace.yaml
@@ -1,4 +1,9 @@
-# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的唯一理由。
+# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的首要理由。
 # pnpm 12 起仅靠 `--ignore-workspace` 不够：pnpm 仍会沿 packageManager 向上锚定到仓库根，
 # 用本工程的解析结果覆写根 pnpm-lock.yaml（overrides 全丢）且当场不报错。见 ISSUE-175。
 packages: []
+# pnpm 12 的构建脚本许可（package.json 的 pnpm.onlyBuiltDependencies 已不被读取，
+# 静默忽略会使安装以 ERR_PNPM_IGNORED_BUILDS 中断、node_modules 半残）。键名与取值
+# 与 `pnpm approve-builds esbuild --yes` 实际写入的形态逐字一致——勿改回旧键名。
+allowBuilds:
+  esbuild: true
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/scripts/motion.test.ts b/apps/negentropy-influence/episodes/claude-code-explained-video/video/scripts/motion.test.ts
new file mode 100644
index 000000000..5e29cab52
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/scripts/motion.test.ts
@@ -0,0 +1,141 @@
+/**
+ * 运动层纯函数单测——`node --test scripts/motion.test.ts`（Node ≥ 23.6 原生跑 TS）。
+ *
+ * 刻意放在 video/ 而非 src/：tsconfig include 只有 src（frozen，不为测试改动），
+ * 而本文件 import 需带 .ts 后缀（Node ESM 解析规则）——tsc 若收编会因
+ * allowImportingTsExtensions 未开而报错。src/ 的类型覆盖由 tsc --noEmit 全量保证，
+ * 本文件只测纯函数行为，不做类型承重。
+ *
+ * 只 import 纯模块（tokens/window/schedule——零 remotion/react 依赖）：
+ * hooks 是它们的薄包装，行为由 MotionGallery 目视 + 场景抽帧覆盖。
+ */
+import {strict as assert} from 'node:assert';
+import test from 'node:test';
+
+import {DUR, EASING_CP, EXIT_FACTOR, SAFE_TOP_Y, SPRING, clampRiseDist, dampingRatio, overshootPeak} from '../src/motion/tokens.ts';
+import {beatProgress, clamp01, progress, revealCharCount, win} from '../src/motion/window.ts';
+import {schedule} from '../src/motion/schedule.ts';
+
+// ── tokens ────────────────────────────────────────────────────────────
+
+test('时长标尺在 30fps 下相邻档可辨（≥1 帧差）', () => {
+  const v = Object.values(DUR) as number[];
+  for (let i = 1; i < v.length; i++) {
+    assert.ok(v[i] - v[i - 1] >= 1, `第 ${i} 档与前一档同帧数（伪选择）`);
+  }
+  assert.ok(v.length === 6);
+});
+
+test('ζ→过冲换算钉死：snap 轻过冲、settle 零过冲（直抄 dampingRatio 的反例护栏）', () => {
+  const zSnap = dampingRatio(SPRING.snap);
+  const zSettle = dampingRatio(SPRING.settle);
+  assert.ok(zSnap > 0.4 && zSnap < 0.9, `snap ζ=${zSnap}`);
+  // Mp = exp(-πζ/√(1-ζ²)) 是超出幅度；峰值 = 1 + Mp（ζ=0.6 → 峰值 ≈1.095）
+  assert.ok(overshootPeak(zSnap) > 1.02 && overshootPeak(zSnap) < 1.2, `snap 峰值 ${overshootPeak(zSnap)}`);
+  assert.ok(zSettle > 1, 'settle 须过阻尼');
+  assert.equal(overshootPeak(zSettle), 1);
+  // 反例：把设计系统的 ζ 当 damping 直填（0.8）→ ζ≈0.04、峰值≈1.88 暴力弹跳
+  const wrong = dampingRatio({damping: 0.8, stiffness: 100, mass: 1});
+  assert.ok(overshootPeak(wrong) > 1.8, `直抄 ζ 的峰值=${overshootPeak(wrong)}，必须被此断言抓住`);
+});
+
+test('缓动控制点合法（CSS 规则 x∈[0,1]，且 x(t) 数值单调——可作函数求值）', () => {
+  for (const cp of Object.values(EASING_CP)) {
+    const [x1, , x2] = cp;
+    assert.ok(x1 >= 0 && x1 <= 1 && x2 >= 0 && x2 <= 1, `x 越界：${cp}`);
+    // x1<x2 是充分不必要（M3 standard (0.2,0,0,1) 的 x2<x1 仍单调）——判据用导数采样
+    for (let i = 0; i <= 50; i++) {
+      const t = i / 50;
+      const dx =
+        3 * (1 - t) ** 2 * x1 + 6 * (1 - t) * t * (x2 - x1) + 3 * t * t * (1 - x2);
+      assert.ok(dx > -1e-9, `x(t) 非单调 @t=${t}：${cp}`);
+    }
+  }
+});
+
+test('出场快于入场系数与安全带口径为常量', () => {
+  assert.equal(EXIT_FACTOR, 0.4);
+  assert.equal(SAFE_TOP_Y, 920);
+});
+
+test('clampRiseDist：自下方入场行程不探进字幕安全带', () => {
+  assert.equal(clampRiseDist(120, 836), 84, 'ISSUE-170 实测几何：rest 836 → 行程封顶 84');
+  assert.equal(clampRiseDist(40, 836), 40, '未超限不动');
+  assert.equal(clampRiseDist(120, 960), 0, '落位已在安全带内 → 零行程（退化但安全）');
+});
+
+// ── window ────────────────────────────────────────────────────────────
+
+test('clamp01 / progress / win 的钳制语义', () => {
+  assert.equal(clamp01(-1), 0);
+  assert.equal(clamp01(2), 1);
+  assert.equal(progress(10, 10, 10), 0, '起点为 0');
+  assert.equal(progress(20, 10, 10), 1, '终点为 1');
+  assert.equal(progress(5, 10, 10), 0, '窗外前钳 0');
+  assert.equal(progress(99, 10, 10), 1, '窗外后钳 1');
+  assert.equal(win(0.5, [0.25, 0.75]), 0.5);
+  assert.equal(win(0.1, [0.25, 0.75]), 0);
+  assert.equal(win(0.9, [0.25, 0.75]), 1);
+  assert.equal(beatProgress(0, -30, 90), 1 / 3);
+});
+
+test('逐字揭示：cps 按实际 fps 换算并向下取整，framesPerChar 保持固定帧间隔', () => {
+  assert.equal(revealCharCount(29, 60, 12), 5);
+  assert.equal(revealCharCount(30, 60, 12), 6);
+  assert.equal(revealCharCount(30, 24, 12, 3), 10);
+  assert.equal(revealCharCount(30, 120, 12, 3), 10);
+});
+
+// ── schedule ──────────────────────────────────────────────────────────
+
+test('fit 模式：末项恰在窗口末完成、不外溢', () => {
+  const p = schedule(5, {dur: 10, fit: {total: 90}});
+  const last = p.starts[4] + p.dur;
+  assert.ok(last <= 90 + 1, `末项 ${last} 外溢`);
+  assert.ok(last >= 89, `末项 ${last} 未到窗口末`);
+});
+
+test('fit 装不下时缩子项时长，不外溢窗口（优先级：不外溢 > 最小步长 > 子项时长）', () => {
+  // total 30 时 (30-12)/7≈2.57 ≥ minStride=2 仍装得下；压到 24 才触发缩时长
+  const p = schedule(8, {dur: 12, fit: {total: 24}});
+  const last = p.starts[7] + p.dur;
+  assert.ok(last <= 24, `末项 ${last} 外溢`);
+  assert.ok(p.dur >= 3, '子项时长跌破下限');
+  assert.ok(p.dur < 12, '装不下却未缩子项时长');
+});
+
+test('fit 窗口连 1 帧子项也容不下时显式拒绝，不返回外溢计划', () => {
+  assert.throws(() => schedule(8, {dur: 12, fit: {total: 5}}), /fit\.total=5.*8/);
+});
+
+test('fit 可行极限先牺牲子项时长，仍完整落在窗口内', () => {
+  const p = schedule(8, {dur: 12, fit: {total: 8}});
+  assert.equal(p.dur, 1);
+  assert.equal(p.starts[7] + p.dur, 8);
+});
+
+test('lag 模式：Manim 语义 start[i] = i·dur·lag', () => {
+  const p = schedule(3, {dur: 10, lag: 0.5});
+  assert.deepEqual(p.starts, [0, 5, 10]);
+  assert.deepEqual(schedule(3, {dur: 10, lag: 0}).starts, [0, 0, 0], 'lag=0 须同刻齐动');
+});
+
+test('stride 模式与三选一守卫', () => {
+  assert.deepEqual(schedule(3, {dur: 5, stride: 4}).starts, [0, 4, 8]);
+  assert.throws(() => schedule(3, {dur: 5, stride: 4, lag: 1}));
+  assert.throws(() => schedule(3, {dur: 5, lag: 1, fit: {total: 40}}));
+});
+
+test('最小步长与空集', () => {
+  assert.deepEqual(schedule(0, {dur: 5, stride: 4}), {starts: [], dur: 5});
+  const p = schedule(2, {dur: 5, stride: 0}); // 非法步长 → 抬到下限
+  assert.ok(p.starts[1] - p.starts[0] >= 1);
+});
+
+test('起点取整且单调不减', () => {
+  const p = schedule(6, {dur: 7, fit: {total: 53}});
+  for (let i = 1; i < p.starts.length; i++) {
+    assert.ok(p.starts[i] >= p.starts[i - 1], '起点须单调不减');
+    assert.ok(Number.isInteger(p.starts[i]));
+  }
+});
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/components/harness-stack.tsx b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/components/harness-stack.tsx
new file mode 100644
index 000000000..c85c03085
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/components/harness-stack.tsx
@@ -0,0 +1,203 @@
+/** 系列身份装置：五层 Harness 栈——skills/06「系列身份视觉」规格的落地。
+ *
+ * 层序/层名/发布态/下集标题一律取 series-layers.json（build_narration 从
+ * series.json 派生——硬编码即漂移，规格原话）。注意 P6 下期卡内的**标题主段**
+ * 仍是硬编码字符串：check_series 规则 8 以 tsx 文本对账 series.json，数据化会
+ * 让那条门失明（两层口径：层短名走数据，标题主段走规则 8 的受检硬编码）。
+ *
+ * 两个组件：
+ *  - HarnessStackP0：开场编排（落板 → 本集层高亮呼吸 → 缩退淡出，末段交叉淡入常驻条）；
+ *  - HarnessBadge：P1–P6 的常驻顶边条（横向五 chip，y 12–48）。
+ *
+ * ⚠️ 形式对规格的一处适配（评审实测）：规格写「缩退左上角纵向角标（宽 ≤300）」，
+ * 但纵向角标（300×194）与既有各幕左上内容五处碰撞（P2 CornerRing 同坐标、P3 小抄、
+ * P5 标尺、P1 1-E 环、P6 标签）；全片唯一零碰撞的常驻区是**顶边 y<50 横条**——
+ * 所有幕的左上内容最早从 y=56 起。故常驻形式取顶边横条（紧贴上缘，不占字幕安全带
+ * 也不与 SceneTag 相干）。缩退以交叉淡出衔接，避免纵向→横向的形态跳变。
+ */
+import React from 'react';
+import {AbsoluteFill} from 'remotion';
+import {theme} from '../design/theme';
+import {DUR, useBreathe, useDim, useProgress, useStagger} from '../motion';
+import series from '../series-layers.json';
+
+export type Layer = {index: number; layer: string; title: string; published: boolean};
+
+export const LAYERS = series.layers as Layer[];
+export const ACTIVE_INDEX = series.activeIndex as number;
+export const NEXT_LAYER = LAYERS[ACTIVE_INDEX] ?? null; // P6 呼吸预告的层
+
+const STACK_CROSSFADE_FRAMES = 8;
+
+/** 开场全尺寸栈与常驻顶边条开始交叉淡化的局部帧。 */
+export const harnessStackCrossAt = (recedeAt: number): number =>
+  recedeAt + DUR.f6 - STACK_CROSSFADE_FRAMES;
+
+/** 单块层板。mode: full（开场全尺寸）/ chip（常驻顶边条）/ p6（收尾放大）。 */
+const Plate: React.FC<{
+  layer: Layer;
+  active: boolean;
+  dim: number;
+  glow?: number;
+  scale: 'full' | 'chip' | 'p6';
+}> = ({layer, active, dim, glow = 0, scale}) => {
+  const chip = scale === 'chip';
+  const h = chip ? 34 : scale === 'p6' ? 56 : 64;
+  const nameSize = chip ? 17 : scale === 'p6' ? 26 : 28;
+  const idSize = chip ? 12 : 17;
+  return (
+    <div
+      style={{
+        height: h,
+        width: '100%',
+        display: 'flex',
+        alignItems: 'center',
+        gap: chip ? 8 : 14,
+        padding: chip ? '0 12px' : '0 18px',
+        background: theme.panel,
+        border: `2px solid ${active ? theme.core : theme.panelBorder}`,
+        borderRadius: chip ? 8 : 12,
+        opacity: dim,
+        boxShadow: active
+          ? `0 0 ${10 + glow * 22}px ${theme.core}55, inset 0 0 ${glow * 10}px ${theme.core}22`
+          : undefined,
+      }}
+    >
+      <div
+        style={{
+          fontFamily: theme.mono,
+          fontSize: idSize,
+          color: active ? theme.core : theme.dim,
+          fontVariantNumeric: 'tabular-nums',
+        }}
+      >
+        {String(layer.index).padStart(2, '0')}
+      </div>
+      <div
+        style={{
+          fontFamily: theme.sans,
+          fontSize: nameSize,
+          fontWeight: active ? 600 : 400,
+          color: active ? theme.text : theme.dim,
+          letterSpacing: 2,
+        }}
+      >
+        {layer.layer}
+      </div>
+    </div>
+  );
+};
+
+/** 常驻顶边条：P1–P6（横向五 chip，y 12–48——见文件头形式适配说明）。 */
+export const HarnessBadge: React.FC<{style?: React.CSSProperties}> = ({style}) => (
+  <div
+    style={{
+      position: 'absolute',
+      left: 64,
+      top: 12,
+      display: 'flex',
+      flexDirection: 'row',
+      gap: 8,
+      ...style,
+    }}
+  >
+    {LAYERS.map((l) => (
+      <Plate key={l.index} layer={l} active={l.index === ACTIVE_INDEX} dim={l.index === ACTIVE_INDEX ? 1 : 0.55} scale="chip" />
+    ))}
+  </div>
+);
+
+/** P0 开场编排：自底向上落板（6 帧一层）→ 本集层高亮呼吸两次 → 其余压暗 55% →
+ *  缩退淡出（向左上收小；末 8 帧与常驻顶边条交叉淡入——衔接 P1 起的 HarnessBadge）。 */
+export const HarnessStackP0: React.FC<{recedeAt: number}> = ({recedeAt}) => {
+  const drops = useStagger(LAYERS.length, {at: 2, dur: DUR.f4, stride: 6, easing: 'decelerate'});
+  const hiAt = 2 + (LAYERS.length - 1) * 6 + DUR.f4 + 2;
+  const glowBreathe = useBreathe({period: 15, amp: 0.5, base: 0.5});
+  // 呼吸两次（30f）后收敛到 0.7 的持续高亮
+  const breathePhase = useProgress(hiAt + 30, DUR.f6);
+  const glow = glowBreathe * (1 - breathePhase) + 0.7 * breathePhase;
+  const dim = useDim({at: hiAt, to: 0.55, dur: DUR.f5});
+  const rec = useProgress(recedeAt, DUR.f6);
+  // 缩退：向左上收小 + 尾段淡出；常驻条同步交叉淡入（换形式不跳变）
+  const crossAt = harnessStackCrossAt(recedeAt);
+  const out = useProgress(crossAt, STACK_CROSSFADE_FRAMES);
+  const fullX = 730;
+  const fullY = 300;
+  const tx = fullX + (64 - fullX) * rec;
+  const ty = fullY + (12 - fullY) * rec;
+  const s = 1 - 0.55 * rec;
+  return (
+    <AbsoluteFill style={{pointerEvents: 'none'}}>
+      <HarnessBadge style={{opacity: out}} />
+      <div
+        style={{
+          position: 'absolute',
+          left: 0,
+          top: 0,
+          width: 460,
+          display: 'flex',
+          flexDirection: 'column',
+          gap: 10,
+          transform: `translate(${tx}px, ${ty}px) scale(${s})`,
+          transformOrigin: '0 0',
+          opacity: 1 - out,
+        }}
+      >
+        {LAYERS.slice()
+          .reverse()
+          .map((l) => {
+            // 自底向上落板：index 1（执行层，最底）最先动
+            const p = drops[l.index - 1];
+            const isHi = l.index === ACTIVE_INDEX;
+            return (
+              <div
+                key={l.index}
+                style={{
+                  opacity: p,
+                  transform: `translateY(${(1 - p) * 26}px)`,
+                }}
+              >
+                <Plate
+                  layer={l}
+                  active={isHi}
+                  dim={isHi ? 1 : dim}
+                  glow={isHi ? glow : 0}
+                  scale="full"
+                />
+              </div>
+            );
+          })}
+      </div>
+    </AbsoluteFill>
+  );
+};
+
+/** P6 收尾：栈重新放大居中；已发布层保持点亮（EP1 时即本集层）；下期层呼吸预告。 */
+export const HarnessStackP6: React.FC<{at: number; nextBreathAt: number}> = ({at, nextBreathAt}) => {
+  const enter = useStagger(LAYERS.length, {at, dur: DUR.f4, stride: 4, easing: 'decelerate'});
+  const breath = useBreathe({period: 40, amp: 0.5, base: 0.5});
+  const nextOn = useProgress(nextBreathAt, DUR.f5);
+  return (
+    <div style={{display: 'flex', flexDirection: 'column', gap: 8, width: 420}}>
+      {LAYERS.slice()
+        .reverse()
+        .map((l) => {
+          const p = enter[l.index - 1];
+          const isNext = NEXT_LAYER !== null && l.index === NEXT_LAYER.index;
+          const lit = l.published || l.index === ACTIVE_INDEX;
+          const glow = isNext ? nextOn * breath : 0;
+          return (
+            <div key={l.index} style={{opacity: p, transform: `translateY(${(1 - p) * 18}px)`}}>
+              <Plate
+                layer={l}
+                active={lit || (isNext && nextOn > 0.5)}
+                dim={lit || (isNext && nextOn > 0.5) ? 1 : 0.55}
+                glow={glow}
+                scale="p6"
+              />
+            </div>
+          );
+        })}
+    </div>
+  );
+};
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/components/motifs.tsx b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/components/motifs.tsx
index 32f01bf81..099f33ff3 100644
--- a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/components/motifs.tsx
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/components/motifs.tsx
@@ -74,8 +74,9 @@ export const Footnote: React.FC<{children: React.ReactNode; delay?: number}> = (
 export const SceneTag: React.FC<{chapter: string; tagline: string}> = ({chapter, tagline}) => {
   const frame = useCurrentFrame();
   const o = interpolate(frame, [6, 24], [0, 1], {extrapolateRight: 'clamp'});
+  // 右上：左上角让位给常驻 HarnessBadge（系列身份栈缩退位，harness-stack.tsx）
   return (
-    <div style={{position: 'absolute', left: 72, top: 64, opacity: o}}>
+    <div style={{position: 'absolute', right: 72, top: 64, textAlign: 'right', opacity: o}}>
       <div style={{fontFamily: theme.mono, fontSize: 26, color: theme.core, letterSpacing: 2}}>
         {chapter}
       </div>
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/gallery.tsx b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/gallery.tsx
new file mode 100644
index 000000000..a71737133
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/gallery.tsx
@@ -0,0 +1,265 @@
+/** MotionGallery——运动层的评审面（独立 Remotion 入口，不经 Root.tsx）。
+ *
+ * 用法（在 video/ 目录，.bin 直调防污染根 workspace）：
+ *   ./node_modules/.bin/remotion still src/motion/gallery.tsx MotionGallery \
+ *       out/motion-gallery.png --frame=30
+ *
+ * 全部模型 × 变体一屏可渲：秒级出图，供 token 校准轮逐格目视。
+ * 色板为本文件内字面量（dev 工具面，不进成片、不读 theme——保持 frozen 跨系列共享）。
+ */
+import React from 'react';
+import {AbsoluteFill, Composition, registerRoot} from 'remotion';
+import {
+  useAccelTravel,
+  useBreathe,
+  useCount,
+  useDim,
+  useDraw,
+  useEnter,
+  useFadeOut,
+  useFlowDash,
+  useImpulse,
+  usePushIn,
+  useReveal,
+  useShake,
+  useStagger,
+  useTravel,
+} from './hooks';
+
+const COLS = 5;
+const CW = 340;
+const CH = 230;
+const GAP = 18;
+
+/** dev 工具面字面量色板（与各集 theme 底座同值但刻意独立声明——不读 theme）。 */
+const C = {
+  bg: '#0E1116',
+  panel: '#171C26',
+  border: '#2A3242',
+  text: '#F2F5FA',
+  dim: '#9AA7B8',
+  core: '#D97757',
+  mech: '#64C4C0',
+  deny: '#EF6461',
+};
+
+/** 单元格壳：定位 + 角标。 */
+const Cell: React.FC<{i: number; name: string; children: React.ReactNode}> = ({i, name, children}) => (
+  <div
+    style={{
+      position: 'absolute',
+      left: 72 + (i % COLS) * (CW + GAP),
+      top: 96 + Math.floor(i / COLS) * (CH + GAP),
+      width: CW,
+      height: CH,
+      background: C.panel,
+      border: `2px solid ${C.border}`,
+      borderRadius: 12,
+    }}
+  >
+    <div
+      style={{
+        position: 'absolute',
+        inset: '28px 0 34px 0',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+      }}
+    >
+      {children}
+    </div>
+    <div style={{position: 'absolute', left: 12, bottom: 8, fontFamily: 'monospace', fontSize: 15, color: C.dim}}>
+      {name}
+    </div>
+  </div>
+);
+
+const Box: React.FC<{color?: string; w?: number; h?: number; style?: React.CSSProperties}> = ({
+  color = C.core,
+  w = 200,
+  h = 80,
+  style,
+}) => <div style={{width: w, height: h, background: C.panel, border: `2px solid ${color}`, borderRadius: 10, ...style}} />;
+
+// ── 每格一个组件：hooks 各归其位（Rules of Hooks 的最简守法形态） ────────
+
+const EnterCell: React.FC<{kind: Parameters<typeof useEnter>[0]}> = ({kind}) => {
+  const e = useEnter(kind, {});
+  return <Box style={{opacity: e.opacity, transform: e.transform}} />;
+};
+
+const StaggerCell: React.FC = () => {
+  const ps = useStagger(5, {dur: 5, fit: {total: 60}});
+  return (
+    <div style={{display: 'flex', gap: 10}}>
+      {ps.map((p, i) => (
+        <div
+          key={i}
+          style={{
+            width: 34,
+            height: 80,
+            background: C.panel,
+            border: `2px solid ${C.mech}`,
+            borderRadius: 8,
+            opacity: p,
+            transform: `translateY(${(1 - p) * 14}px)`,
+          }}
+        />
+      ))}
+    </div>
+  );
+};
+
+const DrawCell: React.FC = () => {
+  const d = useDraw(0, 24);
+  return (
+    <svg width={280} height={110}>
+      <path {...d} d="M10 90 C 90 10, 190 100, 270 20" stroke={C.core} strokeWidth={5} fill="none" strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ImpulseCell: React.FC = () => {
+  const g = useImpulse({dur: 30, peak: 1});
+  return (
+    <div
+      style={{
+        width: 90,
+        height: 90,
+        borderRadius: '50%',
+        background: C.core,
+        opacity: 0.3 + 0.7 * g,
+        boxShadow: `0 0 ${10 + 30 * g}px ${C.core}`,
+      }}
+    />
+  );
+};
+
+const BreatheCell: React.FC = () => {
+  const b = useBreathe({period: 30});
+  return (
+    <svg width={160} height={110}>
+      <circle cx={80} cy={55} r={40} fill="none" stroke={C.mech} strokeWidth={5} opacity={b} />
+    </svg>
+  );
+};
+
+const TravelCell: React.FC = () => {
+  const t = useTravel({cx: 140, cy: 55, r: 42, secPerLap: 3});
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} />
+      <circle cx={t.x} cy={t.y} r={9} fill={C.core} />
+    </svg>
+  );
+};
+
+const AccelCell: React.FC = () => {
+  const t = useAccelTravel({cx: 140, cy: 55, r: 42, durs: [28, 20, 14], at: 4});
+  const heat = `rgb(${217 + Math.round(38 * t.heat)}, ${119 - Math.round(60 * t.heat)}, ${87 - Math.round(20 * t.heat)})`;
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} strokeDasharray="4 6" />
+      <circle cx={t.x} cy={t.y} r={9} fill={heat} />
+    </svg>
+  );
+};
+
+const CountCell: React.FC = () => {
+  const v = useCount({to: 255, dur: 40});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 44, color: C.text, fontVariantNumeric: 'tabular-nums'}}>
+      {Math.round(v)}
+    </div>
+  );
+};
+
+const RevealCell: React.FC = () => {
+  const s = useReveal('while (true) { think(); act(); }', {cps: 14});
+  const blink = useBreathe({period: 16, amp: 0.5, base: 0.5});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 20, color: C.text, whiteSpace: 'nowrap'}}>
+      {s}
+      <span style={{opacity: blink}}>▍</span>
+    </div>
+  );
+};
+
+const PushInCell: React.FC = () => {
+  const t = usePushIn(0, {scale: 0.12});
+  return <Box w={160} h={90} color={C.mech} style={{transform: t}} />;
+};
+
+const DimCell: React.FC = () => {
+  const dim = useDim({at: 40, to: 0.35});
+  return (
+    <div style={{display: 'flex', gap: 12}}>
+      <Box w={64} h={80} style={{opacity: dim}} />
+      <Box w={64} h={80} color={C.core} />
+      <Box w={64} h={80} style={{opacity: dim}} />
+    </div>
+  );
+};
+
+const FlowCell: React.FC = () => {
+  const f = useFlowDash({period: 24});
+  return (
+    <svg width={280} height={60}>
+      <line x1={10} y1={30} x2={270} y2={30} stroke={C.mech} strokeWidth={5} {...f} strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ShakeCell: React.FC = () => {
+  const x = useShake({at: 10, amp: 5, decay: true, dur: 40});
+  return <Box w={150} h={80} color={C.deny} style={{transform: `translateX(${x}px)`}} />;
+};
+
+const FadeCell: React.FC = () => {
+  const op = useFadeOut(90, {frames: 36});
+  return (
+    <div style={{position: 'relative', width: 220, height: 90}}>
+      <Box w={220} h={90} color={C.core} style={{position: 'absolute', inset: 0}} />
+      <div style={{position: 'absolute', inset: 0, background: '#000', opacity: 1 - op}} />
+    </div>
+  );
+};
+
+const CELLS: Array<[string, React.ReactNode]> = [
+  ['enter:fall', <EnterCell kind="fall" />],
+  ['enter:rise', <EnterCell kind="rise" />],
+  ['enter:slideL', <EnterCell kind="slideL" />],
+  ['enter:pop', <EnterCell kind="pop" />],
+  ['enter:flyIn', <EnterCell kind="flyIn" />],
+  ['enter:fade', <EnterCell kind="fade" />],
+  ['stagger×5 fit60', <StaggerCell />],
+  ['draw 24f', <DrawCell />],
+  ['impulse 30f', <ImpulseCell />],
+  ['breathe p30', <BreatheCell />],
+  ['travel 3s/lap', <TravelCell />],
+  ['accelTravel', <AccelCell />],
+  ['count→255', <CountCell />],
+  ['reveal 14cps', <RevealCell />],
+  ['pushIn .12', <PushInCell />],
+  ['dim .35@40', <DimCell />],
+  ['flowDash p24', <FlowCell />],
+  ['shake decay', <ShakeCell />],
+  ['fadeOut 36f', <FadeCell />],
+];
+
+const MotionGallery: React.FC = () => (
+  <AbsoluteFill style={{background: C.bg}}>
+    <div style={{position: 'absolute', left: 72, top: 44, fontFamily: 'monospace', fontSize: 24, color: C.text}}>
+      MotionGallery · 30fps · 120f
+    </div>
+    {CELLS.map(([name, node], i) => (
+      <Cell key={name} i={i} name={name}>
+        {node}
+      </Cell>
+    ))}
+  </AbsoluteFill>
+);
+
+registerRoot(() => (
+  <Composition id="MotionGallery" component={MotionGallery} width={1920} height={1080} fps={30} durationInFrames={120} defaultProps={{}} />
+));
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/hooks.ts b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/hooks.ts
new file mode 100644
index 000000000..f87b8a129
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/hooks.ts
@@ -0,0 +1,303 @@
+/** 运动模型（hooks）——分镜「动效」列动词到帧数学的唯一映射。
+ *
+ * 设计约束（违反任何一条即失去本层存在意义）：
+ * 1. hooks 返回数值 / CSS 片段，不渲染 DOM——FadeUp 式包装组件打不进 svg/<g>/
+ *    absolute 布局，是「组件存在却零调用」的实测根因；数值可落进任意 JSX。
+ * 2. 弹簧一律吃局部帧（frame - at）：spring() 每次调用从第 0 帧重模拟，喂全局帧
+ *    会让长片末帧每个 spring 跑两万余次迭代。
+ * 3. effects（不透明度/颜色）永不吃弹簧——一律时长+缓动（tokens 的二分不变量）。
+ * 4. 不读 theme：颜色一律经参数传入（frozen 跨系列共享的前提）。
+ * 5. `at` 锚点一律来自句边界（rel(beat, '句id')），禁写死帧数。
+ */
+import {Easing, interpolate, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {
+  DUR,
+  EASING_CP,
+  SPRING,
+  clampRiseDist,
+  type DurToken,
+  type EasingToken,
+  type SpringPreset,
+} from './tokens';
+import {progress, revealCharCount} from './window';
+import {schedule, type ScheduleOpts} from './schedule';
+
+/** 帧数解析：token 或直接帧数；缺省用 def。 */
+export const frames = (d: number | DurToken | undefined, def: number): number =>
+  d === undefined ? def : typeof d === 'number' ? d : DUR[d];
+
+/** 缓动令牌 → Remotion 缓动函数（linear 直通）。 */
+export const easeF = (t: EasingToken): ((x: number) => number) =>
+  t === 'linear'
+    ? Easing.linear
+    : Easing.bezier(
+        ...(EASING_CP[t] as [number, number, number, number]),
+      );
+
+/** 缓动后的 0..1 进度（各模型共用的原子）。 */
+const eased = (
+  frame: number,
+  at: number,
+  dur: number,
+  e: EasingToken,
+): number => interpolate(progress(frame, at, dur), [0, 1], [0, 1], {easing: easeF(e)});
+
+/** 缓动数值进度——「clamped 0→1 手写 interpolate」惯用形的统一替身：
+ *  时机值走 token，缓动默认 standard（线性原版会被这一档替换——质量提升点之一）。 */
+export function useProgress(
+  at: number,
+  dur: number | DurToken = DUR.f5,
+  easing: EasingToken = 'standard',
+): number {
+  const frame = useCurrentFrame();
+  return eased(frame, at, frames(dur, DUR.f5), easing);
+}
+
+/** 弹簧数值进度（驱动几何量/位移；effects 通道用 useProgress——tokens 二分不变量）。
+ *  局部帧 + 可选 durationInFrames 截停（防窗口外余振；缺省不设上限，与既有手写等价）。 */
+export function useSpring(
+  preset: SpringPreset,
+  o: {at?: number; dur?: number | DurToken} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const cfg: Parameters<typeof spring>[0] = {
+    frame: frame - (o.at ?? 0),
+    fps,
+    config: SPRING[preset],
+  };
+  if (o.dur !== undefined) {
+    cfg.durationInFrames = frames(o.dur, DUR.f5);
+  }
+  return spring(cfg);
+}
+
+// ── 入场（enter：落下/上浮/滑入/弹出/飞入/淡入） ────────────────────────
+
+export type EnterKind = 'fall' | 'rise' | 'slideL' | 'slideR' | 'pop' | 'flyIn' | 'fade';
+export type EnterOpts = {
+  /** 句边界锚（局部帧）。 */
+  at?: number;
+  dur?: number | DurToken;
+  easing?: EasingToken;
+  /** 空间通道用弹簧（位移类才有意义；fade/pop 无效）。 */
+  springPreset?: SpringPreset;
+  /** 位移像素（fall/rise/slide*；缺省 30）。 */
+  dist?: number;
+  /** rise 专用：落位态底边 y——行程经 clampRiseDist 钳进字幕安全带之上。 */
+  restBottom?: number;
+};
+export type EnterStyle = {opacity: number; transform: string};
+
+export function useEnter(kind: EnterKind, o: EnterOpts = {}): EnterStyle {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const at = o.at ?? 0;
+  const dur = frames(o.dur, DUR.f4);
+  let dist = o.dist ?? 30;
+  if (kind === 'rise' && o.restBottom !== undefined) {
+    dist = clampRiseDist(dist, o.restBottom);
+  }
+  // effects 通道：纯缓动、略快于空间通道（元素先「看见」再「落位」）
+  const opacity = progress(frame, at, Math.max(2, Math.round(dur * 0.8)));
+  // spatial 通道：可选弹簧（局部帧 + durationInFrames 截停，防窗口外余振）
+  const p = o.springPreset
+    ? spring({
+        frame: frame - at,
+        fps,
+        config: SPRING[o.springPreset],
+        durationInFrames: dur,
+      })
+    : eased(frame, at, dur, o.easing ?? 'standard');
+  const inv = 1 - p;
+  const t: string[] = [];
+  if (kind === 'fall') t.push(`translateY(${-inv * dist}px)`);
+  if (kind === 'rise') t.push(`translateY(${inv * dist}px)`);
+  if (kind === 'slideL') t.push(`translateX(${-inv * dist}px)`);
+  if (kind === 'slideR') t.push(`translateX(${inv * dist}px)`);
+  if (kind === 'pop') t.push(`scale(${0.9 + 0.1 * p})`);
+  if (kind === 'flyIn') t.push(`scale(${0.6 + 0.4 * p})`);
+  return {opacity, transform: t.length ? t.join(' ') : 'none'};
+}
+
+// ── 序列错峰（stagger：依次/逐行/逐条/逐格） ───────────────────────────
+
+export type StaggerOpts = ScheduleOpts & {at?: number; easing?: EasingToken};
+
+/** 返回 n 个 0..1 进度——第 i 项随编排依次入场。 */
+export function useStagger(n: number, o: StaggerOpts = {}): number[] {
+  const frame = useCurrentFrame();
+  const {at = 0, easing = 'standard'} = o;
+  const plan = schedule(n, o);
+  return plan.starts.map((s) => eased(frame, at + s, plan.dur, easing));
+}
+
+// ── 描线（draw：红线三由构造保证——只产 pathLength 归一化三元组） ────────
+
+export type DrawProps = {pathLength: 1; strokeDasharray: 1; strokeDashoffset: number};
+
+export function useDraw(at: number, dur: number | DurToken = DUR.f5): DrawProps {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(dur, DUR.f5), 'decelerate');
+  return {pathLength: 1, strokeDasharray: 1, strokeDashoffset: 1 - p};
+}
+
+// ── 脉冲 / 呼吸（glow 语法：impulse=一次性强调，breathe=持续辉光） ───────
+
+/** 一次性冲击：sin(πp) 包络，起于 0 归于 0，峰值 peak。 */
+export function useImpulse(o: {at?: number; dur?: number | DurToken; peak?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const p = progress(frame, o.at ?? 0, frames(o.dur, DUR.f5));
+  return Math.sin(Math.PI * p) * (o.peak ?? 1);
+}
+
+/** 持续呼吸（原 0.55+0.45·sin(frame/K) 散写的收敛；period 帧一周期——注意与
+ *  原除数 K 的换算 period = 2πK，如 sin(frame/26) → period 163）。offset 为相位
+ *  平移（错峰辉光的 per-index 形态）。 */
+export function useBreathe(
+  o: {period?: number; amp?: number; base?: number; offset?: number} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {amp = 0.45, base = 0.55, period = 26, offset = 0} = o;
+  return base + amp * Math.sin((2 * Math.PI * (frame - offset)) / period);
+}
+
+// ── 巡游（travel：环形为主；absorb 原 useRingDot 与加速绕行累加器克隆） ──
+
+export type TravelPos = {x: number; y: number; angle: number};
+
+/** 匀速环形巡游（angle 单位度，-90 = 12 点方向起）。 */
+export function useTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  secPerLap?: number;
+  offset?: number;
+}): TravelPos {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const lap = (frame / (fps * (o.secPerLap ?? 2.5)) + (o.offset ?? 0)) % 1;
+  const a = -90 + lap * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), angle: a};
+}
+
+/** 加速绕行：逐圈时长 durs[]（如 [40,30,22,16]），跑完全部圈后冻结在终点。
+ *  heat 0..1 随圈数推进（「失控感」的配色偏移系数）。 */
+export function useAccelTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  durs: number[];
+  at?: number;
+  heatPerLap?: number;
+}): {x: number; y: number; heat: number} {
+  const frame = useCurrentFrame();
+  let t = Math.max(0, frame - (o.at ?? 0));
+  let lap = 0;
+  while (lap < o.durs.length && t >= o.durs[lap]) {
+    t -= o.durs[lap];
+    lap += 1;
+  }
+  const within = lap >= o.durs.length ? 1 : t / o.durs[lap];
+  const heat = Math.min(1, lap / (o.heatPerLap ?? o.durs.length));
+  const a = -90 + within * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), heat};
+}
+
+// ── 计数 / 水位（meter 语法；显示层自行 Math.round / toFixed） ──────────
+
+export function useCount(o: {
+  from?: number;
+  to: number;
+  at?: number;
+  dur?: number | DurToken;
+  ease?: EasingToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {from = 0, to, at = 0} = o;
+  const p = eased(frame, at, frames(o.dur, DUR.f6), o.ease ?? 'standard');
+  return from + (to - from) * p;
+}
+
+// ── 打字机 / 逐字流出（type；Terminal 之外的泛化） ──────────────────────
+
+export function useReveal(
+  text: string,
+  o: {at?: number; cps?: number; framesPerChar?: number} = {},
+): string {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const elapsed = Math.max(0, frame - (o.at ?? 0));
+  const n = revealCharCount(elapsed, fps, o.cps ?? 12, o.framesPerChar);
+  return text.slice(0, Math.min(text.length, n));
+}
+
+// ── 镜头推近（pushIn 语法：beat 切换的镜头语言，替代纯淡入） ────────────
+
+export function usePushIn(at: number, o: {scale?: number; dur?: number | DurToken} = {}): string {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(o.dur, DUR.f5), 'decelerate');
+  return `scale(${1 + (o.scale ?? 0.06) * p})`;
+}
+
+// ── 压暗 / 提亮（emphasis 反向：让主体从群像中浮出） ─────────────────────
+
+/** 返回目标透明度系数（1 = 原；to 0.4 即压暗到 40%）。 */
+export function useDim(o: {at: number; to?: number; dur?: number | DurToken}): number {
+  const frame = useCurrentFrame();
+  const p = eased(frame, o.at, frames(o.dur, DUR.f4), 'standard');
+  return 1 + ((o.to ?? 0.4) - 1) * p;
+}
+
+// ── 流光（flow 语法：连线上的行进虚线） ─────────────────────────────────
+
+/** 返回可直接展开到 <line>/<path> 的描边属性（像素 dasharray——与 draw 的
+ *  pathLength 归一化描线是两个正交特性，勿混用于同一元素：红线三）。 */
+export function useFlowDash(o: {
+  dash?: number;
+  gap?: number;
+  /** 帧速率：每 period 帧行进一个 dash+gap 周期。 */
+  period?: number;
+}): {strokeDasharray: string; strokeDashoffset: number} {
+  const frame = useCurrentFrame();
+  const {dash = 10, gap = 14, period = 40} = o;
+  return {
+    strokeDasharray: `${dash} ${gap}`,
+    strokeDashoffset: -(frame * (dash + gap)) / period,
+  };
+}
+
+// ── 抖动（错误/故障语义；收敛 P2/P3 两处克隆） ──────────────────────────
+
+/** 返回 translateX 像素值。active 缺省 true；decay=true 时按 dur 衰减归零。 */
+export function useShake(o: {
+  at: number;
+  active?: boolean;
+  amp?: number;
+  /** 相位分母（原手写 /1.6、/2.2 的口径）。 */
+  freq?: number;
+  decay?: boolean;
+  dur?: number | DurToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {amp = 3, freq = 1.6} = o;
+  const t = frame - o.at;
+  if (o.active === false || t < 0) {
+    return 0;
+  }
+  if (o.decay) {
+    const env = 1 - progress(frame, o.at, frames(o.dur, DUR.f5));
+    return amp * env * Math.sin(t / freq);
+  }
+  return amp * Math.sin(t / freq);
+}
+
+// ── 片尾渐黑（红线四：从 beat 总时长推导，勿用末句时长） ────────────────
+
+export function useFadeOut(durationInFrames: number, o: {frames?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const f = o.frames ?? 36; // 1.2s
+  return 1 - progress(frame, durationInFrames - f, f);
+}
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/index.ts b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/index.ts
new file mode 100644
index 000000000..97fd22a5c
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/index.ts
@@ -0,0 +1,5 @@
+/** 运动层门面——场景代码统一 `import {...} from '../motion'`。 */
+export * from './tokens';
+export * from './window';
+export * from './schedule';
+export * from './hooks';
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/schedule.ts b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/schedule.ts
new file mode 100644
index 000000000..5703e3315
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/schedule.ts
@@ -0,0 +1,65 @@
+/** 错峰编排（stagger）纯函数——收敛手写 `frame - i*N`（跨 8 集约 356 处、
+ *  步长 K∈{2,3,4,5,6,8,10} 任意取值、无节奏标尺）。
+ *
+ * 三种模式（互斥，参数即文档）：
+ * - stride：固定步长（与旧手写行为一致——迁移期的保守选项）；
+ * - lag：Manim LaggedStart 语义 start[i] = i·dur·lagRatio（0 = 同刻齐动，1 = 首尾相接）；
+ * - fit：n 个子项恰好装进窗口 total（末项恰在窗口末完成——「随句推进」的首选）。
+ *
+ * 钳制优先级（motion.test.ts 钉死，自左向右）：不外溢窗口 > 最小步长 > 子项时长。
+ * 窗口属于 beat 时间轴，外溢会踩进下一 beat；装不下时先缩子项时长，连 1 帧
+ * 子项都无法错开时显式抛错，不返回违反 fit 契约的计划。
+ */
+export type ScheduleOpts = {
+  /** 子项时长（帧；缺省 DUR.f3=5——「快速子项」档）。 */
+  dur?: number;
+  /** 模式一：固定步长。 */
+  stride?: number;
+  /** 模式二：lag 比率（Manim lag_ratio）。 */
+  lag?: number;
+  /** 模式三：拟装入的窗口总长（帧）。 */
+  fit?: {total: number};
+  /** 相邻起点期望下限，默认 2 帧；fit 紧窗时可按优先级退至 1 帧。 */
+  minStride?: number;
+  /** 子项时长期望下限，默认 3 帧；fit 为守住窗口可退至 1 帧。 */
+  minDur?: number;
+};
+export type Schedule = {starts: number[]; dur: number};
+
+export function schedule(n: number, o: ScheduleOpts): Schedule {
+  const minStride = o.minStride ?? 2;
+  const minDur = o.minDur ?? 3;
+  const modes = [o.stride !== undefined, o.lag !== undefined, o.fit !== undefined].filter(
+    Boolean,
+  ).length;
+  if (modes > 1) {
+    throw new Error('schedule: stride / lag / fit 三选一');
+  }
+  let dur = Math.max(minDur, o.dur ?? 5);
+  if (n <= 0) {
+    return {starts: [], dur};
+  }
+  let stride: number;
+  if (o.fit) {
+    const total = Math.max(1, o.fit.total);
+    if (n > 1 && total < n) {
+      throw new Error(
+        `schedule: fit.total=${total} 无法容纳 ${n} 个至少 1 帧且起点间隔至少 1 帧的子项`,
+      );
+    }
+    dur = Math.min(dur, total);
+    stride = n === 1 ? 0 : (total - dur) / (n - 1);
+    const targetStride = Math.max(1, minStride);
+    if (n > 1 && stride < targetStride) {
+      // 先缩时长争取期望步长；仍不足时牺牲步长，但至少保留 1 帧先后。
+      dur = Math.max(1, Math.min(dur, total - targetStride * (n - 1)));
+      stride = (total - dur) / (n - 1);
+    }
+  } else if (o.lag !== undefined) {
+    stride = dur * o.lag;
+  } else {
+    stride = o.stride ?? minStride;
+  }
+  stride = Math.max(n === 1 || o.lag === 0 ? 0 : 1, stride);
+  return {starts: Array.from({length: n}, (_, i) => Math.round(i * stride)), dur};
+}
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/tokens.ts b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/tokens.ts
new file mode 100644
index 000000000..457448260
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/tokens.ts
@@ -0,0 +1,87 @@
+/** 运动令牌——时长标尺 / 缓动曲线 / 弹簧手感 的单一事实源。
+ *
+ * 只放纯数据与纯函数：不 import remotion、不读 theme（颜色一律经参数注入）——
+ * 这是本层能以 frozen 档跨两个系列共享的前提（两系列 theme token 名已分叉：
+ * CC 用 core/mech/deny、SE 用 danger），判据同 test_chrome_motifs_only_read_base_theme_tokens。
+ *
+ * 取值依据（勿凭感觉改；改前先在本集校准轮逐幕目视复测，依据写回此处注释）：
+ * - 时长六档取 IBM Carbon DTCG（70/110/150/240/400/700ms）@30fps 四舍五入。
+ *   弃 Material 十六档：30fps 量化下其 15 个相邻对里 6 对落进同一帧数（伪选择）。
+ * - 缓动控制点取 Material 3 标准三件；曲线本体在 hooks.ts 经 Remotion Easing.bezier 求值。
+ * - 弹簧预设锚定本仓实测手感：settle=200 即既有 9/10 调用点的惯用值（延续成片观感），
+ *   snap=12 来自 P4「插头咬合」的过冲；ζ 与过冲峰值的关系由 motion.test.ts 用
+ *   Mp = exp(-πζ/√(1-ζ²)) 钉死。
+ * - effects 不变量：不透明度/颜色永不过冲——effects 类动画一律时长+缓动，
+ *   弹簧只用于空间位移（M3 spatial/effects 二分的落地）。
+ */
+
+/** 时长标尺（帧 @30fps）。叙事节拍（4–8s）不用此表——那是 window/schedule 的职责。 */
+export const DUR = {
+  /** 70ms：微反馈（辉光起点、光标） */
+  f1: 2,
+  /** 110ms：快速子项（列表错峰的单项时长） */
+  f2: 3,
+  /** 150ms：标准入场 */
+  f3: 5,
+  /** 200ms：强调入场 */
+  f4: 7,
+  /** 400ms：大位移 / 镜头推近 / 描线 */
+  f5: 12,
+  /** 700ms：幕级大动作（少用） */
+  f6: 21,
+} as const;
+export type DurToken = keyof typeof DUR;
+
+/** 缓动令牌。 */
+export type EasingToken = 'standard' | 'decelerate' | 'accelerate' | 'linear';
+
+/** 贝塞尔控制点（x1,y1,x2,y2）；linear 无控制点。 */
+export const EASING_CP: Record<
+  Exclude<EasingToken, 'linear'>,
+  readonly [number, number, number, number]
+> = {
+  // M3 standard：入场默认
+  standard: [0.2, 0, 0, 1],
+  // M3 decelerate：强减速（大位移入场、镜头推近）
+  decelerate: [0.05, 0.7, 0.1, 1],
+  // M3 accelerate：出场加速
+  accelerate: [0.3, 0, 0.8, 0.15],
+};
+
+/** 弹簧预设（直传 Remotion spring config；ζ = c/(2√(k·m))）。 */
+export type SpringPreset = 'settle' | 'settleSoft' | 'snap';
+export const SPRING: Record<SpringPreset, {damping: number; stiffness: number; mass: number}> = {
+  // ζ≈10：无过冲平滑滑入——本仓主流手感（既有场景 9/10 处 damping 200）
+  settle: {damping: 200, stiffness: 100, mass: 1},
+  // ζ≈8.5：更绵一点（P0/P1 既有 180/170 档的收敛）
+  settleSoft: {damping: 170, stiffness: 100, mass: 1},
+  // ζ≈0.6：轻微过冲（咬合/弹入——原 P4 damping 12）
+  snap: {damping: 12, stiffness: 100, mass: 1},
+};
+
+/** 阻尼比 ζ。设计系统文档普遍给 ζ（无量纲），Remotion 取阻尼系数 c——直抄会得
+ *  ζ≈0.02 的暴力弹跳且能通过渲染体检，这是迁移期最高风险项（单测钉死）。 */
+export const dampingRatio = (s: {
+  damping: number;
+  stiffness: number;
+  mass: number;
+}): number => s.damping / (2 * Math.sqrt(s.stiffness * s.mass));
+
+/** 欠阻尼弹簧的峰值位置（1 = 恰好到终点不过冲；ζ ≥ 1 恒 1）。
+ *  Mp = exp(-πζ/√(1-ζ²)) 是超出终点的幅度，峰值 = 1 + Mp。 */
+export const overshootPeak = (zeta: number): number =>
+  zeta >= 1 ? 1 : 1 + Math.exp((-Math.PI * zeta) / Math.sqrt(1 - zeta * zeta));
+
+/** 出场快于入场的系数（MDC 实测 400ms 入 / 150ms 出 ≈ 0.375，取 0.4 禁手填）。 */
+export const EXIT_FACTOR = 0.4;
+
+/** 字幕安全带上沿：1080 - qa_frames.SUBTITLE_BAND_PX(160)，与体检口径同源。 */
+export const SAFE_TOP_Y = 920;
+
+/** 自下方入场的行程安全钳制：落位态底边 restBottom 之上才是可用的进场空间。
+ *  ISSUE-170 的手工逐卡反算收敛于此——该缺陷类从「评审抽帧抓」变「构造不可能」。 */
+export const clampRiseDist = (
+  dist: number,
+  restBottom: number,
+  safeTop: number = SAFE_TOP_Y,
+): number => Math.max(0, Math.min(dist, safeTop - restBottom));
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/window.ts b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/window.ts
new file mode 100644
index 000000000..69bd59c7a
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/motion/window.ts
@@ -0,0 +1,43 @@
+/** 运动窗口纯函数——「父级持有绝对时间，子动画只是父进度上的窗口」。
+ *
+ * 这是 audio-first 时序与可复用运动模型兼容的核心机制：beat 的绝对帧来自
+ * beatWindow()（数据源是 TTS 实测 manifest），子动画不写死帧数、只声明自己在
+ * beat 进度上的 [start, end] 窗口 ⇒ 旁白实测时长变化时全部窗口自动重定时，
+ * 「写死帧数与口播脱钩」缺陷类（skills/08 实录）由构造消灭。
+ *
+ * 语义借 MDC TransitionUtils.lerp(startFraction, endFraction)：窗外钳制端点。
+ * 本模块零依赖（不 import remotion / theme）——frozen 跨系列共享与 node 单测的前提。
+ */
+
+/** 钳制到 [0,1]——一切进度的唯一出口，防负值/超 1 渗进 transform。 */
+export const clamp01 = (x: number): number => (x < 0 ? 0 : x > 1 ? 1 : x);
+
+/** 子动画窗口：父进度 p(0..1) 在 [s,e] 片段上的局部进度。 */
+export const win = (p: number, w: readonly [number, number]): number =>
+  clamp01((p - w[0]) / (w[1] - w[0]));
+
+/** beat 进度：局部帧 → 该 beat 的 0..1 进度。 */
+export const beatProgress = (
+  frame: number,
+  from: number,
+  durationInFrames: number,
+): number => clamp01((frame - from) / Math.max(1, durationInFrames));
+
+/** 帧域进度：[at, at+dur] 上的 0..1（dur ≤ 0 视作 1，防除零）。 */
+export const progress = (frame: number, at: number, dur: number): number =>
+  clamp01((frame - at) / Math.max(1, dur));
+
+/** 已过帧数 → 可见字符数；cps 随实际 fps 换算，显式帧间隔不受 fps 影响。 */
+export const revealCharCount = (
+  elapsedFrames: number,
+  fps: number,
+  cps: number,
+  framesPerChar?: number,
+): number => {
+  const elapsed = Math.max(0, elapsedFrames);
+  const count =
+    framesPerChar === undefined
+      ? Math.floor((elapsed / fps) * cps)
+      : Math.floor(elapsed / Math.max(1, framesPerChar));
+  return Math.max(0, count);
+};
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P0Hook.tsx b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P0Hook.tsx
index 403d98c09..08c4a5028 100644
--- a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P0Hook.tsx
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P0Hook.tsx
@@ -1,24 +1,32 @@
 /** P0 钩子与命名帧（分镜 0-A…0-C）
- *  三句内完成：搬运工痛点 → 官方命名「Harness」→ 五辐条供给图。
- *  改造（2026-08 Harness Engineering）：10 句压缩为 7 句，命名帧是全系列的开场锚。 */
+ *  三句内完成：系列身份栈开场 → 搬运工痛点 → 官方命名「Harness」→ 五辐条供给图。
+ *  重制（2026-09 运动层）：动效收敛到 motion 模型（分镜动效列 @动词 可机检）；
+ *  HarnessStackP0 落地 skills/06 系列身份视觉规格（五层栈开场 + 缩退常驻角标）。 */
 import React from 'react';
-import {AbsoluteFill, interpolate, Sequence, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {AbsoluteFill, Sequence, useCurrentFrame} from 'remotion';
 import {theme} from '../design/theme';
 import {beatWindow} from '../timing';
 import type {SceneRange} from '../types';
-import {Footnote, Panel, Terminal} from '../components/motifs';
+import {Panel, Terminal} from '../components/motifs';
+import {HarnessStackP0, harnessStackCrossAt} from '../components/harness-stack';
+import {DUR, progress, useBreathe, useProgress, useSpring, useStagger} from '../motion';
 
-/** 0-A 终端打字 → 命令凝住 → 复制粘贴弧线加速塞满（两句内完成旧版六句的信息量） */
-const StallAndCarry: React.FC<{carryAt: number}> = ({carryAt}) => {
+/** 0-A 系列栈开场 → 终端打字 → 命令凝住 → 复制粘贴弧线加速塞满 */
+const StallAndCarry: React.FC<{carryAt: number; revealAt: number}> = ({carryAt, revealAt}) => {
   const frame = useCurrentFrame();
   const W = 1560;
   const H = 400;
   const frozen = frame >= carryAt - 6;
-  // 三轮搬运轨迹（加速：每轮 9 帧，旧版是 15 帧——钩子提速）
+  // 终端在系列栈缩退让位后再进场（栈 choreography 见 HarnessStackP0）
+  const reveal = useProgress(revealAt, DUR.f5);
+  // 三轮搬运轨迹（加速：每轮 9 帧，旧版是 15 帧——钩子提速）。线性匀速是刻意：
+  // 搬运的机械感就该是等速的（motion 模型的逃生舱条款）
   const roundGap = [0, 9, 18];
+  // 侧标（竖排警示）：凝住即淡入，不再布尔硬门瞬现
+  const warnOp = useProgress(carryAt - 6, DUR.f5) * 0.9;
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
-      <div style={{position: 'relative', width: W, height: H}}>
+      <div style={{position: 'relative', width: W, height: H, opacity: reveal}}>
         <Terminal
           width={1300}
           height={330}
@@ -37,10 +45,7 @@ const StallAndCarry: React.FC<{carryAt: number}> = ({carryAt}) => {
               {a: 300, b: W - 300, y: 240 + i * 22, dir: 1},
             ];
             return legs.map((lg, k) => {
-              const t = interpolate(frame - base - k * 6, [0, 9], [0, 1], {
-                extrapolateLeft: 'clamp',
-                extrapolateRight: 'clamp',
-              });
+              const t = progress(frame - base - k * 6, 0, 9);
               if (t <= 0) return null;
               const x = lg.a + (lg.b - lg.a) * t;
               return (
@@ -63,7 +68,7 @@ const StallAndCarry: React.FC<{carryAt: number}> = ({carryAt}) => {
               color: theme.deny,
               writingMode: 'vertical-rl',
               letterSpacing: 5,
-              opacity: interpolate(frame, [carryAt - 6, carryAt + 6], [0, 0.9], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'}),
+              opacity: warnOp,
             }}
           >
             {'每一轮的搬运工，是你'}
@@ -76,25 +81,20 @@ const StallAndCarry: React.FC<{carryAt: number}> = ({carryAt}) => {
 
 /** 0-B 命名帧：搬运残影收束成外框，包住「模型」内核——外框即 Harness + 官方引文条 */
 const NamingFrame: React.FC<{officialAt: number}> = ({officialAt}) => {
-  const frame = useCurrentFrame();
-  const {fps} = useVideoConfig();
-  // 外框四面合拢（spring 收拢感）
-  const close = spring({frame, fps, config: {damping: 180}});
+  // 外框四面合拢（settleSoft 弹簧；局部帧——全局帧会让 spring 每帧重模拟 O(frame)）
+  const close = useSpring('settleSoft');
+  const label = useProgress(22, DUR.f5);
+  const quote = useProgress(officialAt, DUR.f5);
+  // 命名帧的「仪式感」呼吸辉光（sin(frame/26) → period 2π·26 ≈ 163）
+  const breathe = useBreathe({period: 163});
   const CX = 960;
   const CY = 460;
   const full = 420;
   const wHalf = full / 2 + (1 - close) * 620;
   const hHalf = full / 2 + (1 - close) * 380;
-  const label = interpolate(frame - 22, [0, 14], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
-  const quote = interpolate(frame - officialAt, [0, 18], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
-  // 呼吸辉光（命名帧的「仪式感」）
-  const breathe = 0.5 + 0.5 * Math.sin(frame / 26);
+  // 四角旧搬运残影：35% → 0 淡出（收束感）
+  const residue = 0.35 * (1 - useProgress(0, DUR.f6));
+  const core = progress(close, 0.3, 0.7);
   return (
     <AbsoluteFill>
       {/* 四面合拢的残影 → 外框 */}
@@ -116,21 +116,18 @@ const NamingFrame: React.FC<{officialAt: number}> = ({officialAt}) => {
           [1, -1],
           [-1, 1],
           [1, 1],
-        ].map(([sx, sy], i) => {
-          const o = interpolate(frame, [0, 18], [0.35, 0], {extrapolateRight: 'clamp'});
-          return (
-            <line
-              key={i}
-              x1={CX + sx * (wHalf - 120)}
-              y1={CY + sy * (hHalf - 60)}
-              x2={CX + sx * (wHalf + 40)}
-              y2={CY + sy * (hHalf + 40)}
-              stroke={theme.dim}
-              strokeWidth={4}
-              opacity={o}
-            />
-          );
-        })}
+        ].map(([sx, sy], i) => (
+          <line
+            key={i}
+            x1={CX + sx * (wHalf - 120)}
+            y1={CY + sy * (hHalf - 60)}
+            x2={CX + sx * (wHalf + 40)}
+            y2={CY + sy * (hHalf + 40)}
+            stroke={theme.dim}
+            strokeWidth={4}
+            opacity={residue}
+          />
+        ))}
       </svg>
       {/* 内核：模型 */}
       <div
@@ -140,7 +137,7 @@ const NamingFrame: React.FC<{officialAt: number}> = ({officialAt}) => {
           top: CY,
           transform: 'translate(-50%, -50%)',
           textAlign: 'center',
-          opacity: interpolate(close, [0.3, 1], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'}),
+          opacity: core,
         }}
       >
         <div
@@ -192,39 +189,37 @@ const NamingFrame: React.FC<{officialAt: number}> = ({officialAt}) => {
         {'把动力源，套进一个可控的结构里'}
       </div>
       {/* 官方引文条（p0-05 句锚） */}
-      {quote > 0 ? (
-        <div
-          style={{
-            position: 'absolute',
-            left: CX,
-            bottom: 200,
-            transform: `translate(-50%, ${(1 - quote) * 14}px)`,
-            opacity: quote,
-            textAlign: 'center',
-          }}
-        >
-          <Panel style={{padding: '18px 34px', maxWidth: 1200}}>
-            {/* 中英并列（分镜 0-B 承诺）：中文口播句 + 英文原句 */}
-            <div style={{fontFamily: theme.serif, fontSize: 27, color: theme.text}}>
-              {'“Claude Code 是 Harness，Claude 是里面的模型。”'}
-            </div>
-            <div
-              style={{
-                fontFamily: theme.serif,
-                fontSize: 21,
-                color: theme.dim,
-                marginTop: 7,
-                fontStyle: 'italic',
-              }}
-            >
-              {'“Claude Code is the harness, Claude is the model.”'}
-            </div>
-            <div style={{fontFamily: theme.mono, fontSize: 19, color: theme.dim, marginTop: 8}}>
-              {'— 官方文档 how-claude-code-works（code.claude.com，取数2026年8月）'}
-            </div>
-          </Panel>
-        </div>
-      ) : null}
+      <div
+        style={{
+          position: 'absolute',
+          left: CX,
+          bottom: 200,
+          transform: `translate(-50%, ${(1 - quote) * 14}px)`,
+          opacity: quote,
+          textAlign: 'center',
+        }}
+      >
+        <Panel style={{padding: '18px 34px', maxWidth: 1200}}>
+          {/* 中英并列（分镜 0-B 承诺）：中文口播句 + 英文原句 */}
+          <div style={{fontFamily: theme.serif, fontSize: 27, color: theme.text}}>
+            {'“Claude Code 是 Harness，Claude 是里面的模型。”'}
+          </div>
+          <div
+            style={{
+              fontFamily: theme.serif,
+              fontSize: 21,
+              color: theme.dim,
+              marginTop: 7,
+              fontStyle: 'italic',
+            }}
+          >
+            {'“Claude Code is the harness, Claude is the model.”'}
+          </div>
+          <div style={{fontFamily: theme.mono, fontSize: 19, color: theme.dim, marginTop: 8}}>
+            {'— 官方文档 how-claude-code-works（code.claude.com，取数2026年8月）'}
+          </div>
+        </Panel>
+      </div>
     </AbsoluteFill>
   );
 };
@@ -232,10 +227,8 @@ const NamingFrame: React.FC<{officialAt: number}> = ({officialAt}) => {
 /** 0-C 五辐条供给图：外框上长出五根辐条（文件/命令/权限/记忆/护栏）+ 标题卡收尾 */
 const SupplySpokes: React.FC<{titleAt: number}> = ({titleAt}) => {
   const frame = useCurrentFrame();
-  const {fps} = useVideoConfig();
   const CX = 960;
   const CY = 440;
-  const R = 300;
   const spokes = [
     {label: '文件', zh: '读写项目'},
     {label: '命令', zh: '执行与回传'},
@@ -243,15 +236,14 @@ const SupplySpokes: React.FC<{titleAt: number}> = ({titleAt}) => {
     {label: '记忆', zh: '上下文与规则', later: true},
     {label: '护栏', zh: '拦截与兜底'},
   ];
-  const title = spring({frame: frame - titleAt, fps, config: {damping: 200}});
-    const line = interpolate(frame - titleAt, [4, 40], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
-  const ring = interpolate(frame, [0, 16], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  const title = useSpring('settle', {at: titleAt});
+  // 标题卡细线生长（beat 级慢动作，刻意不走 micro token）
+  const line = useProgress(titleAt + 4, 36);
+  // 外框缩小型持续在场：16f 恰在两档 token 中间（Δ4/Δ5），保留显式时长
+  const ring = useProgress(0, 16);
+  // 五辐条依次点亮：stride 8、单项 12f（=DUR.f5，与原手写一致）
+  const lit = useStagger(5, {at: 6, stride: 8, dur: DUR.f5});
+  const laterOp = useProgress(40, DUR.f4);
   return (
     <AbsoluteFill>
       <svg width={1920} height={1080} style={{position: 'absolute'}}>
@@ -270,12 +262,10 @@ const SupplySpokes: React.FC<{titleAt: number}> = ({titleAt}) => {
         <text x={CX} y={CY + 6} textAnchor="middle" fontFamily={theme.mono} fontSize={34} fill={theme.text}>
           {'模型 Claude'}
         </text>
-        {/* 五辐条：自外框上沿五点连向内核 */}
+        {/* 五辐条：自外框上沿五点连向内核。辉光是逐根错相呼吸（per-index 相位），
+            useBreathe(offset) 的语义此处以内联等式表达（map 内不可调 hook） */}
         {spokes.map((sp, i) => {
-          const t = interpolate(frame - 6 - i * 8, [0, 12], [0, 1], {
-            extrapolateLeft: 'clamp',
-            extrapolateRight: 'clamp',
-          });
+          const t = lit[i];
           if (t <= 0) return null;
           // 五点沿外框上沿分布
           const fx = CX - 300 + i * 150;
@@ -305,55 +295,45 @@ const SupplySpokes: React.FC<{titleAt: number}> = ({titleAt}) => {
           );
         })}
         {/* 「记忆」辐条的「后面拆」小标 */}
-        {(() => {
-          const o = interpolate(frame - 6 - 3 * 8 - 10, [0, 10], [0, 1], {
-            extrapolateLeft: 'clamp',
-            extrapolateRight: 'clamp',
-          });
-          return o > 0 ? (
-            <text
-              x={CX + 0}
-              y={CY - 250 - 132}
-              textAnchor="middle"
-              fontFamily={theme.sans}
-              fontSize={20}
-              fill={theme.dim}
-              opacity={o}
-            >
-              {'后面单独拆'}
-            </text>
-          ) : null;
-        })()}
+        <text
+          x={CX}
+          y={CY - 250 - 132}
+          textAnchor="middle"
+          fontFamily={theme.sans}
+          fontSize={20}
+          fill={theme.dim}
+          opacity={laterOp}
+        >
+          {'后面单独拆'}
+        </text>
       </svg>
-      {/* 标题卡（p0-07 收尾压入） */}
-      {title > 0 ? (
+      {/* 标题卡（p0-07 收尾压入；弹簧负帧返回 0，无须布尔门） */}
+      <div
+        style={{
+          position: 'absolute',
+          left: 0,
+          right: 0,
+          bottom: 210,
+          textAlign: 'center',
+          opacity: title,
+          transform: `translateY(${(1 - title) * 18}px)`,
+        }}
+      >
+        <div style={{fontFamily: theme.serif, fontSize: 58, fontWeight: 700, color: theme.core}}>
+          {'执行层：一个循环，就是全部'}
+        </div>
         <div
           style={{
-            position: 'absolute',
-            left: 0,
-            right: 0,
-            bottom: 210,
-            textAlign: 'center',
-            opacity: title,
-            transform: `translateY(${(1 - title) * 18}px)`,
+            margin: '22px auto 0',
+            height: 3,
+            width: 560 * line,
+            background: theme.core,
           }}
-        >
-          <div style={{fontFamily: theme.serif, fontSize: 58, fontWeight: 700, color: theme.core}}>
-            {'执行层：一个循环，就是全部'}
-          </div>
-          <div
-            style={{
-              margin: '22px auto 0',
-              height: 3,
-              width: 560 * line,
-              background: theme.core,
-            }}
-          />
-          <div style={{marginTop: 16, fontFamily: theme.sans, fontSize: 23, color: theme.dim}}>
-            {'Claude Code Harness Engineering · 执行层'}
-          </div>
+        />
+        <div style={{marginTop: 16, fontFamily: theme.sans, fontSize: 23, color: theme.dim}}>
+          {'Claude Code Harness Engineering · 执行层'}
         </div>
-      ) : null}
+      </div>
     </AbsoluteFill>
   );
 };
@@ -364,10 +344,17 @@ export const P0Hook: React.FC<{scene: SceneRange}> = ({scene}) => {
   const bA = w('p0-01', 'p0-02');
   const bB = w('p0-03', 'p0-05');
   const bC = w('p0-06', 'p0-07');
+  // 系列栈缩退在搬运高潮前完成（recedeAt 由句边界推导——禁写死帧数）
+  const p2 = at('p0-02') - bA.from;
+  const recedeAt = Math.max(66, p2 - DUR.f6 - 6);
+  const terminalRevealAt = harnessStackCrossAt(recedeAt);
   return (
     <AbsoluteFill>
+      {/* 系列身份栈：scene 级渲染（beat Sequence 之外）——落板 → 本集层高亮 →
+          缩退左上角后**常驻整幕**；P1 起由各幕的 HarnessBadge 接棒 */}
+      <HarnessStackP0 recedeAt={recedeAt} />
       <Sequence {...bA} name="0-A 停住与搬运">
-        <StallAndCarry carryAt={at('p0-02') - bA.from} />
+        <StallAndCarry carryAt={p2} revealAt={terminalRevealAt} />
       </Sequence>
       <Sequence {...bB} name="0-B 命名帧：Harness">
         <NamingFrame officialAt={at('p0-05') - bB.from} />
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P1Loop.tsx b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P1Loop.tsx
index 9dede2541..615c19817 100644
--- a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P1Loop.tsx
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P1Loop.tsx
@@ -1,7 +1,7 @@
 /** P1 一个循环，就是全部（分镜 1-A…1-F）—— 开源教学素材「Agent While-Loop」可视化的概念重建
  *  ★ 本幕建立全片视觉锚：LoopRing 的色与线宽从此不再改变。 */
 import React from 'react';
-import {AbsoluteFill, interpolate, Sequence, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {AbsoluteFill, Sequence, useCurrentFrame} from 'remotion';
 import {theme} from '../design/theme';
 import {beatWindow} from '../timing';
 import type {SceneRange} from '../types';
@@ -15,20 +15,17 @@ import {
   SceneTag,
   useRingDot,
 } from '../components/motifs';
+import {HarnessBadge} from '../components/harness-stack';
+import {DUR, useProgress, useSpring, useStagger} from '../motion';
 
 /** 1-A 环形循环成形 + 两个信号分支 */
 const RingBirth: React.FC<{yesAt: number; noAt: number}> = ({yesAt, noAt}) => {
   const frame = useCurrentFrame();
-  const draw = interpolate(frame, [4, 40], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  // 描线成形改 decelerate（原线性）：环的「生长感」需要先快后慢
+  const draw = useProgress(4, 36, 'decelerate');
   const dot = useRingDot(2.5, 40);
   // 讲到「没有」时光点滑出到停机出口并定格
-  const pull = interpolate(frame - noAt, [8, 30], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  const pull = useProgress(noAt + 8, 22);
   const active = frame >= yesAt && frame < noAt ? 2 : undefined;
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
@@ -52,15 +49,20 @@ const FiveSteps: React.FC<{stepAt: number[]}> = ({stepAt}) => {
     '结果打包成新消息，回到第二步',
   ];
   const lit = stepAt.filter((s) => frame >= s).length;
+  // 五步逐句点亮（12f = DUR.f5；锚点非均匀，显式五行而非 useStagger）
+  const litP = [
+    useProgress(stepAt[0], DUR.f5),
+    useProgress(stepAt[1], DUR.f5),
+    useProgress(stepAt[2], DUR.f5),
+    useProgress(stepAt[3], DUR.f5),
+    useProgress(stepAt[4], DUR.f5),
+  ];
   const blocks: {color: string; label: string}[] = [];
   if (lit >= 1) blocks.push({color: theme.dim, label: 'user'});
   if (lit >= 3) blocks.push({color: theme.core, label: 'assistant'});
   if (lit >= 4) blocks.push({color: theme.mech, label: 'tool_result'});
   if (lit >= 5) blocks.push({color: theme.core, label: 'assistant'});
-  const loopBack = interpolate(frame - stepAt[4], [6, 26], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  const loopBack = useProgress(stepAt[4] + 6, DUR.f6);
   return (
     <AbsoluteFill style={{flexDirection: 'row', alignItems: 'center', padding: '0 96px', gap: 60}}>
       <div style={{width: 380, display: 'flex', justifyContent: 'center'}}>
@@ -69,10 +71,7 @@ const FiveSteps: React.FC<{stepAt: number[]}> = ({stepAt}) => {
       <div style={{flex: 1}}>
         {steps.map((s, i) => {
           const on = frame >= stepAt[i];
-          const e = interpolate(frame - stepAt[i], [0, 12], [0, 1], {
-            extrapolateLeft: 'clamp',
-            extrapolateRight: 'clamp',
-          });
+          const e = litP[i];
           return (
             <div
               key={s}
@@ -176,10 +175,7 @@ const TwentyThreeLines: React.FC<{countAt: number; splitAt: number}> = ({countAt
     '            "tool_use_id": block.id, "content": output})',
     '    messages.append({"role": "user", "content": results})',
   ];
-  const split = interpolate(frame - splitAt, [0, 20], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  const split = useProgress(splitAt, DUR.f6);
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <div style={{opacity: 1 - split * 0.75, transform: `scale(${1 - split * 0.08})`}}>
@@ -237,10 +233,7 @@ const UnreliableFlag: React.FC<{crossAt: number; quoteAt: number}> = ({crossAt,
   // 工具调用已流出的帧（每 2 帧 1 字）；标记牌刻意再滞后 25 帧才翻转 —— 这就是「不可靠」
   const toolOutAt = toolIdx * 2;
   const flipped = frame >= toolOutAt + 25;
-  const cross = interpolate(frame - crossAt, [0, 14], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  const cross = useProgress(crossAt, DUR.f5);
   if (frame >= quoteAt) {
     return (
       <QuoteCard zh="别听它说「我说完了」，去看它手里还有没有活。" accent={theme.core} />
@@ -328,25 +321,24 @@ const ThreePhaseRing: React.FC<{phaseAt: number; handAt: number; drawersAt: numb
   recedeAt,
 }) => {
   const frame = useCurrentFrame();
-  const {fps} = useVideoConfig();
   const dot = useRingDot(2.5);
   const phases = [
     {label: '收集上下文', zh: '读文件 · 搜代码', ang: -90},
     {label: '采取行动', zh: '改文件 · 跑命令', ang: 30},
     {label: '验证结果', zh: '看输出 · 再补一刀', ang: 150},
   ];
-  const recede = interpolate(frame - recedeAt, [0, 24], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
-  const hand = spring({frame: frame - handAt, fps, config: {damping: 170}});
-  const drawerOn = interpolate(frame - drawersAt, [0, 30], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  const recede = useProgress(recedeAt, DUR.f6);
+  const hand = useSpring('settleSoft', {at: handAt});
+  // 抽屉墙整体一闪：1s 的 beat 级动作（30f 距两档 token 均 >3，保留显式时长）
+  const drawerOn = useProgress(drawersAt, 30);
   const CX = 560;
   const CY = 500;
   const R = 250;
+  // 三相位标签沿环依次点亮（stride 10、单项 f5）
+  const phaseOn = useStagger(3, {at: phaseAt, stride: 10, dur: DUR.f5});
+  // 十格抽屉墙快闪（快节奏：stride 2、单项 f3）
+  const drawerCells = useStagger(10, {at: drawersAt, stride: 2, dur: DUR.f3});
+  const fuseOp = useProgress(phaseAt + 34, DUR.f4);
   return (
     <AbsoluteFill>
       <div
@@ -363,10 +355,7 @@ const ThreePhaseRing: React.FC<{phaseAt: number; handAt: number; drawersAt: numb
       <svg width={1920} height={1080} style={{position: 'absolute'}}>
         {/* 三个相位标签：沿环依次点亮并保持同时可见（交融感） */}
         {phases.map((ph, i) => {
-          const on = interpolate(frame - phaseAt - i * 10, [0, 12], [0, 1], {
-            extrapolateLeft: 'clamp',
-            extrapolateRight: 'clamp',
-          });
+          const on = phaseOn[i];
           const rad = (ph.ang * Math.PI) / 180;
           const lx = CX + Math.cos(rad) * (R + 96);
           const ly = CY + Math.sin(rad) * (R + 96);
@@ -385,12 +374,18 @@ const ThreePhaseRing: React.FC<{phaseAt: number; handAt: number; drawersAt: numb
             </g>
           );
         })}
-        {/* 「交融」标注：三段弧互相咬合（非硬阶段） */}
-        {frame > phaseAt + 34 ? (
-          <text x={CX} y={CY - R - 148} textAnchor="middle" fontFamily={theme.sans} fontSize={24} fill={theme.dim}>
-            {'三相互相交融——不是硬阶段'}
-          </text>
-        ) : null}
+        {/* 「交融」标注：三段弧互相咬合（非硬阶段）——淡入而非瞬现 */}
+        <text
+          x={CX}
+          y={CY - R - 148}
+          textAnchor="middle"
+          fontFamily={theme.sans}
+          fontSize={24}
+          fill={theme.dim}
+          opacity={fuseOp}
+        >
+          {'三相互相交融——不是硬阶段'}
+        </text>
         {/* 人的手：落向「行动」节点，环上光点被拨偏一档 */}
         {hand > 0 ? (
           <g opacity={hand} transform={`translate(0 ${(1 - hand) * -60})`}>
@@ -441,10 +436,7 @@ const ThreePhaseRing: React.FC<{phaseAt: number; handAt: number; drawersAt: numb
             '轮数计数',
             '上次继续原因',
           ].map((label, i) => {
-            const e = interpolate(frame - drawersAt - i * 2, [0, 8], [0, 1], {
-              extrapolateLeft: 'clamp',
-              extrapolateRight: 'clamp',
-            });
+            const e = drawerCells[i];
             return (
               <div
                 key={label}
@@ -474,10 +466,9 @@ const ThreePhaseRing: React.FC<{phaseAt: number; handAt: number; drawersAt: numb
 const ExitPaths: React.FC<{branchAt: number; dimAt: number}> = ({branchAt, dimAt}) => {
   const frame = useCurrentFrame();
   const names = ['报错', '中断', '钩子叫停', '轮数到顶', '预算烧完'];
-  const dim = interpolate(frame - dimAt, [0, 20], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  const dim = useProgress(dimAt, DUR.f6);
+  // 五条支线逐条描线（stride 6；16f 距两档 token 均 >3，保留显式时长）
+  const branchP = useStagger(names.length, {at: branchAt, stride: 6, dur: 16});
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <div style={{position: 'relative', width: 1300, height: 520}}>
@@ -486,10 +477,7 @@ const ExitPaths: React.FC<{branchAt: number; dimAt: number}> = ({branchAt, dimAt
         </div>
         <svg width={1300} height={520} style={{position: 'absolute', left: 0, top: 0}}>
           {names.map((n, i) => {
-            const t = interpolate(frame - branchAt - i * 6, [0, 16], [0, 1], {
-              extrapolateLeft: 'clamp',
-              extrapolateRight: 'clamp',
-            });
+            const t = branchP[i];
             const y0 = 240;
             const y1 = 96 + i * 76;
             const x0 = 618;
@@ -540,6 +528,7 @@ export const P1Loop: React.FC<{scene: SceneRange}> = ({scene}) => {
   const rF = (id: string) => w(id).from - bF.from;
   return (
     <AbsoluteFill>
+      <HarnessBadge />
       <Sequence {...bA} name="1-A 环形循环成形">
         <RingBirth yesAt={rA('p1-04')} noAt={rA('p1-06')} />
       </Sequence>
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P2Dispatch.tsx b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P2Dispatch.tsx
index ac2db9f4e..aec9c3a5a 100644
--- a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P2Dispatch.tsx
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P2Dispatch.tsx
@@ -1,7 +1,7 @@
 /** P2 加一个工具，只改一行（分镜 2-A…2-H）—— 开源教学素材「Tool Dispatch Map」的概念重建
  *  重点视觉演绎：并发安全 ≠ 只读（真值表对撞）、连续块分批、读文件落盘自循环。 */
 import React from 'react';
-import {AbsoluteFill, interpolate, Sequence, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {AbsoluteFill, Sequence, spring, useCurrentFrame, useVideoConfig} from 'remotion';
 import {theme} from '../design/theme';
 import {beatWindow} from '../timing';
 import type {SceneRange} from '../types';
@@ -17,12 +17,15 @@ import {
   Terminal,
   useRingDot,
 } from '../components/motifs';
+import {HarnessBadge} from '../components/harness-stack';
+import {DUR, SPRING, useAccelTravel, useBreathe, useImpulse, useProgress, useShake, useStagger} from '../motion';
 
 /** 环留在左上角：缩小但同色同线宽 */
 const CornerRing: React.FC<{pulse?: boolean}> = ({pulse = false}) => {
-  const frame = useCurrentFrame();
+  // pulse 态呼吸：原 0.6+0.4·sin(frame/4)，period = 2π·4 ≈ 25
+  const breathe = useBreathe({period: 25, base: 0.6, amp: 0.4});
   const dot = useRingDot(2.5);
-  const p = pulse ? 0.6 + 0.4 * Math.sin(frame / 4) : 1;
+  const p = pulse ? breathe : 1;
   return (
     <div style={{position: 'absolute', left: 64, top: 56, opacity: p}}>
       <LoopRing size={190} draw={1} dotProgress={dot} showExit={false} />
@@ -32,9 +35,8 @@ const CornerRing: React.FC<{pulse?: boolean}> = ({pulse = false}) => {
 
 /** 2-A 命令行拼接的笨拙 */
 const ClumsyCommands: React.FC<{typoAt: number}> = ({typoAt}) => {
-  const frame = useCurrentFrame();
-  const bad = frame >= typoAt;
-  const shake = bad ? Math.sin((frame - typoAt) / 1.6) * 3 : 0;
+  // typoAt 起持续抖动（负帧归零，与原 bad 布尔门等价）
+  const shake = useShake({at: typoAt, amp: 3, freq: 1.6});
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <SceneTag chapter="Tool Use" tagline="Add a Tool, Add Just One Line" />
@@ -69,11 +71,13 @@ const ClumsyCommands: React.FC<{typoAt: number}> = ({typoAt}) => {
 
 /** 2-B 五张工具卡（反枚举：只有编号染色） */
 const FiveTools: React.FC = () => {
-  const frame = useCurrentFrame();
   const tools = ['跑命令', '读文件', '写文件', '改文件', '按模式找文件'];
   const mono = ['bash', 'read_file', 'write_file', 'edit_file', 'glob'];
   // 官方五类工具地图（how-claude-code-works）：教学五件归位官方分区，两个空槽亮虚线（Harness Engineering 改造）
   const zones = ['文件操作', '文件操作', '文件操作', '文件操作', '搜索'];
+  // 分区小标同刻淡入（12f = DUR.f5）；两个空槽错峰（stride 8、单项 f5，原终值 0.8 保留为系数）
+  const zoneOp = useProgress(20, DUR.f5);
+  const slotOn = useStagger(2, {at: 26, stride: 8, dur: DUR.f5});
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <CornerRing />
@@ -87,10 +91,7 @@ const FiveTools: React.FC = () => {
                 fontSize: 17,
                 color: theme.dim,
                 marginTop: 10,
-                opacity: interpolate(frame - 20, [0, 12], [0, 1], {
-                  extrapolateLeft: 'clamp',
-                  extrapolateRight: 'clamp',
-                }),
+                opacity: zoneOp,
               }}
             >
               {zones[i]}
@@ -111,10 +112,7 @@ const FiveTools: React.FC = () => {
               alignItems: 'center',
               justifyContent: 'center',
               gap: 8,
-              opacity: interpolate(frame - 26 - i * 8, [0, 12], [0, 0.8], {
-                extrapolateLeft: 'clamp',
-                extrapolateRight: 'clamp',
-              }),
+              opacity: slotOn[i] * 0.8,
               alignSelf: 'center',
             }}
           >
@@ -141,10 +139,9 @@ const Dispatch: React.FC<{hitAt: number; slotAt: number}> = ({hitAt, slotAt}) =>
     {key: 'glob', value: 'run_glob'},
   ];
   const hit = frame >= hitAt ? 1 : -1;
-  const flyT = interpolate(frame - hitAt, [-14, 0], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  // 飞点在 hitAt 前 14 帧起飞、恰与命中行高亮同刻落位——窗口终点锚定，
+  // 换 token 会推后/提前落位，保留显式时长
+  const flyT = useProgress(hitAt - 14, 14);
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center', flexDirection: 'row', gap: 70}}>
       <CornerRing />
@@ -250,7 +247,7 @@ const QueueVsParallel: React.FC<{splitAt: number}> = ({splitAt}) => {
       {!split ? (
         <div style={{display: 'flex', flexDirection: 'column', gap: 14}}>
           {names.map((n, i) => {
-            const e = spring({frame: frame - i * 5, fps, config: {damping: 200}});
+            const e = spring({frame: frame - i * 5, fps, config: SPRING.settle});
             return (
               <Panel key={n} style={{width: 460, padding: '14px 20px', opacity: e}}>
                 <span style={{fontFamily: theme.mono, fontSize: 27, color: theme.text}}>{n}</span>
@@ -302,6 +299,8 @@ const ConcurrencyTable: React.FC<{
   quoteAt: number;
 }> = ({splitAt, flashAt, taskAt, quoteAt}) => {
   const frame = useCurrentFrame();
+  // 「同名，结论相反」标注的闪烁包络：sin 起于 0 归于 0（须在 quoteAt 早退之前调用，hook 数量恒定）
+  const flashOp = useImpulse({at: flashAt, dur: 10});
   if (frame >= quoteAt) {
     return (
       <QuoteCard
@@ -376,20 +375,20 @@ const ConcurrencyTable: React.FC<{
           );
         })}
       </Panel>
-      {flash ? (
-        <div
-          style={{
-            position: 'absolute',
-            fontFamily: theme.serif,
-            fontSize: 40,
-            color: theme.deny,
-            top: 250,
-            right: 190,
-          }}
-        >
-          {'同名，结论相反'}
-        </div>
-      ) : null}
+      {/* 标注常驻渲染、以包络透明度一闪（原布尔瞬现 → 淡入淡出；窗口与背景 flash 同宽 10f） */}
+      <div
+        style={{
+          position: 'absolute',
+          fontFamily: theme.serif,
+          fontSize: 40,
+          color: theme.deny,
+          top: 250,
+          right: 190,
+          opacity: flashOp,
+        }}
+      >
+        {'同名，结论相反'}
+      </div>
       <Footnote delay={splitAt}>
         {'isConcurrencySafe ≠ isReadOnly —— 第三方的源码分析'}
       </Footnote>
@@ -461,29 +460,19 @@ const Batching: React.FC<{groupAt: number[]; noteAt: number}> = ({groupAt, noteA
 /** 2-H 落盘自循环：读→落盘→读→落盘，四圈后定格 */
 const SpillLoop: React.FC<{markAt: number; loopAt: number}> = ({markAt, loopAt}) => {
   const frame = useCurrentFrame();
-  const t = Math.max(0, frame - loopAt);
-  // 每圈加速一档：圈时长 40 → 30 → 22 → 16 帧
+  // 每圈加速一档：圈时长 40 → 30 → 22 → 16 帧（useAccelTravel：跑完四圈冻结在终点，
+  // heat = lap/3 即原 denyMix 的失控感偏移系数）
   const durs = [40, 30, 22, 16];
-  let acc = 0;
-  let lap = 0;
-  let within = 0;
-  for (let i = 0; i < durs.length; i++) {
-    if (t < acc + durs[i]) {
-      lap = i;
-      within = (t - acc) / durs[i];
-      break;
-    }
-    acc += durs[i];
-    lap = i + 1;
-    within = 1;
-  }
-  const done = lap >= durs.length;
-  const angle = done ? 300 : -90 + within * 360;
   const cx = 300;
   const cy = 210;
   const r = 132;
-  const rad = (angle * Math.PI) / 180;
-  const denyMix = Math.min(1, lap / 3);
+  const travel = useAccelTravel({cx, cy, r, durs, at: loopAt, heatPerLap: 3});
+  const denyMix = travel.heat;
+  // 定格时刻 = 四圈时长累加（与 useAccelTravel 内部推进同口径）
+  const doneAt = loopAt + durs.reduce((a, b) => a + b, 0);
+  const done = frame >= doneAt;
+  // 定格判词：原布尔瞬现 → f4 淡入 + 轻微上移落位
+  const verdictOp = useProgress(doneAt, DUR.f4);
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <CornerRing />
@@ -500,9 +489,7 @@ const SpillLoop: React.FC<{markAt: number; loopAt: number}> = ({markAt, loopAt})
               strokeDasharray="10 8"
               opacity={0.55 + denyMix * 0.45}
             />
-            {!done ? (
-              <circle cx={cx + r * Math.cos(rad)} cy={cy + r * Math.sin(rad)} r={12} fill={theme.deny} />
-            ) : null}
+            {!done ? <circle cx={travel.x} cy={travel.y} r={12} fill={theme.deny} /> : null}
             <text x={cx} y={cy - r - 20} textAnchor="middle" fontFamily={theme.sans} fontSize={24} fill={theme.dim}>
               {'读文件'}
             </text>
@@ -516,23 +503,23 @@ const SpillLoop: React.FC<{markAt: number; loopAt: number}> = ({markAt, loopAt})
               {'再落盘'}
             </text>
           </svg>
-          {done ? (
-            <div
-              style={{
-                position: 'absolute',
-                left: 0,
-                right: 0,
-                top: cy - 18,
-                textAlign: 'center',
-                fontFamily: theme.serif,
-                fontSize: 40,
-                color: theme.deny,
-                fontWeight: 700,
-              }}
-            >
-              {'转不出来'}
-            </div>
-          ) : null}
+          <div
+            style={{
+              position: 'absolute',
+              left: 0,
+              right: 0,
+              top: cy - 18,
+              textAlign: 'center',
+              fontFamily: theme.serif,
+              fontSize: 40,
+              color: theme.deny,
+              fontWeight: 700,
+              opacity: verdictOp,
+              transform: `translateY(${(1 - verdictOp) * 10}px)`,
+            }}
+          >
+            {'转不出来'}
+          </div>
         </div>
         <Panel
           accent={frame >= markAt ? theme.core : theme.panelBorder}
@@ -573,6 +560,7 @@ export const P2Dispatch: React.FC<{scene: SceneRange}> = ({scene}) => {
   const rel = (b: {from: number}, id: string) => w(id).from - b.from;
   return (
     <AbsoluteFill>
+      <HarnessBadge />
       <Sequence {...bA} name="2-A 命令行拼接的笨拙">
         <ClumsyCommands typoAt={rel(bA, 'p2-04')} />
       </Sequence>
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P3Gates.tsx b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P3Gates.tsx
index 7169694d1..70536cc89 100644
--- a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P3Gates.tsx
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P3Gates.tsx
@@ -1,11 +1,13 @@
 /** P3 执行之前，先过闸门（分镜 3-A…3-G）—— 开源教学素材「Permission Desk」的概念重建
- *  三种结果不各占一色：allow 回 core（放行=回主干）、ask 用 mech、deny 用 danger。 */
+ *  三种结果不各占一色：allow 回 core（放行=回主干）、ask 用 mech、deny 用 danger。
+ *  重制（2026-09 运动层）：动效收敛到 motion 模型（分镜动效列 @动词 可机检）。 */
 import React from 'react';
-import {AbsoluteFill, interpolate, Sequence, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {AbsoluteFill, Sequence, spring, useCurrentFrame, useVideoConfig} from 'remotion';
 import {theme} from '../design/theme';
 import {beatWindow} from '../timing';
 import type {SceneRange} from '../types';
 import {QuoteCard} from '../components/cards';
+import {HarnessBadge} from '../components/harness-stack';
 import {
   CodeCard,
   Footnote,
@@ -16,6 +18,7 @@ import {
   SceneTag,
   useRingDot,
 } from '../components/motifs';
+import {DUR, SPRING, useBreathe, useProgress, useShake, useStagger, win} from '../motion';
 
 /** 3-A 五张工具卡，跑命令那张在「工作目录」框外 */
 const UnguardedShell: React.FC<{frameAt: number; cmdAt: number; execAt: number}> = ({
@@ -25,13 +28,17 @@ const UnguardedShell: React.FC<{frameAt: number; cmdAt: number; execAt: number}>
 }) => {
   const frame = useCurrentFrame();
   const dot = useRingDot(2.5);
-  const boxT = interpolate(frame - frameAt, [0, 22], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
-  const shake = frame >= frameAt + 22 ? Math.sin(frame / 2.2) * 2.5 : 0;
+  // 合框 22f 是 beat 级动作（≥22 保留显式时长）
+  const boxT = useProgress(frameAt, 22);
+  // 闸门成形后持续微抖（错误语义；局部相位——模型口径）
+  const shake = useShake({at: frameAt + 22, amp: 2.5, freq: 2.2});
   const showCmd = frame >= cmdAt;
   const dim = showCmd ? 0.55 : 1;
+  // rm -rf 大字：瞬现门 → 恒渲染 + f3 淡入；弹入 14f → f6 档
+  const cmdOp = useProgress(cmdAt, DUR.f3);
+  const cmdPop = useProgress(cmdAt, DUR.f6);
+  // 循环角标：同款瞬现门 → 淡入
+  const execOp = useProgress(execAt, DUR.f3);
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <SceneTag chapter="Permission" tagline="Check Permissions Before Execution" />
@@ -70,56 +77,49 @@ const UnguardedShell: React.FC<{frameAt: number; cmdAt: number; execAt: number}>
           <NumberedCard index={1} label="跑命令" sub="没人管它" active width={200} />
         </div>
       </div>
-      {showCmd ? (
+      <div
+        style={{
+          position: 'absolute',
+          fontFamily: theme.mono,
+          fontSize: 56,
+          fontWeight: 700,
+          color: theme.deny,
+          opacity: cmdOp,
+          transform: `scale(${0.8 + 0.2 * cmdPop})`,
+        }}
+      >
+        {'rm -rf /'}
+      </div>
+      <div style={{position: 'absolute', right: 96, bottom: 210, opacity: 0.9 * execOp}}>
+        <LoopRing size={180} draw={1} dotProgress={dot} activeNode={2} showExit={false} />
         <div
           style={{
-            position: 'absolute',
-            fontFamily: theme.mono,
-            fontSize: 56,
-            fontWeight: 700,
-            color: theme.deny,
-            transform: `scale(${interpolate(frame - cmdAt, [0, 14], [0.8, 1], {
-              extrapolateLeft: 'clamp',
-              extrapolateRight: 'clamp',
-            })})`,
+            textAlign: 'center',
+            fontFamily: theme.sans,
+            fontSize: 21,
+            color: theme.dim,
+            marginTop: 4,
           }}
         >
-          {'rm -rf /'}
-        </div>
-      ) : null}
-      {frame >= execAt ? (
-        <div style={{position: 'absolute', right: 96, bottom: 210, opacity: 0.9}}>
-          <LoopRing size={180} draw={1} dotProgress={dot} activeNode={2} showExit={false} />
-          <div
-            style={{
-              textAlign: 'center',
-              fontFamily: theme.sans,
-              fontSize: 21,
-              color: theme.dim,
-              marginTop: 4,
-            }}
-          >
-            {'循环照常执行'}
-          </div>
+          {'循环照常执行'}
         </div>
-      ) : null}
+      </div>
     </AbsoluteFill>
   );
 };
 
 /** 3-B 三道闸门落下，第一道把请求弹回 */
 const GatesFall: React.FC<{gateAt: number[]; bounceAt: number}> = ({gateAt, bounceAt}) => {
-  const frame = useCurrentFrame();
-  const g = gateAt.map((a) =>
-    interpolate(frame - a, [0, 16], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'}),
-  );
-  const travel = interpolate(frame - bounceAt, [0, 20], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  // 三道闸门：锚点等差（stride 取自 prop 锚距），落下 16f → f6 档
+  const g = useStagger(3, {at: gateAt[0], stride: gateAt[1] - gateAt[0], dur: DUR.f6});
+  const travel = useProgress(bounceAt, DUR.f6);
+  // 危险词 chips：第一道闸近落定（gateAt[0]+12）起 stride 4 错峰，10f → f5
+  const banOp = useStagger(4, {at: gateAt[0] + 12, stride: 4, dur: DUR.f5});
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <GateRouter gates={g} travel={travel} blockedBy={0} />
+      {/* 容器参与 AbsoluteFill 垂直居中——恒渲染会整体上移 GateRouter（几何变化），
+          保留门；子项自身已错峰淡入 */}
       {g[0] > 0.8 ? (
         <div style={{display: 'flex', gap: 14, marginTop: 34}}>
           {['删根目录', '提权', '关机', '格式化'].map((t, i) => (
@@ -128,10 +128,7 @@ const GatesFall: React.FC<{gateAt: number[]; bounceAt: number}> = ({gateAt, boun
               accent={theme.deny}
               style={{
                 padding: '10px 20px',
-                opacity: interpolate(frame - gateAt[0] - 12 - i * 4, [0, 10], [0, 1], {
-                  extrapolateLeft: 'clamp',
-                  extrapolateRight: 'clamp',
-                }),
+                opacity: banOp[i],
               }}
             >
               <span style={{fontFamily: theme.mono, fontSize: 24, color: theme.deny}}>{t}</span>
@@ -146,12 +143,11 @@ const GatesFall: React.FC<{gateAt: number[]; bounceAt: number}> = ({gateAt, boun
 /** 3-C 二三道闸门工作：一个停在审批前，一个畅通直达 */
 const AskAndPass: React.FC<{askAt: number; passAt: number}> = ({askAt, passAt}) => {
   const frame = useCurrentFrame();
-  const t1 = interpolate(frame, [0, 26], [0, 1], {extrapolateRight: 'clamp'});
-  const t2 = interpolate(frame - passAt, [0, 30], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  const t1 = useProgress(0, 26);
+  const t2 = useProgress(passAt, 30);
   const asking = frame >= askAt;
+  // 审批卡：瞬现门 → 恒渲染 + f3 淡入
+  const askOp = useProgress(askAt, DUR.f3);
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       {/* 审批卡弹出时闸门整体上移让位——否则卡片会盖住三道闸，
@@ -164,45 +160,44 @@ const AskAndPass: React.FC<{askAt: number; passAt: number}> = ({askAt, passAt})
       >
         <GateRouter gates={[1, 1, 1]} travel={t1} blockedBy={2} />
       </div>
-      {asking ? (
-        <Panel
-          accent={theme.mech}
-          style={{
-            position: 'absolute',
-            width: 760,
-            padding: '26px 30px',
-            background: theme.panel,
-            top: '52%',
-          }}
-        >
-          <div style={{display: 'flex', alignItems: 'center', gap: 12}}>
-            {/* 绘制的三角叹号（不用 emoji——全彩字形会击穿三色契约） */}
-            <svg width={30} height={27} style={{flexShrink: 0}}>
-              <path
-                d="M15 2 L28 25 L2 25 Z"
-                fill="none"
-                stroke={theme.deny}
-                strokeWidth={3}
-                strokeLinejoin="round"
-              />
-              <line x1="15" y1="10" x2="15" y2="18" stroke={theme.deny} strokeWidth={3} strokeLinecap="round" />
-              <circle cx="15" cy="22.5" r="1.8" fill={theme.deny} />
-            </svg>
-            <span style={{fontFamily: theme.sans, fontSize: 24, color: theme.mech}}>
-              {'Potentially destructive command'}
-            </span>
-          </div>
-          <div style={{fontFamily: theme.mono, fontSize: 26, color: theme.text, marginTop: 14}}>
-            {'bash("rm -rf ./tmp/build-cache")'}
-          </div>
-          <div style={{fontFamily: theme.mono, fontSize: 28, color: theme.dim, marginTop: 18}}>
-            {'Allow? [y/N] '}
-            <span style={{color: theme.core, opacity: Math.floor(frame / 12) % 2 === 0 ? 1 : 0.2}}>
-              {'▍'}
-            </span>
-          </div>
-        </Panel>
-      ) : null}
+      <Panel
+        accent={theme.mech}
+        style={{
+          position: 'absolute',
+          width: 760,
+          padding: '26px 30px',
+          background: theme.panel,
+          top: '52%',
+          opacity: askOp,
+        }}
+      >
+        <div style={{display: 'flex', alignItems: 'center', gap: 12}}>
+          {/* 绘制的三角叹号（不用 emoji——全彩字形会击穿三色契约） */}
+          <svg width={30} height={27} style={{flexShrink: 0}}>
+            <path
+              d="M15 2 L28 25 L2 25 Z"
+              fill="none"
+              stroke={theme.deny}
+              strokeWidth={3}
+              strokeLinejoin="round"
+            />
+            <line x1={15} y1={10} x2={15} y2={18} stroke={theme.deny} strokeWidth={3} strokeLinecap="round" />
+            <circle cx={15} cy={22.5} r={1.8} fill={theme.deny} />
+          </svg>
+          <span style={{fontFamily: theme.sans, fontSize: 24, color: theme.mech}}>
+            {'Potentially destructive command'}
+          </span>
+        </div>
+        <div style={{fontFamily: theme.mono, fontSize: 26, color: theme.text, marginTop: 14}}>
+          {'bash("rm -rf ./tmp/build-cache")'}
+        </div>
+        <div style={{fontFamily: theme.mono, fontSize: 28, color: theme.dim, marginTop: 18}}>
+          {'Allow? [y/N] '}
+          <span style={{color: theme.core, opacity: Math.floor(frame / 12) % 2 === 0 ? 1 : 0.2}}>
+            {'▍'}
+          </span>
+        </div>
+      </Panel>
       {t2 > 0 ? (
         <div style={{position: 'absolute', bottom: 200, width: 1120}}>
           <div style={{fontFamily: theme.sans, fontSize: 22, color: theme.dim, marginBottom: 6}}>
@@ -238,7 +233,7 @@ const AskAndPass: React.FC<{askAt: number; passAt: number}> = ({askAt, passAt})
             top: 56,
             display: 'flex',
             gap: 18,
-            opacity: interpolate(t2, [0.4, 0.8], [0, 1], {extrapolateRight: 'clamp'}),
+            opacity: win(t2, [0.4, 0.8]),
           }}
         >
           {[
@@ -280,6 +275,11 @@ const DenyListHonesty: React.FC<{degradeAt: number; bypassAt: number; quoteAt: n
   quoteAt,
 }) => {
   const frame = useCurrentFrame();
+  // hooks 先于 QuoteCard 早退（Rules of Hooks：调用数须恒定）
+  const degradeOp = useProgress(degradeAt, DUR.f3);
+  const bypassOp = useProgress(bypassAt, DUR.f3);
+  // 绕过变体：stride 8 错峰滑入，22f 描入（≥22 保留显式时长）
+  const variantP = useStagger(3, {at: bypassAt, stride: 8, dur: 22});
   if (frame >= quoteAt) {
     return <QuoteCard zh="它告诉你闸门装在哪儿，不是替你把门守住。" accent={theme.deny} />;
   }
@@ -302,17 +302,18 @@ const DenyListHonesty: React.FC<{degradeAt: number; bypassAt: number; quoteAt: n
           showLineNumbers={false}
           accent={degraded ? undefined : theme.deny}
         />
-        {degraded ? (
-          <div
-            style={{
-              position: 'absolute',
-              inset: 0,
-              border: `2px dashed ${theme.dim}`,
-              borderRadius: 14,
-              pointerEvents: 'none',
-            }}
-          />
-        ) : null}
+        {/* 降级虚框：绝对定位无布局影响——瞬现门 → 淡入 */}
+        <div
+          style={{
+            position: 'absolute',
+            inset: 0,
+            border: `2px dashed ${theme.dim}`,
+            borderRadius: 14,
+            pointerEvents: 'none',
+            opacity: degradeOp,
+          }}
+        />
+        {/* 降级说明是常规流子节点：恒渲染会永久改变行内居中（几何变化），保留瞬现门 */}
         {degraded ? (
           <div
             style={{
@@ -329,10 +330,7 @@ const DenyListHonesty: React.FC<{degradeAt: number; bypassAt: number; quoteAt: n
       </div>
       <div style={{width: 430}}>
         {variants.map((v, i) => {
-          const t = interpolate(frame - bypassAt - i * 8, [0, 22], [0, 1], {
-            extrapolateLeft: 'clamp',
-            extrapolateRight: 'clamp',
-          });
+          const t = variantP[i];
           if (t <= 0) return null;
           return (
             <div
@@ -350,11 +348,12 @@ const DenyListHonesty: React.FC<{degradeAt: number; bypassAt: number; quoteAt: n
             </div>
           );
         })}
-        {frame >= bypassAt ? (
-          <div style={{fontFamily: theme.sans, fontSize: 22, color: theme.dim, marginTop: 10}}>
-            {'换个拼法就绕过去了'}
-          </div>
-        ) : null}
+        {/* 末位流子节点且右列恒短于左列——恒渲染无布局影响，瞬现门 → 淡入 */}
+        <div
+          style={{fontFamily: theme.sans, fontSize: 22, color: theme.dim, marginTop: 10, opacity: bypassOp}}
+        >
+          {'换个拼法就绕过去了'}
+        </div>
       </div>
     </AbsoluteFill>
   );
@@ -370,11 +369,12 @@ const FourResults: React.FC<{fourthAt: number; arcAt: number}> = ({fourthAt, arc
     {t: '问你', en: 'ask', c: theme.mech},
     {t: '不表态', en: 'passthrough', c: theme.dim},
   ];
-  const arc = interpolate(frame - arcAt, [0, 24], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
-  const breathe = 0.5 + 0.5 * Math.sin(frame / 8);
+  // 回连弧 24f 是 beat 级（≥22 保留显式时长）。弧进度同时驱动 svg 守卫与「兜底」
+  // 字门——draw 三元组保持内联共享同一进度（换 useDraw 会 fork 出 decelerate
+  // 进度，使 0.9 字门与描线失同步）
+  const arc = useProgress(arcAt, 24);
+  // sin(frame/8) → period 2π·8
+  const breathe = useBreathe({period: 2 * Math.PI * 8, amp: 0.5, base: 0.5});
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <div style={{position: 'relative'}}>
@@ -382,7 +382,9 @@ const FourResults: React.FC<{fourthAt: number; arcAt: number}> = ({fourthAt, arc
           {cells.map((c, i) => {
             const fourth = i === 3;
             const on = fourth ? frame >= fourthAt : true;
-            const e = spring({frame: frame - (fourth ? fourthAt : i * 5), fps, config: {damping: 200}});
+            // 弹簧在 map 内保持纯调用（锚点非均匀：三格 i*5、第四格 fourthAt）；
+            // damping 200 → SPRING.settle
+            const e = spring({frame: frame - (fourth ? fourthAt : i * 5), fps, config: SPRING.settle});
             return (
               <Panel
                 key={c.en}
@@ -443,17 +445,14 @@ const EvalOrder: React.FC<{orderAt: number; ballAt: number; denyHitAt: number; n
     {t: '询问 ask', c: 'mech', sub: '命中即出局'},
     {t: '放行 allow', c: 'core', sub: '兜底到它'},
   ];
-  // 光点沿三站行进；在第二幕演示里被第①站截获
-  const travel = interpolate(frame - ballAt, [0, 46], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  // 光点沿三站行进；在第二幕演示里被第①站截获（46f beat 级，保留显式时长）
+  const travel = useProgress(ballAt, 46);
   const hit = frame >= denyHitAt;
   const naked = frame >= nakedAt;
-  const orderOn = interpolate(frame - orderAt, [0, 20], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  // 顺序点亮 20f → f6 档
+  const orderOn = useProgress(orderAt, DUR.f6);
+  // 裸名 deny 注释：门保留（元素本就以 opacity 淡入），14f → f6 档
+  const nakedOp = useProgress(nakedAt, DUR.f6);
   const PX = 300; // 轨道起点
   const GAP = 380;
   return (
@@ -501,7 +500,8 @@ const EvalOrder: React.FC<{orderAt: number; ballAt: number; denyHitAt: number; n
         {/* 三站闸门 */}
         {stations.map((st, i) => {
           const at = orderAt + 4 + i * 7;
-          const e = spring({frame: frame - at, fps, config: {damping: 200}});
+          // map 内弹簧保持纯调用；damping 200 → SPRING.settle
+          const e = spring({frame: frame - at, fps, config: SPRING.settle});
           const color = st.c === 'deny' ? theme.deny : st.c === 'mech' ? theme.mech : theme.core;
           return (
             <div
@@ -537,7 +537,7 @@ const EvalOrder: React.FC<{orderAt: number; ballAt: number; denyHitAt: number; n
               display: 'flex',
               alignItems: 'center',
               gap: 14,
-              opacity: interpolate(frame - nakedAt, [0, 14], [0, 1], {extrapolateRight: 'clamp'}),
+              opacity: nakedOp,
             }}
           >
             <span style={{fontFamily: theme.mono, fontSize: 24, color: theme.dim, textDecoration: 'line-through'}}>
@@ -575,10 +575,12 @@ const ClassifierVision: React.FC<{scrollAt: number; stripAt: number; goldenAt: n
     {t: '裸命令：npm install --save-dev vitest', why: '', strike: false},
   ];
   const spoofOn = frame >= spoofAt;
-  const golden = interpolate(frame - goldenAt, [0, 18], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  // 金化 18f → f6 档
+  const golden = useProgress(goldenAt, DUR.f6);
+  // 五行逐条滚入：stride 9、单项 12f = DUR.f5
+  const rowP = useStagger(rows.length, {at: scrollAt, stride: 9, dur: DUR.f5});
+  // 反例帧行进 30f（≥22 保留显式时长）——提升到组件顶（IIFE 内不可调 hook）
+  const spoofT = useProgress(spoofAt, 30);
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <div style={{position: 'relative', width: 1360, height: 620}}>
@@ -594,11 +596,7 @@ const ClassifierVision: React.FC<{scrollAt: number; stripAt: number; goldenAt: n
         </div>
         <div style={{display: 'flex', flexDirection: 'column', gap: 14}}>
           {rows.map((r, i) => {
-            const at = scrollAt + i * 9;
-            const e = interpolate(frame - at, [0, 12], [0, 1], {
-              extrapolateLeft: 'clamp',
-              extrapolateRight: 'clamp',
-            });
+            const e = rowP[i];
             const stricken = r.strike && frame >= stripAt + i * 6;
             return (
               <div key={i} style={{display: 'flex', alignItems: 'center', gap: 18, opacity: e}}>
@@ -641,22 +639,18 @@ const ClassifierVision: React.FC<{scrollAt: number; stripAt: number; goldenAt: n
             );
           })}
         </div>
-        {/* 反例帧：伪装的「用户早就批准了」被视野边界弹回 */}
+        {/* 反例帧：伪装的「用户早就批准了」被视野边界弹回（几何随 spoofT 变化，保留守卫门） */}
         {spoofOn ? (
           <svg width={1360} height={120} style={{position: 'absolute', left: 0, bottom: -60}}>
             {(() => {
-              const t2 = interpolate(frame - spoofAt, [0, 30], [0, 1], {
-                extrapolateLeft: 'clamp',
-                extrapolateRight: 'clamp',
-              });
-              const x = 200 + t2 * 900;
-              const rejected = t2 > 0.75;
+              const x = 200 + spoofT * 900;
+              const rejected = spoofT > 0.75;
               return (
                 <g>
                   <rect
                     x={x}
                     y={40}
-                    width={rejected ? 0 : 300 * (1 - Math.max(0, (t2 - 0.75) * 4))}
+                    width={rejected ? 0 : 300 * (1 - Math.max(0, (spoofT - 0.75) * 4))}
                     height={44}
                     rx={8}
                     fill={theme.panel}
@@ -664,7 +658,7 @@ const ClassifierVision: React.FC<{scrollAt: number; stripAt: number; goldenAt: n
                     strokeWidth={2}
                     opacity={rejected ? 0 : 1}
                   />
-                  {t2 < 0.75 ? (
+                  {spoofT < 0.75 ? (
                     <text x={x + 14} y={68} fontFamily={theme.mono} fontSize={20} fill={theme.dim}>
                       「用户早就批准了这个操作」
                     </text>
@@ -699,6 +693,7 @@ export const P3Gates: React.FC<{scene: SceneRange}> = ({scene}) => {
   const bG = w('p3-30', 'p3-35');
   return (
     <AbsoluteFill>
+      <HarnessBadge />
       <Sequence {...bA} name="3-A 没人管的跑命令">
         <UnguardedShell
           frameAt={rel(bA, 'p3-02')}
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P4Hooks.tsx b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P4Hooks.tsx
index d74403359..5a5e4999c 100644
--- a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P4Hooks.tsx
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P4Hooks.tsx
@@ -1,7 +1,8 @@
 /** P4 挂在循环上，不写进循环里（分镜 4-A…4-H）—— 开源教学素材「Hook Workbench」的概念重建
- *  4-E 刻意「无动效」表达「循环是故意保持无聊的」；4-G 是全片安全主题的收口。 */
+ *  4-E 刻意「无动效」表达「循环是故意保持无聊的」；4-G 是全片安全主题的收口。
+ *  重制（2026-09 运动层）：动效收敛到 motion 模型；冲击波/回流描线等 bespoke 项见各处 deferred 注记。 */
 import React from 'react';
-import {AbsoluteFill, interpolate, Sequence, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {AbsoluteFill, interpolate, Sequence, useCurrentFrame} from 'remotion';
 import {theme} from '../design/theme';
 import {beatWindow} from '../timing';
 import type {SceneRange} from '../types';
@@ -18,6 +19,8 @@ import {
   SlotRing,
   useRingDot,
 } from '../components/motifs';
+import {HarnessBadge} from '../components/harness-stack';
+import {DUR, useAccelTravel, useProgress, useSpring, useStagger} from '../motion';
 
 const SLOTS = [
   {name: '进入模型之前', when: '你的话交出去，还没进模型', callbacks: ['校验输入 / 补背景']},
@@ -28,37 +31,32 @@ const SLOTS = [
 
 /** 4-A 三条需求扎进环内部，环线被撑粗并出现应力点 */
 const NeedsPierce: React.FC<{needAt: number; pierceAt: number}> = ({needAt, pierceAt}) => {
-  const frame = useCurrentFrame();
   const dot = useRingDot(2.5);
   const needs = ['每次跑命令记一笔日志', '某些操作后自动提交代码', '危险动作往群里发通知'];
-  const pierce = interpolate(frame - pierceAt, [0, 20], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  // 环线应力撑开：20f → f6（13-21 档）
+  const pierce = useProgress(pierceAt, DUR.f6);
+  // 三张需求卡错峰滑入（stride 8、单项 14f → f6）
+  const needP = useStagger(needs.length, {at: needAt, stride: 8, dur: DUR.f6});
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center', flexDirection: 'row', gap: 80}}>
       <SceneTag chapter="Hooks" tagline="Hang on the Loop, Don't Write into It" />
       <div style={{position: 'relative'}}>
         <LoopRing size={400} draw={1} dotProgress={dot} />
-        {pierce > 0.4 ? (
-          <div
-            style={{
-              position: 'absolute',
-              inset: 0,
-              borderRadius: 999,
-              boxShadow: `0 0 ${26 * pierce}px ${theme.deny}`,
-              opacity: pierce - 0.4,
-              pointerEvents: 'none',
-            }}
-          />
-        ) : null}
+        {/* 应力辉光：原布尔门改常渲染，透明度自 0.4 起亮（负值钳 0） */}
+        <div
+          style={{
+            position: 'absolute',
+            inset: 0,
+            borderRadius: 999,
+            boxShadow: `0 0 ${26 * pierce}px ${theme.deny}`,
+            opacity: Math.max(0, pierce - 0.4),
+            pointerEvents: 'none',
+          }}
+        />
       </div>
       <div>
         {needs.map((n, i) => {
-          const t = interpolate(frame - needAt - i * 8, [0, 14], [0, 1], {
-            extrapolateLeft: 'clamp',
-            extrapolateRight: 'clamp',
-          });
+          const t = needP[i];
           return (
             <div
               key={n}
@@ -101,6 +99,7 @@ const DegradedLoop: React.FC<{quoteAt: number}> = ({quoteAt}) => {
     '            auto_git_add(block)       # 再加一行',
     '            # ... 很快循环就认不出来了',
   ];
+  // 逐条插入的量化节拍（14f 一档）：阶梯式挤出视区是刻意的量化舞台，不模型化
   const inserted = Math.min(5, Math.max(0, Math.floor((frame - 6) / 14)));
   const shift = inserted * 26;
   return (
@@ -122,11 +121,18 @@ const DegradedLoop: React.FC<{quoteAt: number}> = ({quoteAt}) => {
 /** 4-C 杂活被拔出循环、变成回调卡，环恢复原线宽 */
 const PullOut: React.FC<{tableAt: number; plugAt: number}> = ({tableAt, plugAt}) => {
   const frame = useCurrentFrame();
-  const {fps} = useVideoConfig();
   const dot = useRingDot(2.5);
-  const out = interpolate(frame, [0, 26], [0, 1], {extrapolateRight: 'clamp'});
-  const plug = spring({frame: frame - plugAt, fps, config: {damping: 12}});
+  // 拔出收束：26f 属 beat 级大位移（≥22，保留显式时长）
+  const out = useProgress(0, 26);
+  // 插头咬合的过冲：damping 12 即 snap 预设的锚定来源
+  const plug = useSpring('snap', {at: plugAt});
+  // 咬合瞬间的 2 帧高亮闪（模式切换，保留硬切）
   const flash = frame >= plugAt + 6 && frame < plugAt + 8;
+  // 表格与插头句：原布尔瞬现门 → 常渲染 + f3 淡入
+  const tableOp = useProgress(tableAt, DUR.f3);
+  const plugOp = useProgress(plugAt, DUR.f3);
+  // 四行时机错峰浮现（stride 5、单项 10f → f5）
+  const rowP = useStagger(4, {at: tableAt, stride: 5, dur: DUR.f5});
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center', flexDirection: 'row', gap: 70}}>
       <div style={{position: 'relative'}}>
@@ -152,46 +158,45 @@ const PullOut: React.FC<{tableAt: number; plugAt: number}> = ({tableAt, plugAt})
           );
         })}
       </div>
+      {/* 两元素均为常规流子节点：布局门保留（常驻会把 Panel 顶高 ~80px），门内淡入 */}
       <div>
         {frame >= tableAt ? (
-          <Panel style={{padding: '18px 22px', width: 560}}>
-            <div style={{display: 'flex', fontFamily: theme.sans, fontSize: 22, color: theme.dim, paddingBottom: 10}}>
-              <div style={{flex: 1}}>{'时机'}</div>
-              <div style={{flex: 1}}>{'要跑的函数'}</div>
+        <Panel style={{padding: '18px 22px', width: 560, opacity: tableOp}}>
+          <div style={{display: 'flex', fontFamily: theme.sans, fontSize: 22, color: theme.dim, paddingBottom: 10}}>
+            <div style={{flex: 1}}>{'时机'}</div>
+            <div style={{flex: 1}}>{'要跑的函数'}</div>
+          </div>
+          {['进模型前', '执行前', '执行后', '停机前'].map((k, i) => (
+            <div
+              key={k}
+              style={{
+                display: 'flex',
+                height: 48,
+                alignItems: 'center',
+                fontFamily: theme.mono,
+                fontSize: 24,
+                opacity: rowP[i],
+              }}
+            >
+              <div style={{flex: 1, color: theme.mech}}>{k}</div>
+              <div style={{flex: 1, color: theme.dim}}>{'[ … ]'}</div>
             </div>
-            {['进模型前', '执行前', '执行后', '停机前'].map((k, i) => (
-              <div
-                key={k}
-                style={{
-                  display: 'flex',
-                  height: 48,
-                  alignItems: 'center',
-                  fontFamily: theme.mono,
-                  fontSize: 24,
-                  opacity: interpolate(frame - tableAt - i * 5, [0, 10], [0, 1], {
-                    extrapolateLeft: 'clamp',
-                    extrapolateRight: 'clamp',
-                  }),
-                }}
-              >
-                <div style={{flex: 1, color: theme.mech}}>{k}</div>
-                <div style={{flex: 1, color: theme.dim}}>{'[ … ]'}</div>
-              </div>
-            ))}
-          </Panel>
+          ))}
+        </Panel>
         ) : null}
         {frame >= plugAt ? (
-          <div
-            style={{
-              marginTop: 20,
-              fontFamily: theme.serif,
-              fontSize: 32,
-              color: theme.mech,
-              transform: `translateX(${(1 - plug) * -40}px)`,
-            }}
-          >
-            {'加功能是插一个插头，不是重新布线'}
-          </div>
+        <div
+          style={{
+            marginTop: 20,
+            fontFamily: theme.serif,
+            fontSize: 32,
+            color: theme.mech,
+            opacity: plugOp,
+            transform: `translateX(${(1 - plug) * -40}px)`,
+          }}
+        >
+          {'加功能是插一个插头，不是重新布线'}
+        </div>
         ) : null}
       </div>
     </AbsoluteFill>
@@ -207,14 +212,12 @@ const SlotsLightUp: React.FC<{slotAt: number[]; gateMoveAt: number; backflowAt:
   const frame = useCurrentFrame();
   const dot = useRingDot(2.5);
   const lit = slotAt.filter((a) => frame >= a).length - 1;
-  const gm = interpolate(frame - gateMoveAt, [0, 24], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
-  const back = interpolate(frame - backflowAt, [0, 22], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  // P3 闸门搬入插槽：24f 属 beat 级（≥22，保留显式时长）
+  const gm = useProgress(gateMoveAt, 24);
+  // 回流描线：22f 属 beat 级（≥22，保留显式时长）
+  const back = useProgress(backflowAt, 22);
+  // 闸门组原布尔瞬现门 → 常渲染 + f3 淡入（再叠加 gm 的压暗）
+  const gateOp = useProgress(gateMoveAt, DUR.f3);
   // 容器尺寸由 SlotRing 的定位契约推导（见该组件 docstring），环居中
   const RING = 400;
   const W = RING + 2 * (SLOT_W + SLOT_GAP);
@@ -227,35 +230,33 @@ const SlotsLightUp: React.FC<{slotAt: number[]; gateMoveAt: number; backflowAt:
         </div>
         <SlotRing slots={SLOTS} lit={lit} size={RING} />
         {/* P3 的三道闸门缩小平移进右上角的「工具执行之前」插槽（跨幕视觉呼应） */}
-        {gm > 0 ? (
-          <svg
-            width={220}
-            height={90}
-            style={{
-              position: 'absolute',
-              /* 终点对准右上角插槽的左缘与垂直中部：起点在环右侧（P3 闸门的位置），
-                 gm=1 时贴到该插槽旁，读作「闸门被搬进这个插口」 */
-              left: W / 2 + 60 + gm * (W - SLOT_W - 100 - (W / 2 + 60)),
-              top: H / 2 - 45 - gm * (H / 2 - 105),
-              opacity: 1 - gm * 0.35,
-            }}
-          >
-            {[0, 1, 2].map((i) => (
-              <rect
-                key={i}
-                x={20 + i * 42}
-                y={18 * gm}
-                width={11 * (1 - gm * 0.4)}
-                height={54 * (1 - gm * 0.45)}
-                rx={4}
-                fill={i === 0 ? theme.deny : 'none'}
-                stroke={i === 0 ? theme.deny : theme.mech}
-                strokeWidth={3}
-                strokeDasharray={i === 2 ? '7 5' : undefined}
-              />
-            ))}
-          </svg>
-        ) : null}
+        <svg
+          width={220}
+          height={90}
+          style={{
+            position: 'absolute',
+            /* 终点对准右上角插槽的左缘与垂直中部：起点在环右侧（P3 闸门的位置），
+               gm=1 时贴到该插槽旁，读作「闸门被搬进这个插口」 */
+            left: W / 2 + 60 + gm * (W - SLOT_W - 100 - (W / 2 + 60)),
+            top: H / 2 - 45 - gm * (H / 2 - 105),
+            opacity: gateOp * (1 - gm * 0.35),
+          }}
+        >
+          {[0, 1, 2].map((i) => (
+            <rect
+              key={i}
+              x={20 + i * 42}
+              y={18 * gm}
+              width={11 * (1 - gm * 0.4)}
+              height={54 * (1 - gm * 0.45)}
+              rx={4}
+              fill={i === 0 ? theme.deny : 'none'}
+              stroke={i === 0 ? theme.deny : theme.mech}
+              strokeWidth={3}
+              strokeDasharray={i === 2 ? '7 5' : undefined}
+            />
+          ))}
+        </svg>
         {/* 「别停，接着干」：从左下角插槽回流到环的入口（问模型节点） */}
         {back > 0 ? (
           <svg
@@ -370,15 +371,18 @@ const HookNesting: React.FC<{outerAt: number; midAt: number; innerAt: number; co
   asyncAt,
 }) => {
   const frame = useCurrentFrame();
-  const {fps} = useVideoConfig();
-  // 三层依次成形的进度
-  const o = interpolate(frame - outerAt, [0, 16], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
-  const m = interpolate(frame - midAt, [0, 16], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
-  const i = interpolate(frame - innerAt, [0, 16], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
-  // 内层光点沿「工具前→执行→工具后→整批落定」跑一圈
+  // 三层依次成形的进度（单项 16f → f6）
+  const o = useProgress(outerAt, DUR.f6);
+  const m = useProgress(midAt, DUR.f6);
+  const i = useProgress(innerAt, DUR.f6);
+  // 内层光点沿「工具前→执行→工具后→整批落定」跑一圈：80f 周期模除驱动 bespoke 位置
+  // 高亮（非环形巡游，useTravel 不适用），保留内联（deferred）
   const lap = ((frame - innerAt) % 80) / 80;
   const lapOn = frame >= innerAt + 16;
   const asyncEvents = ['会话开始', '会话结束', '配置变更', '目录切换', '文件被改', '通知'];
+  // 右栏整体淡入（16f → f6）+ 六格错峰（stride 3、单项 8f → f3）
+  const asyncOp = useProgress(asyncAt, DUR.f6);
+  const asyncCells = useStagger(asyncEvents.length, {at: asyncAt, stride: 3, dur: DUR.f3});
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <div style={{position: 'relative', width: 1500, height: 640}}>
@@ -465,10 +469,7 @@ const HookNesting: React.FC<{outerAt: number; midAt: number; innerAt: number; co
             right: 0,
             top: 10,
             width: 420,
-            opacity: interpolate(frame - asyncAt, [0, 16], [0, 1], {
-              extrapolateLeft: 'clamp',
-              extrapolateRight: 'clamp',
-            }),
+            opacity: asyncOp,
           }}
         >
           <div style={{fontFamily: theme.sans, fontSize: 22, color: theme.dim, marginBottom: 12}}>
@@ -486,10 +487,7 @@ const HookNesting: React.FC<{outerAt: number; midAt: number; innerAt: number; co
                   fontSize: 19,
                   color: theme.dim,
                   background: theme.panel,
-                  opacity: interpolate(frame - asyncAt - k * 3, [0, 8], [0, 1], {
-                    extrapolateLeft: 'clamp',
-                    extrapolateRight: 'clamp',
-                  }),
+                  opacity: asyncCells[k],
                 }}
               >
                 {e}
@@ -528,13 +526,14 @@ const StampClash: React.FC<{
   quoteAt: number;
 }> = ({pushAt, blockAt, arrowAt, gapAt, quoteAt}) => {
   const frame = useCurrentFrame();
+  // 上层印章推进 18f → f6；箭头组 20f → f6；缺口警示条原布尔门 → f3 淡入。
+  // hooks 必须先于金句早退调用（Rules of Hooks：早退后不得再出现 hook）
+  const push = useProgress(pushAt, DUR.f6);
+  const arrow = useProgress(arrowAt, DUR.f6);
+  const gapOp = useProgress(gapAt, DUR.f3);
   if (frame >= quoteAt) {
     return <QuoteCard zh="扩展点能加限制，不能解除限制。" accent={theme.core} />;
   }
-  const push = interpolate(frame - pushAt, [0, 18], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
   const blocked = frame >= blockAt;
   /* 「顶住」不能是一次性瞬间事件：旁白「配置里的禁止和询问仍然要再走一遍」有 4 秒多，
      若冲击波 16 帧就衰减完，画面在这句的大部分时间里是静止的、读不出对撞。
@@ -545,15 +544,11 @@ const StampClash: React.FC<{
         extrapolateRight: 'clamp',
       }) + (frame - blockAt > 24 ? Math.sin((frame - blockAt) / 7) * 3.5 : 0)
     : 0;
-  // 冲击波每 34 帧复发一次（持续施压 → 持续被顶回）
+  // 冲击波每 34 帧复发一次（持续施压 → 持续被顶回）——模除包络 + 条件抖动是刻意的
+  // 周期性冲击模型，motion 层暂无对应原语，保留 bespoke（deferred：需 periodic-impulse 模型）
   const shock = blocked
     ? interpolate((frame - blockAt) % 34, [0, 16], [0, 1], {extrapolateRight: 'clamp'})
     : 0;
-  const arrow = interpolate(frame - arrowAt, [0, 20], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
-  const gap = frame >= gapAt;
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <div style={{position: 'relative', width: 1560, height: 660}}>
@@ -607,50 +602,47 @@ const StampClash: React.FC<{
             ))}
           </svg>
         ) : null}
-        {arrow > 0 ? (
-          <div style={{position: 'absolute', left: 1010, top: 150, width: 500, opacity: arrow}}>
-            <Panel accent={theme.mech} style={{padding: '20px 26px', marginBottom: 20}}>
-              <div style={{fontFamily: theme.sans, fontSize: 30, color: theme.mech}}>
-                {'加限制　↑　可以'}
-              </div>
-            </Panel>
-            <Panel accent={theme.deny} style={{padding: '20px 26px'}}>
-              <div style={{fontFamily: theme.sans, fontSize: 30, color: theme.deny}}>
-                {'解除限制　↓　不行'}
-              </div>
-            </Panel>
-            <div
-              style={{
-                marginTop: 18,
-                fontFamily: theme.serif,
-                fontSize: 26,
-                color: theme.dim,
-                lineHeight: 1.5,
-              }}
-            >
-              {'方向是单向的'}
+        <div style={{position: 'absolute', left: 1010, top: 150, width: 500, opacity: arrow}}>
+          <Panel accent={theme.mech} style={{padding: '20px 26px', marginBottom: 20}}>
+            <div style={{fontFamily: theme.sans, fontSize: 30, color: theme.mech}}>
+              {'加限制　↑　可以'}
             </div>
-          </div>
-        ) : null}
-        {gap ? (
+          </Panel>
+          <Panel accent={theme.deny} style={{padding: '20px 26px'}}>
+            <div style={{fontFamily: theme.sans, fontSize: 30, color: theme.deny}}>
+              {'解除限制　↓　不行'}
+            </div>
+          </Panel>
           <div
             style={{
-              position: 'absolute',
-              left: 300,
-              top: 552,
-              width: 640,
-              border: `3px dashed ${theme.deny}`,
-              borderRadius: 10,
-              padding: '14px 18px',
-              fontFamily: theme.sans,
+              marginTop: 18,
+              fontFamily: theme.serif,
               fontSize: 26,
-              color: theme.deny,
-              textAlign: 'center',
+              color: theme.dim,
+              lineHeight: 1.5,
             }}
           >
-            {'教学版缺这一层 → 生产环境的安全漏洞'}
+            {'方向是单向的'}
           </div>
-        ) : null}
+        </div>
+        <div
+          style={{
+            position: 'absolute',
+            left: 300,
+            top: 552,
+            width: 640,
+            border: `3px dashed ${theme.deny}`,
+            borderRadius: 10,
+            padding: '14px 18px',
+            fontFamily: theme.sans,
+            fontSize: 26,
+            color: theme.deny,
+            textAlign: 'center',
+            opacity: gapOp,
+          }}
+        >
+          {'教学版缺这一层 → 生产环境的安全漏洞'}
+        </div>
       </div>
       <Footnote delay={arrowAt}>
         {'hook allow 不能绕过 settings 的 deny/ask —— 第三方的源码分析'}
@@ -671,14 +663,12 @@ const SixGatePipeline: React.FC<{railAt: number; runAt: number; yoloAt: number}>
     {t: 'mode', sub: '模式'},
     {t: '默认', sub: '兜底问你'},
   ];
-  const rail = interpolate(frame - railAt, [0, 22], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
-  const travel = interpolate(frame - runAt, [0, 50], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  // 轨道浮现 22f / 光点过闸 50f：均属 beat 级窗口（≥22，保留显式时长）
+  const rail = useProgress(railAt, 22);
+  const travel = useProgress(runAt, 50);
+  // 六站错峰点亮（stride 4、单项 10f → f5）；yolo 标注 12f = f5
+  const stationP = useStagger(stations.length, {at: railAt + 6, stride: 4, dur: DUR.f5});
+  const yoloOp = useProgress(yoloAt, DUR.f5);
   const yolo = frame >= yoloAt;
   // 两轮演示：第一轮光点在 deny 站被截；第二轮（全放行模式）仍在 deny 站被截
   const cutAt = 1 / 6 + 0.5 / 6;
@@ -719,11 +709,7 @@ const SixGatePipeline: React.FC<{railAt: number; runAt: number; yoloAt: number}>
         </svg>
         {/* 六站 */}
         {stations.map((st, i) => {
-          const at = railAt + 6 + i * 4;
-          const e = interpolate(frame - at, [0, 10], [0, 1], {
-            extrapolateLeft: 'clamp',
-            extrapolateRight: 'clamp',
-          });
+          const e = stationP[i];
           const isDeny = st.t === 'deny';
           const bypassed = yolo && (st.t === 'mode');
           return (
@@ -756,7 +742,7 @@ const SixGatePipeline: React.FC<{railAt: number; runAt: number; yoloAt: number}>
               fontFamily: theme.sans,
               fontSize: 23,
               color: theme.deny,
-              opacity: interpolate(frame - yoloAt, [0, 12], [0, 1], {extrapolateRight: 'clamp'}),
+              opacity: yoloOp,
             }}
           >
             {'全放行模式也一样：拒绝压得住'}
@@ -773,29 +759,13 @@ const SixGatePipeline: React.FC<{railAt: number; runAt: number; yoloAt: number}>
 /** 4-H 自激小闭环，被一枚标记截断 */
 const SelfLoopBreak: React.FC<{spinAt: number; markAt: number}> = ({spinAt, markAt}) => {
   const frame = useCurrentFrame();
-  const t = Math.max(0, frame - spinAt);
-  const durs = [34, 26, 20];
-  let acc = 0;
-  let lap = 0;
-  let within = 0;
-  for (let i = 0; i < durs.length; i++) {
-    if (t < acc + durs[i]) {
-      lap = i;
-      within = (t - acc) / durs[i];
-      break;
-    }
-    acc += durs[i];
-    lap = i + 1;
-    within = 0;
-  }
-  const marked = frame >= markAt;
-  // 第四圈行进到标记处被截断
-  const angle = marked ? -30 : -90 + within * 360;
   const cx = 260;
   const cy = 220;
   const r = 128;
-  const rad = (angle * Math.PI) / 180;
-  const heat = Math.min(1, lap / 2.5);
+  // 加速绕行（34/26/20 逐圈提速，heat 随圈数 /2.5 升温）——手写累加器 → useAccelTravel
+  const travel = useAccelTravel({cx, cy, r, durs: [34, 26, 20], at: spinAt, heatPerLap: 2.5});
+  const marked = frame >= markAt;
+  const heat = travel.heat;
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <div style={{display: 'flex', alignItems: 'center', gap: 80}}>
@@ -809,8 +779,9 @@ const SelfLoopBreak: React.FC<{spinAt: number; markAt: number}> = ({spinAt, mark
             strokeWidth={5}
             opacity={0.5 + heat * 0.5}
           />
+          {/* 光点行进至 -30°（标记处）被截断：marked 后由下方标记方块接管该位置 */}
           {!marked ? (
-            <circle cx={cx + r * Math.cos(rad)} cy={cy + r * Math.sin(rad)} r={12} fill={theme.deny} />
+            <circle cx={travel.x} cy={travel.y} r={12} fill={theme.deny} />
           ) : null}
           <text x={cx} y={cy - r - 22} textAnchor="middle" fontFamily={theme.sans} fontSize={23} fill={theme.dim}>
             {'插口说「别停」'}
@@ -858,6 +829,7 @@ export const P4Hooks: React.FC<{scene: SceneRange}> = ({scene}) => {
   const bH = w('p4-35', 'p4-37');
   return (
     <AbsoluteFill>
+      <HarnessBadge />
       <Sequence {...bA} name="4-A 需求扎进循环">
         <NeedsPierce needAt={rel(bA, 'p4-03')} pierceAt={rel(bA, 'p4-04')} />
       </Sequence>
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P5Stack.tsx b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P5Stack.tsx
index 27d72dd15..adfa4fc67 100644
--- a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P5Stack.tsx
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P5Stack.tsx
@@ -1,14 +1,17 @@
 /** P5 四层叠起来是什么（分镜 5-A…5-D）—— 主题回收
  *  5-B 的柱体用**实测值**：总行 141/191/241/255，其中循环段 23/20/24/28
  *  （非空非注释 @ pinned commit）。刻意不美化成「完全等高」——口播说的是
- *  「一直在二十到二十八行之间」，画面必须与这句话一致。 */
+ *  「一直在二十到二十八行之间」，画面必须与这句话一致。
+ *  重制（2026-09 运动层）：动效收敛 motion 模型；常驻角标 HarnessBadge（skills/06）。 */
 import React from 'react';
-import {AbsoluteFill, interpolate, Sequence, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {AbsoluteFill, Sequence, spring, useCurrentFrame, useVideoConfig} from 'remotion';
 import {theme} from '../design/theme';
 import {beatWindow} from '../timing';
 import type {SceneRange} from '../types';
 import {QuoteCard} from '../components/cards';
 import {Footnote, LoopRing, Panel, Terminal, useRingDot} from '../components/motifs';
+import {HarnessBadge} from '../components/harness-stack';
+import {DUR, SPRING, useProgress, win} from '../motion';
 
 const CHAPTERS = [
   {name: '一个循环', total: 141, loop: 23},
@@ -32,10 +35,8 @@ const FourLayers: React.FC<{splitAt: number; mapAt: number}> = ({splitAt, mapAt}
     {t: '三道闸门', s: '让危险的事在执行之前被拦住', core: false},
     {t: '一排插口', s: '让扩展挂在外面，不侵入内核', core: false},
   ];
-  const split = interpolate(frame - splitAt, [0, 22], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  // 卡片阵重排（骨架让位 / 挂件滑拢）是幕级动作：22f ≥22 不入 micro token；原线性 → standard
+  const split = useProgress(splitAt, 22);
   // 官方四件套标尺：位置对齐下方四卡的水平中心（卡宽 350 + gap 22 → 步距 372）
   const OFFICIAL = [
     {t: '循环', link: 0},
@@ -43,14 +44,12 @@ const FourLayers: React.FC<{splitAt: number; mapAt: number}> = ({splitAt, mapAt}
     {t: '上下文管理', link: -1},
     {t: '护栏', link: 3},
   ];
-  const map = interpolate(frame - mapAt, [0, 18], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
-  const linkOn = interpolate(frame - mapAt - 10, [0, 14], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  // 标尺落下 18f → f6（Δ3）；原线性 → standard
+  const map = useProgress(mapAt, DUR.f6);
+  // 连线生长 14f → f5（Δ2）；原线性 → standard
+  const linkOn = useProgress(mapAt + 10, DUR.f5);
+  // 「骨架 / 挂件 ×3」命名标注：split 窗口中点（11f）浮现，与 P6 同名标注同档
+  const nameOp = useProgress(splitAt + 11, DUR.f5);
   const CARD_W = 350;
   const GAP = 22;
   const stripLeft = 960 - (CARD_W * 4 + GAP * 3) / 2;
@@ -122,7 +121,8 @@ const FourLayers: React.FC<{splitAt: number; mapAt: number}> = ({splitAt, mapAt}
       </div>
       <div style={{display: 'flex', gap: 22, alignItems: 'flex-end'}}>
         {layers.map((l, i) => {
-          const e = spring({frame: frame - i * 8, fps, config: {damping: 200}});
+          // 四卡错峰弹入：map 内只跑纯 spring()（hook 禁入 map），settle = 既有 damping 200
+          const e = spring({frame: frame - i * 8, fps, config: SPRING.settle});
           // 骨架卡：split 后向左漂出并让位给环；挂件卡：split 后向左滑拢（对环的预演）
           const drift = l.core ? split * -60 : split * -14;
           const lift = l.core ? 0 : -split * 10;
@@ -169,6 +169,8 @@ const FourLayers: React.FC<{splitAt: number; mapAt: number}> = ({splitAt, mapAt}
                   {l.s}
                 </div>
               </Panel>
+              {/* 骨架小标：布局门保留（in-flow 子节点，常驻会顶起卡 1 底对齐），
+                  门内淡入替代瞬现——布局归布局、透明度归透明度 */}
               {l.core && split > 0.5 ? (
                 <div
                   style={{
@@ -177,6 +179,7 @@ const FourLayers: React.FC<{splitAt: number; mapAt: number}> = ({splitAt, mapAt}
                     fontFamily: theme.sans,
                     fontSize: 24,
                     color: theme.core,
+                    opacity: nameOp,
                   }}
                 >
                   {'骨架'}
@@ -186,44 +189,43 @@ const FourLayers: React.FC<{splitAt: number; mapAt: number}> = ({splitAt, mapAt}
           );
         })}
       </div>
-      {/* 环自 split 中段从卡片阵后浮出（第 6 次出场：同色同线宽），三张挂件卡尾部各引一条挂线贴向它 */}
-      {split > 0.35 ? (
-        <div
-          style={{
-            position: 'absolute',
-            left: 60,
-            top: 240,
-            opacity: interpolate(split, [0.35, 0.9], [0, 1], {extrapolateRight: 'clamp'}),
-          }}
-        >
-          <LoopRing size={300} draw={1} dotProgress={dot} showExit={false} showLabels={false} />
-          <div
-            style={{
-              textAlign: 'center',
-              marginTop: 10,
-              fontFamily: theme.mono,
-              fontSize: 22,
-              color: theme.core,
-            }}
-          >
-            {'骨架'}
-          </div>
-        </div>
-      ) : null}
-      {split > 0.5 ? (
+      {/* 环自 split 中段从卡片阵后浮出（第 6 次出场：同色同线宽），三张挂件卡尾部各引一条挂线贴向它。
+          常驻渲染：透明度走 split 域窗口，窗外恒 0（替代原布尔门） */}
+      <div
+        style={{
+          position: 'absolute',
+          left: 60,
+          top: 240,
+          opacity: win(split, [0.35, 0.9]),
+        }}
+      >
+        <LoopRing size={300} draw={1} dotProgress={dot} showExit={false} showLabels={false} />
         <div
           style={{
-            position: 'absolute',
-            right: 150,
-            bottom: 230,
-            fontFamily: theme.sans,
-            fontSize: 24,
-            color: theme.mech,
+            textAlign: 'center',
+            marginTop: 10,
+            fontFamily: theme.mono,
+            fontSize: 22,
+            color: theme.core,
           }}
         >
-          {'挂件 ×3'}
+          {'骨架'}
         </div>
-      ) : null}
+      </div>
+      {/* 挂件计数：split 中点淡入（原 split>0.5 硬门瞬现） */}
+      <div
+        style={{
+          position: 'absolute',
+          right: 150,
+          bottom: 230,
+          fontFamily: theme.sans,
+          fontSize: 24,
+          color: theme.mech,
+          opacity: nameOp,
+        }}
+      >
+        {'挂件 ×3'}
+      </div>
     </AbsoluteFill>
   );
 };
@@ -234,11 +236,10 @@ const GrowthBars: React.FC<{barAt: number; coreAt: number}> = ({barAt, coreAt})
   const {fps} = useVideoConfig();
   const H = 430;
   const maxLines = 260;
+  // 测量模式切换（柱体压暗 / core 段点亮 / 行数标注现身）：离散状态，保留硬门
   const showCore = frame >= coreAt;
-  const bandT = interpolate(frame - coreAt - 6, [0, 16], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  // 实测带 16f：距 f5/f6 均 >3（Δ4/Δ5），保留显式时长；原线性 → standard
+  const bandT = useProgress(coreAt + 6, 16);
   const yFor = (lines: number) => (lines / maxLines) * H;
   //: 柱底距容器底的实测像素：幕名标签（22px 字，行盒 ~33）+ `marginTop: 12`。
   //: 基准带必须减掉它才能落在柱子自己的行数刻度上——此前写 90，带体整体上浮 45px。
@@ -248,7 +249,8 @@ const GrowthBars: React.FC<{barAt: number; coreAt: number}> = ({barAt, coreAt})
       <div style={{position: 'relative', display: 'flex', gap: 56, alignItems: 'flex-end', height: H + 90}}>
         {CHAPTERS.map((c, i) => {
           const at = barAt + i * 9;
-          const e = spring({frame: frame - at, fps, config: {damping: 200}});
+          // 四柱错峰生长：map 内只跑纯 spring()（hook 禁入 map），settle = 既有 damping 200
+          const e = spring({frame: frame - at, fps, config: SPRING.settle});
           const h = (c.total / maxLines) * H * e;
           const ch = (c.loop / maxLines) * H * e;
           return (
@@ -320,62 +322,61 @@ const GrowthBars: React.FC<{barAt: number; coreAt: number}> = ({barAt, coreAt})
             </div>
           );
         })}
-        {/* 20–28 行实测带：横贯四柱的虚线基准带——「恒在 20–28 行」这句口播的测量仪器 */}
-        {bandT > 0 ? (
+        {/* 20–28 行实测带：横贯四柱的虚线基准带——「恒在 20–28 行」这句口播的测量仪器。
+            常驻渲染：整体透明度随 bandT 自 0 起（替代原布尔门） */}
+        <div
+          style={{
+            position: 'absolute',
+            left: -60,
+            right: -60,
+            // 锚在区间**下界**（20 行），向上长到 28 行——锚上界会让带体
+            // 落在 28→36 行，与标签写的 20–28 不符
+            bottom: yFor(20) + BAR_BASE,
+            height: yFor(28) - yFor(20),
+            background: theme.core,
+            opacity: 0.12 * bandT,
+            borderRadius: 6,
+            pointerEvents: 'none',
+          }}
+        >
+          <div
+            style={{
+              position: 'absolute',
+              left: 0,
+              right: 0,
+              top: 0,
+              borderTop: `2px dashed ${theme.core}`,
+              opacity: bandT,
+            }}
+          />
+          <div
+            style={{
+              position: 'absolute',
+              left: 0,
+              right: 0,
+              bottom: 0,
+              borderBottom: `2px dashed ${theme.core}`,
+              opacity: bandT,
+            }}
+          />
+          {/* 带宽只有 13px，标注压在带子上方会撞四根柱子各自的 loop 行数（`bottom: ch + 6`
+              恰好落在同一高度）——放到带子右侧的空白区，垂直居中对齐带体 */}
           <div
             style={{
               position: 'absolute',
-              left: -60,
-              right: -60,
-              // 锚在区间**下界**（20 行），向上长到 28 行——锚上界会让带体
-              // 落在 28→36 行，与标签写的 20–28 不符
-              bottom: yFor(20) + BAR_BASE,
-              height: yFor(28) - yFor(20),
-              background: theme.core,
-              opacity: 0.12 * bandT,
-              borderRadius: 6,
-              pointerEvents: 'none',
+              left: '100%',
+              marginLeft: 14,
+              top: -8,
+              whiteSpace: 'nowrap',
+              fontFamily: theme.mono,
+              fontSize: 22,
+              color: theme.core,
+              opacity: bandT,
             }}
           >
-            <div
-              style={{
-                position: 'absolute',
-                left: 0,
-                right: 0,
-                top: 0,
-                borderTop: `2px dashed ${theme.core}`,
-                opacity: bandT,
-              }}
-            />
-            <div
-              style={{
-                position: 'absolute',
-                left: 0,
-                right: 0,
-                bottom: 0,
-                borderBottom: `2px dashed ${theme.core}`,
-                opacity: bandT,
-              }}
-            />
-            {/* 带宽只有 13px，标注压在带子上方会撞四根柱子各自的 loop 行数（`bottom: ch + 6`
-                恰好落在同一高度）——放到带子右侧的空白区，垂直居中对齐带体 */}
-            <div
-              style={{
-                position: 'absolute',
-                left: '100%',
-                marginLeft: 14,
-                top: -8,
-                whiteSpace: 'nowrap',
-                fontFamily: theme.mono,
-                fontSize: 22,
-                color: theme.core,
-                opacity: bandT,
-              }}
-            >
-              {'循环函数行数带 20–28（实测）'}
-            </div>
+            {'循环函数行数带 20–28（实测）'}
           </div>
-        ) : null}
+        </div>
       </div>
       <Footnote delay={coreAt}>
         {'总行 141 → 255（+81%）·  循环函数恒在 20–28 行（非空非注释）'}
@@ -389,7 +390,10 @@ const SameRingFourLabels: React.FC<{flipAt: number; quoteAt: number}> = ({flipAt
   const frame = useCurrentFrame();
   const dot = useRingDot(2.5);
   const labels = ['写死一个命令', '查一张表', '先过一道闸门', '交给一排插口'];
+  // 标签翻牌是离散事件（每 12f 一翻），保留整数翻转
   const idx = frame < flipAt ? -1 : Math.min(labels.length - 1, Math.floor((frame - flipAt) / 12));
+  // 首翻起淡入计数标注（原 idx>=0 硬门瞬现）；在 QuoteCard 早退之前取——hook 数量须恒定
+  const flipOp = useProgress(flipAt, DUR.f3);
   if (frame >= quoteAt) {
     return (
       <QuoteCard zh="骨架一字未改，变的只有「执行」那一步怎么写。" accent={theme.core} />
@@ -405,22 +409,21 @@ const SameRingFourLabels: React.FC<{flipAt: number; quoteAt: number}> = ({flipAt
           activeNode={2}
           nodeLabels={['问模型', '看回答', idx < 0 ? '执行工具' : labels[idx], '填回结果']}
         />
-        {idx >= 0 ? (
-          <div
-            style={{
-              position: 'absolute',
-              left: 0,
-              right: 0,
-              bottom: -78,
-              textAlign: 'center',
-              fontFamily: theme.mono,
-              fontSize: 24,
-              color: theme.mech,
-            }}
-          >
-            {`第 ${idx + 1} 次写法`}
-          </div>
-        ) : null}
+        <div
+          style={{
+            position: 'absolute',
+            left: 0,
+            right: 0,
+            bottom: -78,
+            textAlign: 'center',
+            fontFamily: theme.mono,
+            fontSize: 24,
+            color: theme.mech,
+            opacity: flipOp,
+          }}
+        >
+          {`第 ${idx + 1} 次写法`}
+        </div>
       </div>
       <Footnote delay={flipAt}>{'同一个位置，换了四次写法'}</Footnote>
     </AbsoluteFill>
@@ -430,6 +433,9 @@ const SameRingFourLabels: React.FC<{flipAt: number; quoteAt: number}> = ({flipAt
 /** 5-D 回到 P0 的终端，这次它自己跑起来 */
 const SelfRunning: React.FC<{shellAt: number; quoteAt: number}> = ({shellAt, quoteAt}) => {
   const frame = useCurrentFrame();
+  // 壳合拢是幕级动作：26f ≥22 不入 micro token；原线性 → standard。
+  // 在 QuoteCard 早退之前取——hook 数量须恒定
+  const shell = useProgress(shellAt, 26);
   if (frame >= quoteAt) {
     return (
       <QuoteCard
@@ -439,10 +445,6 @@ const SelfRunning: React.FC<{shellAt: number; quoteAt: number}> = ({shellAt, quo
       />
     );
   }
-  const shell = interpolate(frame - shellAt, [0, 26], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <div style={{position: 'relative'}}>
@@ -457,22 +459,20 @@ const SelfRunning: React.FC<{shellAt: number; quoteAt: number}> = ({shellAt, quo
             {text: 'python ./tools/fmt.py  →  完成', color: theme.mech, delay: 80},
           ]}
         />
-        {/* 四层结构在终端外围合拢成一个壳 */}
-        {shell > 0 ? (
-          <div
-            style={{
-              position: 'absolute',
-              left: -34 + shell * 12,
-              top: -34 + shell * 12,
-              right: -34 + shell * 12,
-              bottom: -34 + shell * 12,
-              border: `3px solid ${theme.core}`,
-              borderRadius: 22,
-              opacity: shell * 0.9,
-              pointerEvents: 'none',
-            }}
-          />
-        ) : null}
+        {/* 四层结构在终端外围合拢成一个壳。常驻渲染：透明度随 shell 自 0 起（替代原布尔门） */}
+        <div
+          style={{
+            position: 'absolute',
+            left: -34 + shell * 12,
+            top: -34 + shell * 12,
+            right: -34 + shell * 12,
+            bottom: -34 + shell * 12,
+            border: `3px solid ${theme.core}`,
+            borderRadius: 22,
+            opacity: shell * 0.9,
+            pointerEvents: 'none',
+          }}
+        />
       </div>
       <Footnote delay={shellAt}>{'一个愿意反复跑、能查表、会拦门、留了插口的壳'}</Footnote>
     </AbsoluteFill>
@@ -488,6 +488,7 @@ export const P5Stack: React.FC<{scene: SceneRange}> = ({scene}) => {
   const bD = w('p5-15', 'p5-19');
   return (
     <AbsoluteFill>
+      <HarnessBadge />
       <Sequence {...bA} name="5-A 四层卡片与官方四件套">
         <FourLayers splitAt={rel(bA, 'p5-06')} mapAt={rel(bA, 'p5-05')} />
       </Sequence>
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P6Ending.tsx b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P6Ending.tsx
index 5b8834817..606cc8402 100644
--- a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P6Ending.tsx
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/scenes/P6Ending.tsx
@@ -1,13 +1,15 @@
 /** P6 收尾（分镜 6-A…6-B）
- *  ★ 渐黑窗口从**末 beat 总时长**推导（beatDurationInFrames），不是末句时长
- *    —— 第三集上线教训：末句短于 beat 时渐黑提前收尾，导致收尾长黑屏
- *    （skills/06 渲染红线四）。 */
+ *  ★ 渐黑窗口从**末 beat 总时长**推导（useFadeOut 模型化——红线四由构造保证）。
+ *  重制（2026-09 运动层）：动效收敛 motion 模型；系列栈收尾（HarnessStackP6）
+ *  落地 skills/06「P6 用法」：栈重新放大居中、已发布层点亮、下期层呼吸预告。 */
 import React from 'react';
-import {AbsoluteFill, interpolate, Sequence, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {AbsoluteFill, Sequence, useCurrentFrame, useVideoConfig} from 'remotion';
 import {theme} from '../design/theme';
 import {beatWindow} from '../timing';
 import type {SceneRange} from '../types';
 import {LoopRing, Panel, useRingDot} from '../components/motifs';
+import {HarnessBadge, HarnessStackP6, NEXT_LAYER} from '../components/harness-stack';
+import {DUR, SAFE_TOP_Y, progress, useFadeOut, useProgress, useSpring, useStagger} from '../motion';
 
 /** 6-A 壳的四层：三张挂件卡沿径向滑入、逐一「咬合」上环（骨架 vs 挂件的物理化收束）。
  *  循环层不用卡——它就是环本身（p6-03 的口播顺序：循环→分发表→闸门→插口）。
@@ -21,10 +23,6 @@ const ShellLayers: React.FC<{layerAt: number[]}> = ({layerAt}) => {
   const RING_R = (R * 2 + 76) / 2 - 46;
   const CX = 560;
   const CY = 540;
-  // 字幕安全带上沿：与 qa_frames.py 的 SUBTITLE_BAND_PX = 160 同口径（比 skills/06
-  // 红线二「角标 bottom ≥ 150」再严 10px，留出体检余量）。入场轨迹必须自己让开它——
-  // **落位态干净、入场越界**这一类缺陷 `--check` 每幕只抽 ~8 帧，结构性看不见。
-  const SAFE_TOP_Y = 1080 - 160;
   const CARD_HALF_H = 36; // 卡片 rect 半高 34 + 描边 2.5 的一半，向上取整
   // 三张挂件卡沿环 120° 均分，且刻意避开 0/±90/180 —— LoopRing 的四个节点文案
   // （问模型/看回答/执行工具/填回结果）就画在那四个方位上，挂脚会横穿它们。
@@ -33,8 +31,18 @@ const ShellLayers: React.FC<{layerAt: number[]}> = ({layerAt}) => {
     {t: '闸门', s: '守着底线', c: theme.deny, ang: 75},
     {t: '插口', s: '留给你发挥', c: theme.mech, ang: 195},
   ];
+  // 三卡径向滑入：时点来自句锚（layerAt[1..3]），单项 12f = DUR.f5。
+  // 显式三个调用而非 map——map 内调 hook 违反 Rules of Hooks（数量须恒定）
+  const lit = [
+    useProgress(layerAt[1], DUR.f5),
+    useProgress(layerAt[2], DUR.f5),
+    useProgress(layerAt[3], DUR.f5),
+  ];
   const allOn = frame >= layerAt[3];
+  // 咬合后的整组轻呼吸：单向半波（只向内收），与 useBreathe 的正弦不同——保留内联
   const breathe = allOn ? 1 - 0.02 * Math.max(0, Math.sin((frame - layerAt[3]) / 9)) : 1;
+  const cycleOp = useProgress(layerAt[0], DUR.f5);
+  const hangOp = useProgress(layerAt[3], DUR.f5);
   return (
     <AbsoluteFill>
       <svg width={1920} height={1080} style={{position: 'absolute', inset: 0}}>
@@ -43,12 +51,8 @@ const ShellLayers: React.FC<{layerAt: number[]}> = ({layerAt}) => {
             <LoopRing size={R * 2 + 76} draw={1} dotProgress={dot} showExit={false} />
           </g>
           {attach.map((a, i) => {
-            const on = frame >= layerAt[i + 1];
-            const t = interpolate(frame - layerAt[i + 1], [0, 16], [0, 1], {
-              extrapolateLeft: 'clamp',
-              extrapolateRight: 'clamp',
-            });
-            if (!on) return null;
+            const t = lit[i];
+            if (t <= 0) return null;
             const rad = (a.ang * Math.PI) / 180;
             // 卡片中心的落位半径：环外一圈（dist > RING_R，卡片整体在环之外——
             // 底部那句「挂件 ×3，都挂在外面」是字面意思，卡片不得压在环线上）
@@ -56,9 +60,9 @@ const ShellLayers: React.FC<{layerAt: number[]}> = ({layerAt}) => {
             // 挂脚长度 = 卡心到环线的径向距离；本组已按 ang 旋转，故 -x 指向环心
             const stem = dist - RING_R;
             // 入场自环外 startPx 倍半径径向滑入。**向下**的卡（sin > 0）滑到最远处时
-            // 会探进字幕安全带（1.6 倍时闸门卡下沿到 y≈1047，被字幕条切掉半张），
-            // 故其起步倍率按「卡片下沿贴住 SAFE_TOP_Y」封顶；向上的两张不受此限，
-            // 仍走完整行程。三张卡入场时刻错开，行程长短不同不构成可比性问题。
+            // 会探进字幕安全带——其起步倍率按「卡片下沿贴住 SAFE_TOP_Y（motion 的
+            // SSOT 常量，与 qa_frames.SUBTITLE_BAND_PX 同口径）」封顶；向上的两张
+            // 不受此限。ISSUE-170 的缺陷类由常量单源化。
             const sinA = Math.sin(rad);
             const startPx = Math.min(
               1.6,
@@ -126,10 +130,7 @@ const ShellLayers: React.FC<{layerAt: number[]}> = ({layerAt}) => {
           position: 'absolute',
           left: 120,
           top: 220,
-          opacity: interpolate(frame - layerAt[0], [0, 12], [0, 1], {
-            extrapolateLeft: 'clamp',
-            extrapolateRight: 'clamp',
-          }),
+          opacity: cycleOp,
         }}
       >
         <div style={{fontFamily: theme.serif, fontSize: 44, fontWeight: 700, color: theme.core}}>
@@ -147,10 +148,7 @@ const ShellLayers: React.FC<{layerAt: number[]}> = ({layerAt}) => {
           fontFamily: theme.sans,
           fontSize: 26,
           color: theme.mech,
-          opacity: interpolate(frame - layerAt[3], [0, 14], [0, 1], {
-            extrapolateLeft: 'clamp',
-            extrapolateRight: 'clamp',
-          }),
+          opacity: hangOp,
         }}
       >
         {'挂件 ×3，都挂在外面'}
@@ -160,33 +158,29 @@ const ShellLayers: React.FC<{layerAt: number[]}> = ({layerAt}) => {
 };
 
 /**
- * 6-B 信源卡 + 系列身份卡 + 渐黑。
- * `beatDurationInFrames` 是**本 beat 的总时长**，渐黑窗口据此反推。
+ * 6-B 信源卡 + 系列身份（栈收尾）+ 渐黑。
+ * `beatDurationInFrames` 是**本 beat 的总时长**，渐黑窗口由 useFadeOut 据此反推。
  */
 const SourceAndFade: React.FC<{beatDurationInFrames: number; seriesAt: number}> = ({
   beatDurationInFrames,
   seriesAt,
 }) => {
-  const frame = useCurrentFrame();
   const {fps} = useVideoConfig();
-  const enter = spring({frame: frame - 4, fps, config: {damping: 200}});
+  const enter = useSpring('settle', {at: 4});
+  // 信源四行 + 诚实行依次浮现（stride 4、单项 f4）
+  const rowsOn = useStagger(4, {at: 8, stride: 4, dur: DUR.f4});
   const rows = [
     ['官方文档', 'code.claude.com/docs · 取数2026年8月'],
     ['工程博客', 'anthropic.com/engineering'],
     ['源码分析', '第三方逆向分析 · 片中逐处标注'],
     ['数字口径', '开源仓库钉版实测 · 行数均为非空非注释口径'],
   ];
-  const seriesT = interpolate(frame - seriesAt, [0, 20], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
-  // 渐黑：末 1.2 秒线性压暗到全黑，窗口从 beat 总时长反推
-  const fadeFrames = Math.round(1.2 * fps);
-  const fadeStart = beatDurationInFrames - fadeFrames;
-  const dark = interpolate(frame, [fadeStart, beatDurationInFrames], [0, 1], {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-  });
+  const seriesT = useProgress(seriesAt, DUR.f6);
+  const honesty = useProgress(8 + rows.length * 4, DUR.f4) * 0.9;
+  // 渐黑：末 1.2s 线性压暗——useFadeOut 从 beat 总时长反推（红线四模型化）
+  const keep = useFadeOut(beatDurationInFrames, {frames: Math.round(1.2 * fps)});
+  const dark = 1 - keep;
+  const stackBreathAt = seriesAt + DUR.f5;
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <div style={{opacity: enter * (1 - seriesT * 0.85), transform: `translateY(${(1 - enter) * 20}px)`}}>
@@ -200,10 +194,7 @@ const SourceAndFade: React.FC<{beatDurationInFrames: number; seriesAt: number}>
               style={{
                 display: 'flex',
                 marginBottom: 10,
-                opacity: interpolate(frame - 8 - i * 4, [0, 10], [0, 1], {
-                  extrapolateLeft: 'clamp',
-                  extrapolateRight: 'clamp',
-                }),
+                opacity: rowsOn[i],
               }}
             >
               <div style={{width: 150, fontFamily: theme.sans, fontSize: 23, color: theme.dim}}>
@@ -221,60 +212,59 @@ const SourceAndFade: React.FC<{beatDurationInFrames: number; seriesAt: number}>
               fontFamily: theme.sans,
               fontSize: 20,
               color: theme.dim,
-              opacity: interpolate(frame - 8 - rows.length * 4, [0, 10], [0, 0.9], {
-                extrapolateLeft: 'clamp',
-                extrapolateRight: 'clamp',
-              }),
+              opacity: honesty,
             }}
           >
             {'画面中的行数均为本片在固定提交上的实测（非空非注释口径）'}
           </div>
         </Panel>
       </div>
-      {seriesT > 0 ? (
+      <div
+        style={{
+          position: 'absolute',
+          textAlign: 'center',
+          opacity: seriesT,
+          transform: `translateY(${(1 - seriesT) * 18}px)`,
+        }}
+      >
+        {/* 系列栈收尾（skills/06 P6 用法）：已发布层点亮、下期层呼吸预告 */}
+        <div style={{display: 'flex', justifyContent: 'center', marginBottom: 26}}>
+          <HarnessStackP6 at={seriesAt + 4} nextBreathAt={stackBreathAt} />
+        </div>
+        <div style={{fontFamily: theme.serif, fontSize: 34, color: theme.dim, letterSpacing: 3}}>
+          {'Claude Code Harness Engineering'}
+        </div>
         <div
           style={{
-            position: 'absolute',
-            textAlign: 'center',
-            opacity: seriesT,
-            transform: `translateY(${(1 - seriesT) * 18}px)`,
+            fontFamily: theme.serif,
+            fontSize: 62,
+            fontWeight: 700,
+            color: theme.core,
+            marginTop: 18,
           }}
         >
-          <div style={{fontFamily: theme.serif, fontSize: 34, color: theme.dim, letterSpacing: 3}}>
-            {'Claude Code Harness Engineering'}
-          </div>
-          <div
-            style={{
-              fontFamily: theme.serif,
-              fontSize: 62,
-              fontWeight: 700,
-              color: theme.core,
-              marginTop: 18,
-            }}
-          >
-            {'执行层：一个循环，就是全部'}
+          {'执行层：一个循环，就是全部'}
+        </div>
+        {/* 下期预告卡：标题只在画面（口播为话题描述——反串线纪律）。
+            标题主段是 series.json 派生数据的硬编码镜像，由 check_series 规则 8
+            与清单对账（改标题先改 series.json，再同步此串——规则会拦漂移）。 */}
+        <div
+          style={{
+            marginTop: 30,
+            padding: '14px 30px',
+            border: `1.5px solid ${theme.panelBorder}`,
+            borderRadius: 12,
+            background: theme.panel,
+          }}
+        >
+          <div style={{fontFamily: theme.sans, fontSize: 21, color: theme.dim, letterSpacing: 2}}>
+            {`下期 · ${NEXT_LAYER?.layer ?? ''}`}
           </div>
-          {/* 下期预告卡：标题只在画面（口播为话题描述——反串线纪律）。
-              标题为 series.json 派生数据的硬编码镜像，由 check_series 规则 8
-              与清单对账（改标题先改 series.json，再同步此串——规则会拦漂移）。 */}
-          <div
-            style={{
-              marginTop: 30,
-              padding: '14px 30px',
-              border: `1.5px solid ${theme.panelBorder}`,
-              borderRadius: 12,
-              background: theme.panel,
-            }}
-          >
-            <div style={{fontFamily: theme.sans, fontSize: 21, color: theme.dim, letterSpacing: 2}}>
-              {'下期 · 规划层'}
-            </div>
-            <div style={{fontFamily: theme.serif, fontSize: 33, color: theme.text, marginTop: 6}}>
-              {'模型的视野是安排出来的'}
-            </div>
+          <div style={{fontFamily: theme.serif, fontSize: 33, color: theme.text, marginTop: 6}}>
+            {'模型的视野是安排出来的'}
           </div>
         </div>
-      ) : null}
+      </div>
       {/* 渐黑遮罩 */}
       <AbsoluteFill style={{background: '#000', opacity: dark, pointerEvents: 'none'}} />
     </AbsoluteFill>
@@ -286,6 +276,11 @@ export const P6Ending: React.FC<{scene: SceneRange}> = ({scene}) => {
   const rel = (b: {from: number}, id: string) => w(id).from - b.from;
   const bA = w('p6-01', 'p6-04');
   const bB = w('p6-05', 'p6-08');
+  const frame = useCurrentFrame();
+  // 常驻角标在 6-A 全程；6-B（= bB.from 起）信源/收尾卡占满视野，角标淡出避免拥挤。
+  // 非 beat 用途不得写 w('句id') 字面形态——check_script 的 SCENE_CALL_RE 会把它当
+  // beat 区间登记面（用 bB.from 取同一锚点）
+  const badgeFade = progress(frame - bB.from, 0, DUR.f5);
   return (
     <AbsoluteFill>
       <Sequence {...bA} name="6-A 壳的四层">
@@ -300,6 +295,11 @@ export const P6Ending: React.FC<{scene: SceneRange}> = ({scene}) => {
           seriesAt={rel(bB, 'p6-08')}
         />
       </Sequence>
+      {frame < bB.from + DUR.f5 ? (
+        <div style={{opacity: 1 - badgeFade}}>
+          <HarnessBadge />
+        </div>
+      ) : null}
     </AbsoluteFill>
   );
 };
diff --git a/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/series-layers.json b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/series-layers.json
new file mode 100644
index 000000000..e8c5d4011
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-explained-video/video/src/series-layers.json
@@ -0,0 +1,37 @@
+{
+ "seriesId": "claude-code-explained",
+ "layers": [
+  {
+   "index": 1,
+   "layer": "执行层",
+   "title": "执行层：一个循环，就是全部",
+   "published": false
+  },
+  {
+   "index": 2,
+   "layer": "规划层",
+   "title": "规划层：模型的视野是安排出来的",
+   "published": false
+  },
+  {
+   "index": 3,
+   "layer": "记忆层",
+   "title": "记忆层：会丢的和不能丢的",
+   "published": false
+  },
+  {
+   "index": 4,
+   "layer": "时机层",
+   "title": "时机层：谁来按下开始",
+   "published": false
+  },
+  {
+   "index": 5,
+   "layer": "协作层",
+   "title": "协作层：从一个到一群",
+   "published": false
+  }
+ ],
+ "activeIndex": 1,
+ "next": "规划层：模型的视野是安排出来的"
+}
diff --git a/apps/negentropy-influence/episodes/claude-code-memory-video/video/package.json b/apps/negentropy-influence/episodes/claude-code-memory-video/video/package.json
index 94896ee1c..35d1c2641 100644
--- a/apps/negentropy-influence/episodes/claude-code-memory-video/video/package.json
+++ b/apps/negentropy-influence/episodes/claude-code-memory-video/video/package.json
@@ -19,10 +19,5 @@
   "devDependencies": {
     "@types/react": "^19.0.0",
     "typescript": "^5.6.0"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild"
-    ]
   }
 }
diff --git a/apps/negentropy-influence/episodes/claude-code-memory-video/video/pnpm-workspace.yaml b/apps/negentropy-influence/episodes/claude-code-memory-video/video/pnpm-workspace.yaml
index f2686ac7d..add822dbe 100644
--- a/apps/negentropy-influence/episodes/claude-code-memory-video/video/pnpm-workspace.yaml
+++ b/apps/negentropy-influence/episodes/claude-code-memory-video/video/pnpm-workspace.yaml
@@ -1,4 +1,9 @@
-# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的唯一理由。
+# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的首要理由。
 # pnpm 12 起仅靠 `--ignore-workspace` 不够：pnpm 仍会沿 packageManager 向上锚定到仓库根，
 # 用本工程的解析结果覆写根 pnpm-lock.yaml（overrides 全丢）且当场不报错。见 ISSUE-175。
 packages: []
+# pnpm 12 的构建脚本许可（package.json 的 pnpm.onlyBuiltDependencies 已不被读取，
+# 静默忽略会使安装以 ERR_PNPM_IGNORED_BUILDS 中断、node_modules 半残）。键名与取值
+# 与 `pnpm approve-builds esbuild --yes` 实际写入的形态逐字一致——勿改回旧键名。
+allowBuilds:
+  esbuild: true
diff --git a/apps/negentropy-influence/episodes/claude-code-memory-video/video/scripts/motion.test.ts b/apps/negentropy-influence/episodes/claude-code-memory-video/video/scripts/motion.test.ts
new file mode 100644
index 000000000..5e29cab52
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-memory-video/video/scripts/motion.test.ts
@@ -0,0 +1,141 @@
+/**
+ * 运动层纯函数单测——`node --test scripts/motion.test.ts`（Node ≥ 23.6 原生跑 TS）。
+ *
+ * 刻意放在 video/ 而非 src/：tsconfig include 只有 src（frozen，不为测试改动），
+ * 而本文件 import 需带 .ts 后缀（Node ESM 解析规则）——tsc 若收编会因
+ * allowImportingTsExtensions 未开而报错。src/ 的类型覆盖由 tsc --noEmit 全量保证，
+ * 本文件只测纯函数行为，不做类型承重。
+ *
+ * 只 import 纯模块（tokens/window/schedule——零 remotion/react 依赖）：
+ * hooks 是它们的薄包装，行为由 MotionGallery 目视 + 场景抽帧覆盖。
+ */
+import {strict as assert} from 'node:assert';
+import test from 'node:test';
+
+import {DUR, EASING_CP, EXIT_FACTOR, SAFE_TOP_Y, SPRING, clampRiseDist, dampingRatio, overshootPeak} from '../src/motion/tokens.ts';
+import {beatProgress, clamp01, progress, revealCharCount, win} from '../src/motion/window.ts';
+import {schedule} from '../src/motion/schedule.ts';
+
+// ── tokens ────────────────────────────────────────────────────────────
+
+test('时长标尺在 30fps 下相邻档可辨（≥1 帧差）', () => {
+  const v = Object.values(DUR) as number[];
+  for (let i = 1; i < v.length; i++) {
+    assert.ok(v[i] - v[i - 1] >= 1, `第 ${i} 档与前一档同帧数（伪选择）`);
+  }
+  assert.ok(v.length === 6);
+});
+
+test('ζ→过冲换算钉死：snap 轻过冲、settle 零过冲（直抄 dampingRatio 的反例护栏）', () => {
+  const zSnap = dampingRatio(SPRING.snap);
+  const zSettle = dampingRatio(SPRING.settle);
+  assert.ok(zSnap > 0.4 && zSnap < 0.9, `snap ζ=${zSnap}`);
+  // Mp = exp(-πζ/√(1-ζ²)) 是超出幅度；峰值 = 1 + Mp（ζ=0.6 → 峰值 ≈1.095）
+  assert.ok(overshootPeak(zSnap) > 1.02 && overshootPeak(zSnap) < 1.2, `snap 峰值 ${overshootPeak(zSnap)}`);
+  assert.ok(zSettle > 1, 'settle 须过阻尼');
+  assert.equal(overshootPeak(zSettle), 1);
+  // 反例：把设计系统的 ζ 当 damping 直填（0.8）→ ζ≈0.04、峰值≈1.88 暴力弹跳
+  const wrong = dampingRatio({damping: 0.8, stiffness: 100, mass: 1});
+  assert.ok(overshootPeak(wrong) > 1.8, `直抄 ζ 的峰值=${overshootPeak(wrong)}，必须被此断言抓住`);
+});
+
+test('缓动控制点合法（CSS 规则 x∈[0,1]，且 x(t) 数值单调——可作函数求值）', () => {
+  for (const cp of Object.values(EASING_CP)) {
+    const [x1, , x2] = cp;
+    assert.ok(x1 >= 0 && x1 <= 1 && x2 >= 0 && x2 <= 1, `x 越界：${cp}`);
+    // x1<x2 是充分不必要（M3 standard (0.2,0,0,1) 的 x2<x1 仍单调）——判据用导数采样
+    for (let i = 0; i <= 50; i++) {
+      const t = i / 50;
+      const dx =
+        3 * (1 - t) ** 2 * x1 + 6 * (1 - t) * t * (x2 - x1) + 3 * t * t * (1 - x2);
+      assert.ok(dx > -1e-9, `x(t) 非单调 @t=${t}：${cp}`);
+    }
+  }
+});
+
+test('出场快于入场系数与安全带口径为常量', () => {
+  assert.equal(EXIT_FACTOR, 0.4);
+  assert.equal(SAFE_TOP_Y, 920);
+});
+
+test('clampRiseDist：自下方入场行程不探进字幕安全带', () => {
+  assert.equal(clampRiseDist(120, 836), 84, 'ISSUE-170 实测几何：rest 836 → 行程封顶 84');
+  assert.equal(clampRiseDist(40, 836), 40, '未超限不动');
+  assert.equal(clampRiseDist(120, 960), 0, '落位已在安全带内 → 零行程（退化但安全）');
+});
+
+// ── window ────────────────────────────────────────────────────────────
+
+test('clamp01 / progress / win 的钳制语义', () => {
+  assert.equal(clamp01(-1), 0);
+  assert.equal(clamp01(2), 1);
+  assert.equal(progress(10, 10, 10), 0, '起点为 0');
+  assert.equal(progress(20, 10, 10), 1, '终点为 1');
+  assert.equal(progress(5, 10, 10), 0, '窗外前钳 0');
+  assert.equal(progress(99, 10, 10), 1, '窗外后钳 1');
+  assert.equal(win(0.5, [0.25, 0.75]), 0.5);
+  assert.equal(win(0.1, [0.25, 0.75]), 0);
+  assert.equal(win(0.9, [0.25, 0.75]), 1);
+  assert.equal(beatProgress(0, -30, 90), 1 / 3);
+});
+
+test('逐字揭示：cps 按实际 fps 换算并向下取整，framesPerChar 保持固定帧间隔', () => {
+  assert.equal(revealCharCount(29, 60, 12), 5);
+  assert.equal(revealCharCount(30, 60, 12), 6);
+  assert.equal(revealCharCount(30, 24, 12, 3), 10);
+  assert.equal(revealCharCount(30, 120, 12, 3), 10);
+});
+
+// ── schedule ──────────────────────────────────────────────────────────
+
+test('fit 模式：末项恰在窗口末完成、不外溢', () => {
+  const p = schedule(5, {dur: 10, fit: {total: 90}});
+  const last = p.starts[4] + p.dur;
+  assert.ok(last <= 90 + 1, `末项 ${last} 外溢`);
+  assert.ok(last >= 89, `末项 ${last} 未到窗口末`);
+});
+
+test('fit 装不下时缩子项时长，不外溢窗口（优先级：不外溢 > 最小步长 > 子项时长）', () => {
+  // total 30 时 (30-12)/7≈2.57 ≥ minStride=2 仍装得下；压到 24 才触发缩时长
+  const p = schedule(8, {dur: 12, fit: {total: 24}});
+  const last = p.starts[7] + p.dur;
+  assert.ok(last <= 24, `末项 ${last} 外溢`);
+  assert.ok(p.dur >= 3, '子项时长跌破下限');
+  assert.ok(p.dur < 12, '装不下却未缩子项时长');
+});
+
+test('fit 窗口连 1 帧子项也容不下时显式拒绝，不返回外溢计划', () => {
+  assert.throws(() => schedule(8, {dur: 12, fit: {total: 5}}), /fit\.total=5.*8/);
+});
+
+test('fit 可行极限先牺牲子项时长，仍完整落在窗口内', () => {
+  const p = schedule(8, {dur: 12, fit: {total: 8}});
+  assert.equal(p.dur, 1);
+  assert.equal(p.starts[7] + p.dur, 8);
+});
+
+test('lag 模式：Manim 语义 start[i] = i·dur·lag', () => {
+  const p = schedule(3, {dur: 10, lag: 0.5});
+  assert.deepEqual(p.starts, [0, 5, 10]);
+  assert.deepEqual(schedule(3, {dur: 10, lag: 0}).starts, [0, 0, 0], 'lag=0 须同刻齐动');
+});
+
+test('stride 模式与三选一守卫', () => {
+  assert.deepEqual(schedule(3, {dur: 5, stride: 4}).starts, [0, 4, 8]);
+  assert.throws(() => schedule(3, {dur: 5, stride: 4, lag: 1}));
+  assert.throws(() => schedule(3, {dur: 5, lag: 1, fit: {total: 40}}));
+});
+
+test('最小步长与空集', () => {
+  assert.deepEqual(schedule(0, {dur: 5, stride: 4}), {starts: [], dur: 5});
+  const p = schedule(2, {dur: 5, stride: 0}); // 非法步长 → 抬到下限
+  assert.ok(p.starts[1] - p.starts[0] >= 1);
+});
+
+test('起点取整且单调不减', () => {
+  const p = schedule(6, {dur: 7, fit: {total: 53}});
+  for (let i = 1; i < p.starts.length; i++) {
+    assert.ok(p.starts[i] >= p.starts[i - 1], '起点须单调不减');
+    assert.ok(Number.isInteger(p.starts[i]));
+  }
+});
diff --git a/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/gallery.tsx b/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/gallery.tsx
new file mode 100644
index 000000000..a71737133
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/gallery.tsx
@@ -0,0 +1,265 @@
+/** MotionGallery——运动层的评审面（独立 Remotion 入口，不经 Root.tsx）。
+ *
+ * 用法（在 video/ 目录，.bin 直调防污染根 workspace）：
+ *   ./node_modules/.bin/remotion still src/motion/gallery.tsx MotionGallery \
+ *       out/motion-gallery.png --frame=30
+ *
+ * 全部模型 × 变体一屏可渲：秒级出图，供 token 校准轮逐格目视。
+ * 色板为本文件内字面量（dev 工具面，不进成片、不读 theme——保持 frozen 跨系列共享）。
+ */
+import React from 'react';
+import {AbsoluteFill, Composition, registerRoot} from 'remotion';
+import {
+  useAccelTravel,
+  useBreathe,
+  useCount,
+  useDim,
+  useDraw,
+  useEnter,
+  useFadeOut,
+  useFlowDash,
+  useImpulse,
+  usePushIn,
+  useReveal,
+  useShake,
+  useStagger,
+  useTravel,
+} from './hooks';
+
+const COLS = 5;
+const CW = 340;
+const CH = 230;
+const GAP = 18;
+
+/** dev 工具面字面量色板（与各集 theme 底座同值但刻意独立声明——不读 theme）。 */
+const C = {
+  bg: '#0E1116',
+  panel: '#171C26',
+  border: '#2A3242',
+  text: '#F2F5FA',
+  dim: '#9AA7B8',
+  core: '#D97757',
+  mech: '#64C4C0',
+  deny: '#EF6461',
+};
+
+/** 单元格壳：定位 + 角标。 */
+const Cell: React.FC<{i: number; name: string; children: React.ReactNode}> = ({i, name, children}) => (
+  <div
+    style={{
+      position: 'absolute',
+      left: 72 + (i % COLS) * (CW + GAP),
+      top: 96 + Math.floor(i / COLS) * (CH + GAP),
+      width: CW,
+      height: CH,
+      background: C.panel,
+      border: `2px solid ${C.border}`,
+      borderRadius: 12,
+    }}
+  >
+    <div
+      style={{
+        position: 'absolute',
+        inset: '28px 0 34px 0',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+      }}
+    >
+      {children}
+    </div>
+    <div style={{position: 'absolute', left: 12, bottom: 8, fontFamily: 'monospace', fontSize: 15, color: C.dim}}>
+      {name}
+    </div>
+  </div>
+);
+
+const Box: React.FC<{color?: string; w?: number; h?: number; style?: React.CSSProperties}> = ({
+  color = C.core,
+  w = 200,
+  h = 80,
+  style,
+}) => <div style={{width: w, height: h, background: C.panel, border: `2px solid ${color}`, borderRadius: 10, ...style}} />;
+
+// ── 每格一个组件：hooks 各归其位（Rules of Hooks 的最简守法形态） ────────
+
+const EnterCell: React.FC<{kind: Parameters<typeof useEnter>[0]}> = ({kind}) => {
+  const e = useEnter(kind, {});
+  return <Box style={{opacity: e.opacity, transform: e.transform}} />;
+};
+
+const StaggerCell: React.FC = () => {
+  const ps = useStagger(5, {dur: 5, fit: {total: 60}});
+  return (
+    <div style={{display: 'flex', gap: 10}}>
+      {ps.map((p, i) => (
+        <div
+          key={i}
+          style={{
+            width: 34,
+            height: 80,
+            background: C.panel,
+            border: `2px solid ${C.mech}`,
+            borderRadius: 8,
+            opacity: p,
+            transform: `translateY(${(1 - p) * 14}px)`,
+          }}
+        />
+      ))}
+    </div>
+  );
+};
+
+const DrawCell: React.FC = () => {
+  const d = useDraw(0, 24);
+  return (
+    <svg width={280} height={110}>
+      <path {...d} d="M10 90 C 90 10, 190 100, 270 20" stroke={C.core} strokeWidth={5} fill="none" strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ImpulseCell: React.FC = () => {
+  const g = useImpulse({dur: 30, peak: 1});
+  return (
+    <div
+      style={{
+        width: 90,
+        height: 90,
+        borderRadius: '50%',
+        background: C.core,
+        opacity: 0.3 + 0.7 * g,
+        boxShadow: `0 0 ${10 + 30 * g}px ${C.core}`,
+      }}
+    />
+  );
+};
+
+const BreatheCell: React.FC = () => {
+  const b = useBreathe({period: 30});
+  return (
+    <svg width={160} height={110}>
+      <circle cx={80} cy={55} r={40} fill="none" stroke={C.mech} strokeWidth={5} opacity={b} />
+    </svg>
+  );
+};
+
+const TravelCell: React.FC = () => {
+  const t = useTravel({cx: 140, cy: 55, r: 42, secPerLap: 3});
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} />
+      <circle cx={t.x} cy={t.y} r={9} fill={C.core} />
+    </svg>
+  );
+};
+
+const AccelCell: React.FC = () => {
+  const t = useAccelTravel({cx: 140, cy: 55, r: 42, durs: [28, 20, 14], at: 4});
+  const heat = `rgb(${217 + Math.round(38 * t.heat)}, ${119 - Math.round(60 * t.heat)}, ${87 - Math.round(20 * t.heat)})`;
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} strokeDasharray="4 6" />
+      <circle cx={t.x} cy={t.y} r={9} fill={heat} />
+    </svg>
+  );
+};
+
+const CountCell: React.FC = () => {
+  const v = useCount({to: 255, dur: 40});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 44, color: C.text, fontVariantNumeric: 'tabular-nums'}}>
+      {Math.round(v)}
+    </div>
+  );
+};
+
+const RevealCell: React.FC = () => {
+  const s = useReveal('while (true) { think(); act(); }', {cps: 14});
+  const blink = useBreathe({period: 16, amp: 0.5, base: 0.5});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 20, color: C.text, whiteSpace: 'nowrap'}}>
+      {s}
+      <span style={{opacity: blink}}>▍</span>
+    </div>
+  );
+};
+
+const PushInCell: React.FC = () => {
+  const t = usePushIn(0, {scale: 0.12});
+  return <Box w={160} h={90} color={C.mech} style={{transform: t}} />;
+};
+
+const DimCell: React.FC = () => {
+  const dim = useDim({at: 40, to: 0.35});
+  return (
+    <div style={{display: 'flex', gap: 12}}>
+      <Box w={64} h={80} style={{opacity: dim}} />
+      <Box w={64} h={80} color={C.core} />
+      <Box w={64} h={80} style={{opacity: dim}} />
+    </div>
+  );
+};
+
+const FlowCell: React.FC = () => {
+  const f = useFlowDash({period: 24});
+  return (
+    <svg width={280} height={60}>
+      <line x1={10} y1={30} x2={270} y2={30} stroke={C.mech} strokeWidth={5} {...f} strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ShakeCell: React.FC = () => {
+  const x = useShake({at: 10, amp: 5, decay: true, dur: 40});
+  return <Box w={150} h={80} color={C.deny} style={{transform: `translateX(${x}px)`}} />;
+};
+
+const FadeCell: React.FC = () => {
+  const op = useFadeOut(90, {frames: 36});
+  return (
+    <div style={{position: 'relative', width: 220, height: 90}}>
+      <Box w={220} h={90} color={C.core} style={{position: 'absolute', inset: 0}} />
+      <div style={{position: 'absolute', inset: 0, background: '#000', opacity: 1 - op}} />
+    </div>
+  );
+};
+
+const CELLS: Array<[string, React.ReactNode]> = [
+  ['enter:fall', <EnterCell kind="fall" />],
+  ['enter:rise', <EnterCell kind="rise" />],
+  ['enter:slideL', <EnterCell kind="slideL" />],
+  ['enter:pop', <EnterCell kind="pop" />],
+  ['enter:flyIn', <EnterCell kind="flyIn" />],
+  ['enter:fade', <EnterCell kind="fade" />],
+  ['stagger×5 fit60', <StaggerCell />],
+  ['draw 24f', <DrawCell />],
+  ['impulse 30f', <ImpulseCell />],
+  ['breathe p30', <BreatheCell />],
+  ['travel 3s/lap', <TravelCell />],
+  ['accelTravel', <AccelCell />],
+  ['count→255', <CountCell />],
+  ['reveal 14cps', <RevealCell />],
+  ['pushIn .12', <PushInCell />],
+  ['dim .35@40', <DimCell />],
+  ['flowDash p24', <FlowCell />],
+  ['shake decay', <ShakeCell />],
+  ['fadeOut 36f', <FadeCell />],
+];
+
+const MotionGallery: React.FC = () => (
+  <AbsoluteFill style={{background: C.bg}}>
+    <div style={{position: 'absolute', left: 72, top: 44, fontFamily: 'monospace', fontSize: 24, color: C.text}}>
+      MotionGallery · 30fps · 120f
+    </div>
+    {CELLS.map(([name, node], i) => (
+      <Cell key={name} i={i} name={name}>
+        {node}
+      </Cell>
+    ))}
+  </AbsoluteFill>
+);
+
+registerRoot(() => (
+  <Composition id="MotionGallery" component={MotionGallery} width={1920} height={1080} fps={30} durationInFrames={120} defaultProps={{}} />
+));
diff --git a/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/hooks.ts b/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/hooks.ts
new file mode 100644
index 000000000..f87b8a129
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/hooks.ts
@@ -0,0 +1,303 @@
+/** 运动模型（hooks）——分镜「动效」列动词到帧数学的唯一映射。
+ *
+ * 设计约束（违反任何一条即失去本层存在意义）：
+ * 1. hooks 返回数值 / CSS 片段，不渲染 DOM——FadeUp 式包装组件打不进 svg/<g>/
+ *    absolute 布局，是「组件存在却零调用」的实测根因；数值可落进任意 JSX。
+ * 2. 弹簧一律吃局部帧（frame - at）：spring() 每次调用从第 0 帧重模拟，喂全局帧
+ *    会让长片末帧每个 spring 跑两万余次迭代。
+ * 3. effects（不透明度/颜色）永不吃弹簧——一律时长+缓动（tokens 的二分不变量）。
+ * 4. 不读 theme：颜色一律经参数传入（frozen 跨系列共享的前提）。
+ * 5. `at` 锚点一律来自句边界（rel(beat, '句id')），禁写死帧数。
+ */
+import {Easing, interpolate, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {
+  DUR,
+  EASING_CP,
+  SPRING,
+  clampRiseDist,
+  type DurToken,
+  type EasingToken,
+  type SpringPreset,
+} from './tokens';
+import {progress, revealCharCount} from './window';
+import {schedule, type ScheduleOpts} from './schedule';
+
+/** 帧数解析：token 或直接帧数；缺省用 def。 */
+export const frames = (d: number | DurToken | undefined, def: number): number =>
+  d === undefined ? def : typeof d === 'number' ? d : DUR[d];
+
+/** 缓动令牌 → Remotion 缓动函数（linear 直通）。 */
+export const easeF = (t: EasingToken): ((x: number) => number) =>
+  t === 'linear'
+    ? Easing.linear
+    : Easing.bezier(
+        ...(EASING_CP[t] as [number, number, number, number]),
+      );
+
+/** 缓动后的 0..1 进度（各模型共用的原子）。 */
+const eased = (
+  frame: number,
+  at: number,
+  dur: number,
+  e: EasingToken,
+): number => interpolate(progress(frame, at, dur), [0, 1], [0, 1], {easing: easeF(e)});
+
+/** 缓动数值进度——「clamped 0→1 手写 interpolate」惯用形的统一替身：
+ *  时机值走 token，缓动默认 standard（线性原版会被这一档替换——质量提升点之一）。 */
+export function useProgress(
+  at: number,
+  dur: number | DurToken = DUR.f5,
+  easing: EasingToken = 'standard',
+): number {
+  const frame = useCurrentFrame();
+  return eased(frame, at, frames(dur, DUR.f5), easing);
+}
+
+/** 弹簧数值进度（驱动几何量/位移；effects 通道用 useProgress——tokens 二分不变量）。
+ *  局部帧 + 可选 durationInFrames 截停（防窗口外余振；缺省不设上限，与既有手写等价）。 */
+export function useSpring(
+  preset: SpringPreset,
+  o: {at?: number; dur?: number | DurToken} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const cfg: Parameters<typeof spring>[0] = {
+    frame: frame - (o.at ?? 0),
+    fps,
+    config: SPRING[preset],
+  };
+  if (o.dur !== undefined) {
+    cfg.durationInFrames = frames(o.dur, DUR.f5);
+  }
+  return spring(cfg);
+}
+
+// ── 入场（enter：落下/上浮/滑入/弹出/飞入/淡入） ────────────────────────
+
+export type EnterKind = 'fall' | 'rise' | 'slideL' | 'slideR' | 'pop' | 'flyIn' | 'fade';
+export type EnterOpts = {
+  /** 句边界锚（局部帧）。 */
+  at?: number;
+  dur?: number | DurToken;
+  easing?: EasingToken;
+  /** 空间通道用弹簧（位移类才有意义；fade/pop 无效）。 */
+  springPreset?: SpringPreset;
+  /** 位移像素（fall/rise/slide*；缺省 30）。 */
+  dist?: number;
+  /** rise 专用：落位态底边 y——行程经 clampRiseDist 钳进字幕安全带之上。 */
+  restBottom?: number;
+};
+export type EnterStyle = {opacity: number; transform: string};
+
+export function useEnter(kind: EnterKind, o: EnterOpts = {}): EnterStyle {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const at = o.at ?? 0;
+  const dur = frames(o.dur, DUR.f4);
+  let dist = o.dist ?? 30;
+  if (kind === 'rise' && o.restBottom !== undefined) {
+    dist = clampRiseDist(dist, o.restBottom);
+  }
+  // effects 通道：纯缓动、略快于空间通道（元素先「看见」再「落位」）
+  const opacity = progress(frame, at, Math.max(2, Math.round(dur * 0.8)));
+  // spatial 通道：可选弹簧（局部帧 + durationInFrames 截停，防窗口外余振）
+  const p = o.springPreset
+    ? spring({
+        frame: frame - at,
+        fps,
+        config: SPRING[o.springPreset],
+        durationInFrames: dur,
+      })
+    : eased(frame, at, dur, o.easing ?? 'standard');
+  const inv = 1 - p;
+  const t: string[] = [];
+  if (kind === 'fall') t.push(`translateY(${-inv * dist}px)`);
+  if (kind === 'rise') t.push(`translateY(${inv * dist}px)`);
+  if (kind === 'slideL') t.push(`translateX(${-inv * dist}px)`);
+  if (kind === 'slideR') t.push(`translateX(${inv * dist}px)`);
+  if (kind === 'pop') t.push(`scale(${0.9 + 0.1 * p})`);
+  if (kind === 'flyIn') t.push(`scale(${0.6 + 0.4 * p})`);
+  return {opacity, transform: t.length ? t.join(' ') : 'none'};
+}
+
+// ── 序列错峰（stagger：依次/逐行/逐条/逐格） ───────────────────────────
+
+export type StaggerOpts = ScheduleOpts & {at?: number; easing?: EasingToken};
+
+/** 返回 n 个 0..1 进度——第 i 项随编排依次入场。 */
+export function useStagger(n: number, o: StaggerOpts = {}): number[] {
+  const frame = useCurrentFrame();
+  const {at = 0, easing = 'standard'} = o;
+  const plan = schedule(n, o);
+  return plan.starts.map((s) => eased(frame, at + s, plan.dur, easing));
+}
+
+// ── 描线（draw：红线三由构造保证——只产 pathLength 归一化三元组） ────────
+
+export type DrawProps = {pathLength: 1; strokeDasharray: 1; strokeDashoffset: number};
+
+export function useDraw(at: number, dur: number | DurToken = DUR.f5): DrawProps {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(dur, DUR.f5), 'decelerate');
+  return {pathLength: 1, strokeDasharray: 1, strokeDashoffset: 1 - p};
+}
+
+// ── 脉冲 / 呼吸（glow 语法：impulse=一次性强调，breathe=持续辉光） ───────
+
+/** 一次性冲击：sin(πp) 包络，起于 0 归于 0，峰值 peak。 */
+export function useImpulse(o: {at?: number; dur?: number | DurToken; peak?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const p = progress(frame, o.at ?? 0, frames(o.dur, DUR.f5));
+  return Math.sin(Math.PI * p) * (o.peak ?? 1);
+}
+
+/** 持续呼吸（原 0.55+0.45·sin(frame/K) 散写的收敛；period 帧一周期——注意与
+ *  原除数 K 的换算 period = 2πK，如 sin(frame/26) → period 163）。offset 为相位
+ *  平移（错峰辉光的 per-index 形态）。 */
+export function useBreathe(
+  o: {period?: number; amp?: number; base?: number; offset?: number} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {amp = 0.45, base = 0.55, period = 26, offset = 0} = o;
+  return base + amp * Math.sin((2 * Math.PI * (frame - offset)) / period);
+}
+
+// ── 巡游（travel：环形为主；absorb 原 useRingDot 与加速绕行累加器克隆） ──
+
+export type TravelPos = {x: number; y: number; angle: number};
+
+/** 匀速环形巡游（angle 单位度，-90 = 12 点方向起）。 */
+export function useTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  secPerLap?: number;
+  offset?: number;
+}): TravelPos {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const lap = (frame / (fps * (o.secPerLap ?? 2.5)) + (o.offset ?? 0)) % 1;
+  const a = -90 + lap * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), angle: a};
+}
+
+/** 加速绕行：逐圈时长 durs[]（如 [40,30,22,16]），跑完全部圈后冻结在终点。
+ *  heat 0..1 随圈数推进（「失控感」的配色偏移系数）。 */
+export function useAccelTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  durs: number[];
+  at?: number;
+  heatPerLap?: number;
+}): {x: number; y: number; heat: number} {
+  const frame = useCurrentFrame();
+  let t = Math.max(0, frame - (o.at ?? 0));
+  let lap = 0;
+  while (lap < o.durs.length && t >= o.durs[lap]) {
+    t -= o.durs[lap];
+    lap += 1;
+  }
+  const within = lap >= o.durs.length ? 1 : t / o.durs[lap];
+  const heat = Math.min(1, lap / (o.heatPerLap ?? o.durs.length));
+  const a = -90 + within * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), heat};
+}
+
+// ── 计数 / 水位（meter 语法；显示层自行 Math.round / toFixed） ──────────
+
+export function useCount(o: {
+  from?: number;
+  to: number;
+  at?: number;
+  dur?: number | DurToken;
+  ease?: EasingToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {from = 0, to, at = 0} = o;
+  const p = eased(frame, at, frames(o.dur, DUR.f6), o.ease ?? 'standard');
+  return from + (to - from) * p;
+}
+
+// ── 打字机 / 逐字流出（type；Terminal 之外的泛化） ──────────────────────
+
+export function useReveal(
+  text: string,
+  o: {at?: number; cps?: number; framesPerChar?: number} = {},
+): string {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const elapsed = Math.max(0, frame - (o.at ?? 0));
+  const n = revealCharCount(elapsed, fps, o.cps ?? 12, o.framesPerChar);
+  return text.slice(0, Math.min(text.length, n));
+}
+
+// ── 镜头推近（pushIn 语法：beat 切换的镜头语言，替代纯淡入） ────────────
+
+export function usePushIn(at: number, o: {scale?: number; dur?: number | DurToken} = {}): string {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(o.dur, DUR.f5), 'decelerate');
+  return `scale(${1 + (o.scale ?? 0.06) * p})`;
+}
+
+// ── 压暗 / 提亮（emphasis 反向：让主体从群像中浮出） ─────────────────────
+
+/** 返回目标透明度系数（1 = 原；to 0.4 即压暗到 40%）。 */
+export function useDim(o: {at: number; to?: number; dur?: number | DurToken}): number {
+  const frame = useCurrentFrame();
+  const p = eased(frame, o.at, frames(o.dur, DUR.f4), 'standard');
+  return 1 + ((o.to ?? 0.4) - 1) * p;
+}
+
+// ── 流光（flow 语法：连线上的行进虚线） ─────────────────────────────────
+
+/** 返回可直接展开到 <line>/<path> 的描边属性（像素 dasharray——与 draw 的
+ *  pathLength 归一化描线是两个正交特性，勿混用于同一元素：红线三）。 */
+export function useFlowDash(o: {
+  dash?: number;
+  gap?: number;
+  /** 帧速率：每 period 帧行进一个 dash+gap 周期。 */
+  period?: number;
+}): {strokeDasharray: string; strokeDashoffset: number} {
+  const frame = useCurrentFrame();
+  const {dash = 10, gap = 14, period = 40} = o;
+  return {
+    strokeDasharray: `${dash} ${gap}`,
+    strokeDashoffset: -(frame * (dash + gap)) / period,
+  };
+}
+
+// ── 抖动（错误/故障语义；收敛 P2/P3 两处克隆） ──────────────────────────
+
+/** 返回 translateX 像素值。active 缺省 true；decay=true 时按 dur 衰减归零。 */
+export function useShake(o: {
+  at: number;
+  active?: boolean;
+  amp?: number;
+  /** 相位分母（原手写 /1.6、/2.2 的口径）。 */
+  freq?: number;
+  decay?: boolean;
+  dur?: number | DurToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {amp = 3, freq = 1.6} = o;
+  const t = frame - o.at;
+  if (o.active === false || t < 0) {
+    return 0;
+  }
+  if (o.decay) {
+    const env = 1 - progress(frame, o.at, frames(o.dur, DUR.f5));
+    return amp * env * Math.sin(t / freq);
+  }
+  return amp * Math.sin(t / freq);
+}
+
+// ── 片尾渐黑（红线四：从 beat 总时长推导，勿用末句时长） ────────────────
+
+export function useFadeOut(durationInFrames: number, o: {frames?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const f = o.frames ?? 36; // 1.2s
+  return 1 - progress(frame, durationInFrames - f, f);
+}
diff --git a/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/index.ts b/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/index.ts
new file mode 100644
index 000000000..97fd22a5c
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/index.ts
@@ -0,0 +1,5 @@
+/** 运动层门面——场景代码统一 `import {...} from '../motion'`。 */
+export * from './tokens';
+export * from './window';
+export * from './schedule';
+export * from './hooks';
diff --git a/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/schedule.ts b/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/schedule.ts
new file mode 100644
index 000000000..5703e3315
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/schedule.ts
@@ -0,0 +1,65 @@
+/** 错峰编排（stagger）纯函数——收敛手写 `frame - i*N`（跨 8 集约 356 处、
+ *  步长 K∈{2,3,4,5,6,8,10} 任意取值、无节奏标尺）。
+ *
+ * 三种模式（互斥，参数即文档）：
+ * - stride：固定步长（与旧手写行为一致——迁移期的保守选项）；
+ * - lag：Manim LaggedStart 语义 start[i] = i·dur·lagRatio（0 = 同刻齐动，1 = 首尾相接）；
+ * - fit：n 个子项恰好装进窗口 total（末项恰在窗口末完成——「随句推进」的首选）。
+ *
+ * 钳制优先级（motion.test.ts 钉死，自左向右）：不外溢窗口 > 最小步长 > 子项时长。
+ * 窗口属于 beat 时间轴，外溢会踩进下一 beat；装不下时先缩子项时长，连 1 帧
+ * 子项都无法错开时显式抛错，不返回违反 fit 契约的计划。
+ */
+export type ScheduleOpts = {
+  /** 子项时长（帧；缺省 DUR.f3=5——「快速子项」档）。 */
+  dur?: number;
+  /** 模式一：固定步长。 */
+  stride?: number;
+  /** 模式二：lag 比率（Manim lag_ratio）。 */
+  lag?: number;
+  /** 模式三：拟装入的窗口总长（帧）。 */
+  fit?: {total: number};
+  /** 相邻起点期望下限，默认 2 帧；fit 紧窗时可按优先级退至 1 帧。 */
+  minStride?: number;
+  /** 子项时长期望下限，默认 3 帧；fit 为守住窗口可退至 1 帧。 */
+  minDur?: number;
+};
+export type Schedule = {starts: number[]; dur: number};
+
+export function schedule(n: number, o: ScheduleOpts): Schedule {
+  const minStride = o.minStride ?? 2;
+  const minDur = o.minDur ?? 3;
+  const modes = [o.stride !== undefined, o.lag !== undefined, o.fit !== undefined].filter(
+    Boolean,
+  ).length;
+  if (modes > 1) {
+    throw new Error('schedule: stride / lag / fit 三选一');
+  }
+  let dur = Math.max(minDur, o.dur ?? 5);
+  if (n <= 0) {
+    return {starts: [], dur};
+  }
+  let stride: number;
+  if (o.fit) {
+    const total = Math.max(1, o.fit.total);
+    if (n > 1 && total < n) {
+      throw new Error(
+        `schedule: fit.total=${total} 无法容纳 ${n} 个至少 1 帧且起点间隔至少 1 帧的子项`,
+      );
+    }
+    dur = Math.min(dur, total);
+    stride = n === 1 ? 0 : (total - dur) / (n - 1);
+    const targetStride = Math.max(1, minStride);
+    if (n > 1 && stride < targetStride) {
+      // 先缩时长争取期望步长；仍不足时牺牲步长，但至少保留 1 帧先后。
+      dur = Math.max(1, Math.min(dur, total - targetStride * (n - 1)));
+      stride = (total - dur) / (n - 1);
+    }
+  } else if (o.lag !== undefined) {
+    stride = dur * o.lag;
+  } else {
+    stride = o.stride ?? minStride;
+  }
+  stride = Math.max(n === 1 || o.lag === 0 ? 0 : 1, stride);
+  return {starts: Array.from({length: n}, (_, i) => Math.round(i * stride)), dur};
+}
diff --git a/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/tokens.ts b/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/tokens.ts
new file mode 100644
index 000000000..457448260
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/tokens.ts
@@ -0,0 +1,87 @@
+/** 运动令牌——时长标尺 / 缓动曲线 / 弹簧手感 的单一事实源。
+ *
+ * 只放纯数据与纯函数：不 import remotion、不读 theme（颜色一律经参数注入）——
+ * 这是本层能以 frozen 档跨两个系列共享的前提（两系列 theme token 名已分叉：
+ * CC 用 core/mech/deny、SE 用 danger），判据同 test_chrome_motifs_only_read_base_theme_tokens。
+ *
+ * 取值依据（勿凭感觉改；改前先在本集校准轮逐幕目视复测，依据写回此处注释）：
+ * - 时长六档取 IBM Carbon DTCG（70/110/150/240/400/700ms）@30fps 四舍五入。
+ *   弃 Material 十六档：30fps 量化下其 15 个相邻对里 6 对落进同一帧数（伪选择）。
+ * - 缓动控制点取 Material 3 标准三件；曲线本体在 hooks.ts 经 Remotion Easing.bezier 求值。
+ * - 弹簧预设锚定本仓实测手感：settle=200 即既有 9/10 调用点的惯用值（延续成片观感），
+ *   snap=12 来自 P4「插头咬合」的过冲；ζ 与过冲峰值的关系由 motion.test.ts 用
+ *   Mp = exp(-πζ/√(1-ζ²)) 钉死。
+ * - effects 不变量：不透明度/颜色永不过冲——effects 类动画一律时长+缓动，
+ *   弹簧只用于空间位移（M3 spatial/effects 二分的落地）。
+ */
+
+/** 时长标尺（帧 @30fps）。叙事节拍（4–8s）不用此表——那是 window/schedule 的职责。 */
+export const DUR = {
+  /** 70ms：微反馈（辉光起点、光标） */
+  f1: 2,
+  /** 110ms：快速子项（列表错峰的单项时长） */
+  f2: 3,
+  /** 150ms：标准入场 */
+  f3: 5,
+  /** 200ms：强调入场 */
+  f4: 7,
+  /** 400ms：大位移 / 镜头推近 / 描线 */
+  f5: 12,
+  /** 700ms：幕级大动作（少用） */
+  f6: 21,
+} as const;
+export type DurToken = keyof typeof DUR;
+
+/** 缓动令牌。 */
+export type EasingToken = 'standard' | 'decelerate' | 'accelerate' | 'linear';
+
+/** 贝塞尔控制点（x1,y1,x2,y2）；linear 无控制点。 */
+export const EASING_CP: Record<
+  Exclude<EasingToken, 'linear'>,
+  readonly [number, number, number, number]
+> = {
+  // M3 standard：入场默认
+  standard: [0.2, 0, 0, 1],
+  // M3 decelerate：强减速（大位移入场、镜头推近）
+  decelerate: [0.05, 0.7, 0.1, 1],
+  // M3 accelerate：出场加速
+  accelerate: [0.3, 0, 0.8, 0.15],
+};
+
+/** 弹簧预设（直传 Remotion spring config；ζ = c/(2√(k·m))）。 */
+export type SpringPreset = 'settle' | 'settleSoft' | 'snap';
+export const SPRING: Record<SpringPreset, {damping: number; stiffness: number; mass: number}> = {
+  // ζ≈10：无过冲平滑滑入——本仓主流手感（既有场景 9/10 处 damping 200）
+  settle: {damping: 200, stiffness: 100, mass: 1},
+  // ζ≈8.5：更绵一点（P0/P1 既有 180/170 档的收敛）
+  settleSoft: {damping: 170, stiffness: 100, mass: 1},
+  // ζ≈0.6：轻微过冲（咬合/弹入——原 P4 damping 12）
+  snap: {damping: 12, stiffness: 100, mass: 1},
+};
+
+/** 阻尼比 ζ。设计系统文档普遍给 ζ（无量纲），Remotion 取阻尼系数 c——直抄会得
+ *  ζ≈0.02 的暴力弹跳且能通过渲染体检，这是迁移期最高风险项（单测钉死）。 */
+export const dampingRatio = (s: {
+  damping: number;
+  stiffness: number;
+  mass: number;
+}): number => s.damping / (2 * Math.sqrt(s.stiffness * s.mass));
+
+/** 欠阻尼弹簧的峰值位置（1 = 恰好到终点不过冲；ζ ≥ 1 恒 1）。
+ *  Mp = exp(-πζ/√(1-ζ²)) 是超出终点的幅度，峰值 = 1 + Mp。 */
+export const overshootPeak = (zeta: number): number =>
+  zeta >= 1 ? 1 : 1 + Math.exp((-Math.PI * zeta) / Math.sqrt(1 - zeta * zeta));
+
+/** 出场快于入场的系数（MDC 实测 400ms 入 / 150ms 出 ≈ 0.375，取 0.4 禁手填）。 */
+export const EXIT_FACTOR = 0.4;
+
+/** 字幕安全带上沿：1080 - qa_frames.SUBTITLE_BAND_PX(160)，与体检口径同源。 */
+export const SAFE_TOP_Y = 920;
+
+/** 自下方入场的行程安全钳制：落位态底边 restBottom 之上才是可用的进场空间。
+ *  ISSUE-170 的手工逐卡反算收敛于此——该缺陷类从「评审抽帧抓」变「构造不可能」。 */
+export const clampRiseDist = (
+  dist: number,
+  restBottom: number,
+  safeTop: number = SAFE_TOP_Y,
+): number => Math.max(0, Math.min(dist, safeTop - restBottom));
diff --git a/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/window.ts b/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/window.ts
new file mode 100644
index 000000000..69bd59c7a
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-memory-video/video/src/motion/window.ts
@@ -0,0 +1,43 @@
+/** 运动窗口纯函数——「父级持有绝对时间，子动画只是父进度上的窗口」。
+ *
+ * 这是 audio-first 时序与可复用运动模型兼容的核心机制：beat 的绝对帧来自
+ * beatWindow()（数据源是 TTS 实测 manifest），子动画不写死帧数、只声明自己在
+ * beat 进度上的 [start, end] 窗口 ⇒ 旁白实测时长变化时全部窗口自动重定时，
+ * 「写死帧数与口播脱钩」缺陷类（skills/08 实录）由构造消灭。
+ *
+ * 语义借 MDC TransitionUtils.lerp(startFraction, endFraction)：窗外钳制端点。
+ * 本模块零依赖（不 import remotion / theme）——frozen 跨系列共享与 node 单测的前提。
+ */
+
+/** 钳制到 [0,1]——一切进度的唯一出口，防负值/超 1 渗进 transform。 */
+export const clamp01 = (x: number): number => (x < 0 ? 0 : x > 1 ? 1 : x);
+
+/** 子动画窗口：父进度 p(0..1) 在 [s,e] 片段上的局部进度。 */
+export const win = (p: number, w: readonly [number, number]): number =>
+  clamp01((p - w[0]) / (w[1] - w[0]));
+
+/** beat 进度：局部帧 → 该 beat 的 0..1 进度。 */
+export const beatProgress = (
+  frame: number,
+  from: number,
+  durationInFrames: number,
+): number => clamp01((frame - from) / Math.max(1, durationInFrames));
+
+/** 帧域进度：[at, at+dur] 上的 0..1（dur ≤ 0 视作 1，防除零）。 */
+export const progress = (frame: number, at: number, dur: number): number =>
+  clamp01((frame - at) / Math.max(1, dur));
+
+/** 已过帧数 → 可见字符数；cps 随实际 fps 换算，显式帧间隔不受 fps 影响。 */
+export const revealCharCount = (
+  elapsedFrames: number,
+  fps: number,
+  cps: number,
+  framesPerChar?: number,
+): number => {
+  const elapsed = Math.max(0, elapsedFrames);
+  const count =
+    framesPerChar === undefined
+      ? Math.floor((elapsed / fps) * cps)
+      : Math.floor(elapsed / Math.max(1, framesPerChar));
+  return Math.max(0, count);
+};
diff --git a/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/package.json b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/package.json
index 6c9440d49..2153d57e7 100644
--- a/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/package.json
+++ b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/package.json
@@ -19,10 +19,5 @@
   "devDependencies": {
     "@types/react": "^19.0.0",
     "typescript": "^5.6.0"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild"
-    ]
   }
 }
diff --git a/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/pnpm-workspace.yaml b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/pnpm-workspace.yaml
index f2686ac7d..add822dbe 100644
--- a/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/pnpm-workspace.yaml
+++ b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/pnpm-workspace.yaml
@@ -1,4 +1,9 @@
-# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的唯一理由。
+# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的首要理由。
 # pnpm 12 起仅靠 `--ignore-workspace` 不够：pnpm 仍会沿 packageManager 向上锚定到仓库根，
 # 用本工程的解析结果覆写根 pnpm-lock.yaml（overrides 全丢）且当场不报错。见 ISSUE-175。
 packages: []
+# pnpm 12 的构建脚本许可（package.json 的 pnpm.onlyBuiltDependencies 已不被读取，
+# 静默忽略会使安装以 ERR_PNPM_IGNORED_BUILDS 中断、node_modules 半残）。键名与取值
+# 与 `pnpm approve-builds esbuild --yes` 实际写入的形态逐字一致——勿改回旧键名。
+allowBuilds:
+  esbuild: true
diff --git a/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/scripts/motion.test.ts b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/scripts/motion.test.ts
new file mode 100644
index 000000000..5e29cab52
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/scripts/motion.test.ts
@@ -0,0 +1,141 @@
+/**
+ * 运动层纯函数单测——`node --test scripts/motion.test.ts`（Node ≥ 23.6 原生跑 TS）。
+ *
+ * 刻意放在 video/ 而非 src/：tsconfig include 只有 src（frozen，不为测试改动），
+ * 而本文件 import 需带 .ts 后缀（Node ESM 解析规则）——tsc 若收编会因
+ * allowImportingTsExtensions 未开而报错。src/ 的类型覆盖由 tsc --noEmit 全量保证，
+ * 本文件只测纯函数行为，不做类型承重。
+ *
+ * 只 import 纯模块（tokens/window/schedule——零 remotion/react 依赖）：
+ * hooks 是它们的薄包装，行为由 MotionGallery 目视 + 场景抽帧覆盖。
+ */
+import {strict as assert} from 'node:assert';
+import test from 'node:test';
+
+import {DUR, EASING_CP, EXIT_FACTOR, SAFE_TOP_Y, SPRING, clampRiseDist, dampingRatio, overshootPeak} from '../src/motion/tokens.ts';
+import {beatProgress, clamp01, progress, revealCharCount, win} from '../src/motion/window.ts';
+import {schedule} from '../src/motion/schedule.ts';
+
+// ── tokens ────────────────────────────────────────────────────────────
+
+test('时长标尺在 30fps 下相邻档可辨（≥1 帧差）', () => {
+  const v = Object.values(DUR) as number[];
+  for (let i = 1; i < v.length; i++) {
+    assert.ok(v[i] - v[i - 1] >= 1, `第 ${i} 档与前一档同帧数（伪选择）`);
+  }
+  assert.ok(v.length === 6);
+});
+
+test('ζ→过冲换算钉死：snap 轻过冲、settle 零过冲（直抄 dampingRatio 的反例护栏）', () => {
+  const zSnap = dampingRatio(SPRING.snap);
+  const zSettle = dampingRatio(SPRING.settle);
+  assert.ok(zSnap > 0.4 && zSnap < 0.9, `snap ζ=${zSnap}`);
+  // Mp = exp(-πζ/√(1-ζ²)) 是超出幅度；峰值 = 1 + Mp（ζ=0.6 → 峰值 ≈1.095）
+  assert.ok(overshootPeak(zSnap) > 1.02 && overshootPeak(zSnap) < 1.2, `snap 峰值 ${overshootPeak(zSnap)}`);
+  assert.ok(zSettle > 1, 'settle 须过阻尼');
+  assert.equal(overshootPeak(zSettle), 1);
+  // 反例：把设计系统的 ζ 当 damping 直填（0.8）→ ζ≈0.04、峰值≈1.88 暴力弹跳
+  const wrong = dampingRatio({damping: 0.8, stiffness: 100, mass: 1});
+  assert.ok(overshootPeak(wrong) > 1.8, `直抄 ζ 的峰值=${overshootPeak(wrong)}，必须被此断言抓住`);
+});
+
+test('缓动控制点合法（CSS 规则 x∈[0,1]，且 x(t) 数值单调——可作函数求值）', () => {
+  for (const cp of Object.values(EASING_CP)) {
+    const [x1, , x2] = cp;
+    assert.ok(x1 >= 0 && x1 <= 1 && x2 >= 0 && x2 <= 1, `x 越界：${cp}`);
+    // x1<x2 是充分不必要（M3 standard (0.2,0,0,1) 的 x2<x1 仍单调）——判据用导数采样
+    for (let i = 0; i <= 50; i++) {
+      const t = i / 50;
+      const dx =
+        3 * (1 - t) ** 2 * x1 + 6 * (1 - t) * t * (x2 - x1) + 3 * t * t * (1 - x2);
+      assert.ok(dx > -1e-9, `x(t) 非单调 @t=${t}：${cp}`);
+    }
+  }
+});
+
+test('出场快于入场系数与安全带口径为常量', () => {
+  assert.equal(EXIT_FACTOR, 0.4);
+  assert.equal(SAFE_TOP_Y, 920);
+});
+
+test('clampRiseDist：自下方入场行程不探进字幕安全带', () => {
+  assert.equal(clampRiseDist(120, 836), 84, 'ISSUE-170 实测几何：rest 836 → 行程封顶 84');
+  assert.equal(clampRiseDist(40, 836), 40, '未超限不动');
+  assert.equal(clampRiseDist(120, 960), 0, '落位已在安全带内 → 零行程（退化但安全）');
+});
+
+// ── window ────────────────────────────────────────────────────────────
+
+test('clamp01 / progress / win 的钳制语义', () => {
+  assert.equal(clamp01(-1), 0);
+  assert.equal(clamp01(2), 1);
+  assert.equal(progress(10, 10, 10), 0, '起点为 0');
+  assert.equal(progress(20, 10, 10), 1, '终点为 1');
+  assert.equal(progress(5, 10, 10), 0, '窗外前钳 0');
+  assert.equal(progress(99, 10, 10), 1, '窗外后钳 1');
+  assert.equal(win(0.5, [0.25, 0.75]), 0.5);
+  assert.equal(win(0.1, [0.25, 0.75]), 0);
+  assert.equal(win(0.9, [0.25, 0.75]), 1);
+  assert.equal(beatProgress(0, -30, 90), 1 / 3);
+});
+
+test('逐字揭示：cps 按实际 fps 换算并向下取整，framesPerChar 保持固定帧间隔', () => {
+  assert.equal(revealCharCount(29, 60, 12), 5);
+  assert.equal(revealCharCount(30, 60, 12), 6);
+  assert.equal(revealCharCount(30, 24, 12, 3), 10);
+  assert.equal(revealCharCount(30, 120, 12, 3), 10);
+});
+
+// ── schedule ──────────────────────────────────────────────────────────
+
+test('fit 模式：末项恰在窗口末完成、不外溢', () => {
+  const p = schedule(5, {dur: 10, fit: {total: 90}});
+  const last = p.starts[4] + p.dur;
+  assert.ok(last <= 90 + 1, `末项 ${last} 外溢`);
+  assert.ok(last >= 89, `末项 ${last} 未到窗口末`);
+});
+
+test('fit 装不下时缩子项时长，不外溢窗口（优先级：不外溢 > 最小步长 > 子项时长）', () => {
+  // total 30 时 (30-12)/7≈2.57 ≥ minStride=2 仍装得下；压到 24 才触发缩时长
+  const p = schedule(8, {dur: 12, fit: {total: 24}});
+  const last = p.starts[7] + p.dur;
+  assert.ok(last <= 24, `末项 ${last} 外溢`);
+  assert.ok(p.dur >= 3, '子项时长跌破下限');
+  assert.ok(p.dur < 12, '装不下却未缩子项时长');
+});
+
+test('fit 窗口连 1 帧子项也容不下时显式拒绝，不返回外溢计划', () => {
+  assert.throws(() => schedule(8, {dur: 12, fit: {total: 5}}), /fit\.total=5.*8/);
+});
+
+test('fit 可行极限先牺牲子项时长，仍完整落在窗口内', () => {
+  const p = schedule(8, {dur: 12, fit: {total: 8}});
+  assert.equal(p.dur, 1);
+  assert.equal(p.starts[7] + p.dur, 8);
+});
+
+test('lag 模式：Manim 语义 start[i] = i·dur·lag', () => {
+  const p = schedule(3, {dur: 10, lag: 0.5});
+  assert.deepEqual(p.starts, [0, 5, 10]);
+  assert.deepEqual(schedule(3, {dur: 10, lag: 0}).starts, [0, 0, 0], 'lag=0 须同刻齐动');
+});
+
+test('stride 模式与三选一守卫', () => {
+  assert.deepEqual(schedule(3, {dur: 5, stride: 4}).starts, [0, 4, 8]);
+  assert.throws(() => schedule(3, {dur: 5, stride: 4, lag: 1}));
+  assert.throws(() => schedule(3, {dur: 5, lag: 1, fit: {total: 40}}));
+});
+
+test('最小步长与空集', () => {
+  assert.deepEqual(schedule(0, {dur: 5, stride: 4}), {starts: [], dur: 5});
+  const p = schedule(2, {dur: 5, stride: 0}); // 非法步长 → 抬到下限
+  assert.ok(p.starts[1] - p.starts[0] >= 1);
+});
+
+test('起点取整且单调不减', () => {
+  const p = schedule(6, {dur: 7, fit: {total: 53}});
+  for (let i = 1; i < p.starts.length; i++) {
+    assert.ok(p.starts[i] >= p.starts[i - 1], '起点须单调不减');
+    assert.ok(Number.isInteger(p.starts[i]));
+  }
+});
diff --git a/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/gallery.tsx b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/gallery.tsx
new file mode 100644
index 000000000..a71737133
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/gallery.tsx
@@ -0,0 +1,265 @@
+/** MotionGallery——运动层的评审面（独立 Remotion 入口，不经 Root.tsx）。
+ *
+ * 用法（在 video/ 目录，.bin 直调防污染根 workspace）：
+ *   ./node_modules/.bin/remotion still src/motion/gallery.tsx MotionGallery \
+ *       out/motion-gallery.png --frame=30
+ *
+ * 全部模型 × 变体一屏可渲：秒级出图，供 token 校准轮逐格目视。
+ * 色板为本文件内字面量（dev 工具面，不进成片、不读 theme——保持 frozen 跨系列共享）。
+ */
+import React from 'react';
+import {AbsoluteFill, Composition, registerRoot} from 'remotion';
+import {
+  useAccelTravel,
+  useBreathe,
+  useCount,
+  useDim,
+  useDraw,
+  useEnter,
+  useFadeOut,
+  useFlowDash,
+  useImpulse,
+  usePushIn,
+  useReveal,
+  useShake,
+  useStagger,
+  useTravel,
+} from './hooks';
+
+const COLS = 5;
+const CW = 340;
+const CH = 230;
+const GAP = 18;
+
+/** dev 工具面字面量色板（与各集 theme 底座同值但刻意独立声明——不读 theme）。 */
+const C = {
+  bg: '#0E1116',
+  panel: '#171C26',
+  border: '#2A3242',
+  text: '#F2F5FA',
+  dim: '#9AA7B8',
+  core: '#D97757',
+  mech: '#64C4C0',
+  deny: '#EF6461',
+};
+
+/** 单元格壳：定位 + 角标。 */
+const Cell: React.FC<{i: number; name: string; children: React.ReactNode}> = ({i, name, children}) => (
+  <div
+    style={{
+      position: 'absolute',
+      left: 72 + (i % COLS) * (CW + GAP),
+      top: 96 + Math.floor(i / COLS) * (CH + GAP),
+      width: CW,
+      height: CH,
+      background: C.panel,
+      border: `2px solid ${C.border}`,
+      borderRadius: 12,
+    }}
+  >
+    <div
+      style={{
+        position: 'absolute',
+        inset: '28px 0 34px 0',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+      }}
+    >
+      {children}
+    </div>
+    <div style={{position: 'absolute', left: 12, bottom: 8, fontFamily: 'monospace', fontSize: 15, color: C.dim}}>
+      {name}
+    </div>
+  </div>
+);
+
+const Box: React.FC<{color?: string; w?: number; h?: number; style?: React.CSSProperties}> = ({
+  color = C.core,
+  w = 200,
+  h = 80,
+  style,
+}) => <div style={{width: w, height: h, background: C.panel, border: `2px solid ${color}`, borderRadius: 10, ...style}} />;
+
+// ── 每格一个组件：hooks 各归其位（Rules of Hooks 的最简守法形态） ────────
+
+const EnterCell: React.FC<{kind: Parameters<typeof useEnter>[0]}> = ({kind}) => {
+  const e = useEnter(kind, {});
+  return <Box style={{opacity: e.opacity, transform: e.transform}} />;
+};
+
+const StaggerCell: React.FC = () => {
+  const ps = useStagger(5, {dur: 5, fit: {total: 60}});
+  return (
+    <div style={{display: 'flex', gap: 10}}>
+      {ps.map((p, i) => (
+        <div
+          key={i}
+          style={{
+            width: 34,
+            height: 80,
+            background: C.panel,
+            border: `2px solid ${C.mech}`,
+            borderRadius: 8,
+            opacity: p,
+            transform: `translateY(${(1 - p) * 14}px)`,
+          }}
+        />
+      ))}
+    </div>
+  );
+};
+
+const DrawCell: React.FC = () => {
+  const d = useDraw(0, 24);
+  return (
+    <svg width={280} height={110}>
+      <path {...d} d="M10 90 C 90 10, 190 100, 270 20" stroke={C.core} strokeWidth={5} fill="none" strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ImpulseCell: React.FC = () => {
+  const g = useImpulse({dur: 30, peak: 1});
+  return (
+    <div
+      style={{
+        width: 90,
+        height: 90,
+        borderRadius: '50%',
+        background: C.core,
+        opacity: 0.3 + 0.7 * g,
+        boxShadow: `0 0 ${10 + 30 * g}px ${C.core}`,
+      }}
+    />
+  );
+};
+
+const BreatheCell: React.FC = () => {
+  const b = useBreathe({period: 30});
+  return (
+    <svg width={160} height={110}>
+      <circle cx={80} cy={55} r={40} fill="none" stroke={C.mech} strokeWidth={5} opacity={b} />
+    </svg>
+  );
+};
+
+const TravelCell: React.FC = () => {
+  const t = useTravel({cx: 140, cy: 55, r: 42, secPerLap: 3});
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} />
+      <circle cx={t.x} cy={t.y} r={9} fill={C.core} />
+    </svg>
+  );
+};
+
+const AccelCell: React.FC = () => {
+  const t = useAccelTravel({cx: 140, cy: 55, r: 42, durs: [28, 20, 14], at: 4});
+  const heat = `rgb(${217 + Math.round(38 * t.heat)}, ${119 - Math.round(60 * t.heat)}, ${87 - Math.round(20 * t.heat)})`;
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} strokeDasharray="4 6" />
+      <circle cx={t.x} cy={t.y} r={9} fill={heat} />
+    </svg>
+  );
+};
+
+const CountCell: React.FC = () => {
+  const v = useCount({to: 255, dur: 40});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 44, color: C.text, fontVariantNumeric: 'tabular-nums'}}>
+      {Math.round(v)}
+    </div>
+  );
+};
+
+const RevealCell: React.FC = () => {
+  const s = useReveal('while (true) { think(); act(); }', {cps: 14});
+  const blink = useBreathe({period: 16, amp: 0.5, base: 0.5});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 20, color: C.text, whiteSpace: 'nowrap'}}>
+      {s}
+      <span style={{opacity: blink}}>▍</span>
+    </div>
+  );
+};
+
+const PushInCell: React.FC = () => {
+  const t = usePushIn(0, {scale: 0.12});
+  return <Box w={160} h={90} color={C.mech} style={{transform: t}} />;
+};
+
+const DimCell: React.FC = () => {
+  const dim = useDim({at: 40, to: 0.35});
+  return (
+    <div style={{display: 'flex', gap: 12}}>
+      <Box w={64} h={80} style={{opacity: dim}} />
+      <Box w={64} h={80} color={C.core} />
+      <Box w={64} h={80} style={{opacity: dim}} />
+    </div>
+  );
+};
+
+const FlowCell: React.FC = () => {
+  const f = useFlowDash({period: 24});
+  return (
+    <svg width={280} height={60}>
+      <line x1={10} y1={30} x2={270} y2={30} stroke={C.mech} strokeWidth={5} {...f} strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ShakeCell: React.FC = () => {
+  const x = useShake({at: 10, amp: 5, decay: true, dur: 40});
+  return <Box w={150} h={80} color={C.deny} style={{transform: `translateX(${x}px)`}} />;
+};
+
+const FadeCell: React.FC = () => {
+  const op = useFadeOut(90, {frames: 36});
+  return (
+    <div style={{position: 'relative', width: 220, height: 90}}>
+      <Box w={220} h={90} color={C.core} style={{position: 'absolute', inset: 0}} />
+      <div style={{position: 'absolute', inset: 0, background: '#000', opacity: 1 - op}} />
+    </div>
+  );
+};
+
+const CELLS: Array<[string, React.ReactNode]> = [
+  ['enter:fall', <EnterCell kind="fall" />],
+  ['enter:rise', <EnterCell kind="rise" />],
+  ['enter:slideL', <EnterCell kind="slideL" />],
+  ['enter:pop', <EnterCell kind="pop" />],
+  ['enter:flyIn', <EnterCell kind="flyIn" />],
+  ['enter:fade', <EnterCell kind="fade" />],
+  ['stagger×5 fit60', <StaggerCell />],
+  ['draw 24f', <DrawCell />],
+  ['impulse 30f', <ImpulseCell />],
+  ['breathe p30', <BreatheCell />],
+  ['travel 3s/lap', <TravelCell />],
+  ['accelTravel', <AccelCell />],
+  ['count→255', <CountCell />],
+  ['reveal 14cps', <RevealCell />],
+  ['pushIn .12', <PushInCell />],
+  ['dim .35@40', <DimCell />],
+  ['flowDash p24', <FlowCell />],
+  ['shake decay', <ShakeCell />],
+  ['fadeOut 36f', <FadeCell />],
+];
+
+const MotionGallery: React.FC = () => (
+  <AbsoluteFill style={{background: C.bg}}>
+    <div style={{position: 'absolute', left: 72, top: 44, fontFamily: 'monospace', fontSize: 24, color: C.text}}>
+      MotionGallery · 30fps · 120f
+    </div>
+    {CELLS.map(([name, node], i) => (
+      <Cell key={name} i={i} name={name}>
+        {node}
+      </Cell>
+    ))}
+  </AbsoluteFill>
+);
+
+registerRoot(() => (
+  <Composition id="MotionGallery" component={MotionGallery} width={1920} height={1080} fps={30} durationInFrames={120} defaultProps={{}} />
+));
diff --git a/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/hooks.ts b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/hooks.ts
new file mode 100644
index 000000000..f87b8a129
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/hooks.ts
@@ -0,0 +1,303 @@
+/** 运动模型（hooks）——分镜「动效」列动词到帧数学的唯一映射。
+ *
+ * 设计约束（违反任何一条即失去本层存在意义）：
+ * 1. hooks 返回数值 / CSS 片段，不渲染 DOM——FadeUp 式包装组件打不进 svg/<g>/
+ *    absolute 布局，是「组件存在却零调用」的实测根因；数值可落进任意 JSX。
+ * 2. 弹簧一律吃局部帧（frame - at）：spring() 每次调用从第 0 帧重模拟，喂全局帧
+ *    会让长片末帧每个 spring 跑两万余次迭代。
+ * 3. effects（不透明度/颜色）永不吃弹簧——一律时长+缓动（tokens 的二分不变量）。
+ * 4. 不读 theme：颜色一律经参数传入（frozen 跨系列共享的前提）。
+ * 5. `at` 锚点一律来自句边界（rel(beat, '句id')），禁写死帧数。
+ */
+import {Easing, interpolate, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {
+  DUR,
+  EASING_CP,
+  SPRING,
+  clampRiseDist,
+  type DurToken,
+  type EasingToken,
+  type SpringPreset,
+} from './tokens';
+import {progress, revealCharCount} from './window';
+import {schedule, type ScheduleOpts} from './schedule';
+
+/** 帧数解析：token 或直接帧数；缺省用 def。 */
+export const frames = (d: number | DurToken | undefined, def: number): number =>
+  d === undefined ? def : typeof d === 'number' ? d : DUR[d];
+
+/** 缓动令牌 → Remotion 缓动函数（linear 直通）。 */
+export const easeF = (t: EasingToken): ((x: number) => number) =>
+  t === 'linear'
+    ? Easing.linear
+    : Easing.bezier(
+        ...(EASING_CP[t] as [number, number, number, number]),
+      );
+
+/** 缓动后的 0..1 进度（各模型共用的原子）。 */
+const eased = (
+  frame: number,
+  at: number,
+  dur: number,
+  e: EasingToken,
+): number => interpolate(progress(frame, at, dur), [0, 1], [0, 1], {easing: easeF(e)});
+
+/** 缓动数值进度——「clamped 0→1 手写 interpolate」惯用形的统一替身：
+ *  时机值走 token，缓动默认 standard（线性原版会被这一档替换——质量提升点之一）。 */
+export function useProgress(
+  at: number,
+  dur: number | DurToken = DUR.f5,
+  easing: EasingToken = 'standard',
+): number {
+  const frame = useCurrentFrame();
+  return eased(frame, at, frames(dur, DUR.f5), easing);
+}
+
+/** 弹簧数值进度（驱动几何量/位移；effects 通道用 useProgress——tokens 二分不变量）。
+ *  局部帧 + 可选 durationInFrames 截停（防窗口外余振；缺省不设上限，与既有手写等价）。 */
+export function useSpring(
+  preset: SpringPreset,
+  o: {at?: number; dur?: number | DurToken} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const cfg: Parameters<typeof spring>[0] = {
+    frame: frame - (o.at ?? 0),
+    fps,
+    config: SPRING[preset],
+  };
+  if (o.dur !== undefined) {
+    cfg.durationInFrames = frames(o.dur, DUR.f5);
+  }
+  return spring(cfg);
+}
+
+// ── 入场（enter：落下/上浮/滑入/弹出/飞入/淡入） ────────────────────────
+
+export type EnterKind = 'fall' | 'rise' | 'slideL' | 'slideR' | 'pop' | 'flyIn' | 'fade';
+export type EnterOpts = {
+  /** 句边界锚（局部帧）。 */
+  at?: number;
+  dur?: number | DurToken;
+  easing?: EasingToken;
+  /** 空间通道用弹簧（位移类才有意义；fade/pop 无效）。 */
+  springPreset?: SpringPreset;
+  /** 位移像素（fall/rise/slide*；缺省 30）。 */
+  dist?: number;
+  /** rise 专用：落位态底边 y——行程经 clampRiseDist 钳进字幕安全带之上。 */
+  restBottom?: number;
+};
+export type EnterStyle = {opacity: number; transform: string};
+
+export function useEnter(kind: EnterKind, o: EnterOpts = {}): EnterStyle {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const at = o.at ?? 0;
+  const dur = frames(o.dur, DUR.f4);
+  let dist = o.dist ?? 30;
+  if (kind === 'rise' && o.restBottom !== undefined) {
+    dist = clampRiseDist(dist, o.restBottom);
+  }
+  // effects 通道：纯缓动、略快于空间通道（元素先「看见」再「落位」）
+  const opacity = progress(frame, at, Math.max(2, Math.round(dur * 0.8)));
+  // spatial 通道：可选弹簧（局部帧 + durationInFrames 截停，防窗口外余振）
+  const p = o.springPreset
+    ? spring({
+        frame: frame - at,
+        fps,
+        config: SPRING[o.springPreset],
+        durationInFrames: dur,
+      })
+    : eased(frame, at, dur, o.easing ?? 'standard');
+  const inv = 1 - p;
+  const t: string[] = [];
+  if (kind === 'fall') t.push(`translateY(${-inv * dist}px)`);
+  if (kind === 'rise') t.push(`translateY(${inv * dist}px)`);
+  if (kind === 'slideL') t.push(`translateX(${-inv * dist}px)`);
+  if (kind === 'slideR') t.push(`translateX(${inv * dist}px)`);
+  if (kind === 'pop') t.push(`scale(${0.9 + 0.1 * p})`);
+  if (kind === 'flyIn') t.push(`scale(${0.6 + 0.4 * p})`);
+  return {opacity, transform: t.length ? t.join(' ') : 'none'};
+}
+
+// ── 序列错峰（stagger：依次/逐行/逐条/逐格） ───────────────────────────
+
+export type StaggerOpts = ScheduleOpts & {at?: number; easing?: EasingToken};
+
+/** 返回 n 个 0..1 进度——第 i 项随编排依次入场。 */
+export function useStagger(n: number, o: StaggerOpts = {}): number[] {
+  const frame = useCurrentFrame();
+  const {at = 0, easing = 'standard'} = o;
+  const plan = schedule(n, o);
+  return plan.starts.map((s) => eased(frame, at + s, plan.dur, easing));
+}
+
+// ── 描线（draw：红线三由构造保证——只产 pathLength 归一化三元组） ────────
+
+export type DrawProps = {pathLength: 1; strokeDasharray: 1; strokeDashoffset: number};
+
+export function useDraw(at: number, dur: number | DurToken = DUR.f5): DrawProps {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(dur, DUR.f5), 'decelerate');
+  return {pathLength: 1, strokeDasharray: 1, strokeDashoffset: 1 - p};
+}
+
+// ── 脉冲 / 呼吸（glow 语法：impulse=一次性强调，breathe=持续辉光） ───────
+
+/** 一次性冲击：sin(πp) 包络，起于 0 归于 0，峰值 peak。 */
+export function useImpulse(o: {at?: number; dur?: number | DurToken; peak?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const p = progress(frame, o.at ?? 0, frames(o.dur, DUR.f5));
+  return Math.sin(Math.PI * p) * (o.peak ?? 1);
+}
+
+/** 持续呼吸（原 0.55+0.45·sin(frame/K) 散写的收敛；period 帧一周期——注意与
+ *  原除数 K 的换算 period = 2πK，如 sin(frame/26) → period 163）。offset 为相位
+ *  平移（错峰辉光的 per-index 形态）。 */
+export function useBreathe(
+  o: {period?: number; amp?: number; base?: number; offset?: number} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {amp = 0.45, base = 0.55, period = 26, offset = 0} = o;
+  return base + amp * Math.sin((2 * Math.PI * (frame - offset)) / period);
+}
+
+// ── 巡游（travel：环形为主；absorb 原 useRingDot 与加速绕行累加器克隆） ──
+
+export type TravelPos = {x: number; y: number; angle: number};
+
+/** 匀速环形巡游（angle 单位度，-90 = 12 点方向起）。 */
+export function useTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  secPerLap?: number;
+  offset?: number;
+}): TravelPos {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const lap = (frame / (fps * (o.secPerLap ?? 2.5)) + (o.offset ?? 0)) % 1;
+  const a = -90 + lap * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), angle: a};
+}
+
+/** 加速绕行：逐圈时长 durs[]（如 [40,30,22,16]），跑完全部圈后冻结在终点。
+ *  heat 0..1 随圈数推进（「失控感」的配色偏移系数）。 */
+export function useAccelTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  durs: number[];
+  at?: number;
+  heatPerLap?: number;
+}): {x: number; y: number; heat: number} {
+  const frame = useCurrentFrame();
+  let t = Math.max(0, frame - (o.at ?? 0));
+  let lap = 0;
+  while (lap < o.durs.length && t >= o.durs[lap]) {
+    t -= o.durs[lap];
+    lap += 1;
+  }
+  const within = lap >= o.durs.length ? 1 : t / o.durs[lap];
+  const heat = Math.min(1, lap / (o.heatPerLap ?? o.durs.length));
+  const a = -90 + within * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), heat};
+}
+
+// ── 计数 / 水位（meter 语法；显示层自行 Math.round / toFixed） ──────────
+
+export function useCount(o: {
+  from?: number;
+  to: number;
+  at?: number;
+  dur?: number | DurToken;
+  ease?: EasingToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {from = 0, to, at = 0} = o;
+  const p = eased(frame, at, frames(o.dur, DUR.f6), o.ease ?? 'standard');
+  return from + (to - from) * p;
+}
+
+// ── 打字机 / 逐字流出（type；Terminal 之外的泛化） ──────────────────────
+
+export function useReveal(
+  text: string,
+  o: {at?: number; cps?: number; framesPerChar?: number} = {},
+): string {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const elapsed = Math.max(0, frame - (o.at ?? 0));
+  const n = revealCharCount(elapsed, fps, o.cps ?? 12, o.framesPerChar);
+  return text.slice(0, Math.min(text.length, n));
+}
+
+// ── 镜头推近（pushIn 语法：beat 切换的镜头语言，替代纯淡入） ────────────
+
+export function usePushIn(at: number, o: {scale?: number; dur?: number | DurToken} = {}): string {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(o.dur, DUR.f5), 'decelerate');
+  return `scale(${1 + (o.scale ?? 0.06) * p})`;
+}
+
+// ── 压暗 / 提亮（emphasis 反向：让主体从群像中浮出） ─────────────────────
+
+/** 返回目标透明度系数（1 = 原；to 0.4 即压暗到 40%）。 */
+export function useDim(o: {at: number; to?: number; dur?: number | DurToken}): number {
+  const frame = useCurrentFrame();
+  const p = eased(frame, o.at, frames(o.dur, DUR.f4), 'standard');
+  return 1 + ((o.to ?? 0.4) - 1) * p;
+}
+
+// ── 流光（flow 语法：连线上的行进虚线） ─────────────────────────────────
+
+/** 返回可直接展开到 <line>/<path> 的描边属性（像素 dasharray——与 draw 的
+ *  pathLength 归一化描线是两个正交特性，勿混用于同一元素：红线三）。 */
+export function useFlowDash(o: {
+  dash?: number;
+  gap?: number;
+  /** 帧速率：每 period 帧行进一个 dash+gap 周期。 */
+  period?: number;
+}): {strokeDasharray: string; strokeDashoffset: number} {
+  const frame = useCurrentFrame();
+  const {dash = 10, gap = 14, period = 40} = o;
+  return {
+    strokeDasharray: `${dash} ${gap}`,
+    strokeDashoffset: -(frame * (dash + gap)) / period,
+  };
+}
+
+// ── 抖动（错误/故障语义；收敛 P2/P3 两处克隆） ──────────────────────────
+
+/** 返回 translateX 像素值。active 缺省 true；decay=true 时按 dur 衰减归零。 */
+export function useShake(o: {
+  at: number;
+  active?: boolean;
+  amp?: number;
+  /** 相位分母（原手写 /1.6、/2.2 的口径）。 */
+  freq?: number;
+  decay?: boolean;
+  dur?: number | DurToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {amp = 3, freq = 1.6} = o;
+  const t = frame - o.at;
+  if (o.active === false || t < 0) {
+    return 0;
+  }
+  if (o.decay) {
+    const env = 1 - progress(frame, o.at, frames(o.dur, DUR.f5));
+    return amp * env * Math.sin(t / freq);
+  }
+  return amp * Math.sin(t / freq);
+}
+
+// ── 片尾渐黑（红线四：从 beat 总时长推导，勿用末句时长） ────────────────
+
+export function useFadeOut(durationInFrames: number, o: {frames?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const f = o.frames ?? 36; // 1.2s
+  return 1 - progress(frame, durationInFrames - f, f);
+}
diff --git a/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/index.ts b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/index.ts
new file mode 100644
index 000000000..97fd22a5c
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/index.ts
@@ -0,0 +1,5 @@
+/** 运动层门面——场景代码统一 `import {...} from '../motion'`。 */
+export * from './tokens';
+export * from './window';
+export * from './schedule';
+export * from './hooks';
diff --git a/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/schedule.ts b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/schedule.ts
new file mode 100644
index 000000000..5703e3315
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/schedule.ts
@@ -0,0 +1,65 @@
+/** 错峰编排（stagger）纯函数——收敛手写 `frame - i*N`（跨 8 集约 356 处、
+ *  步长 K∈{2,3,4,5,6,8,10} 任意取值、无节奏标尺）。
+ *
+ * 三种模式（互斥，参数即文档）：
+ * - stride：固定步长（与旧手写行为一致——迁移期的保守选项）；
+ * - lag：Manim LaggedStart 语义 start[i] = i·dur·lagRatio（0 = 同刻齐动，1 = 首尾相接）；
+ * - fit：n 个子项恰好装进窗口 total（末项恰在窗口末完成——「随句推进」的首选）。
+ *
+ * 钳制优先级（motion.test.ts 钉死，自左向右）：不外溢窗口 > 最小步长 > 子项时长。
+ * 窗口属于 beat 时间轴，外溢会踩进下一 beat；装不下时先缩子项时长，连 1 帧
+ * 子项都无法错开时显式抛错，不返回违反 fit 契约的计划。
+ */
+export type ScheduleOpts = {
+  /** 子项时长（帧；缺省 DUR.f3=5——「快速子项」档）。 */
+  dur?: number;
+  /** 模式一：固定步长。 */
+  stride?: number;
+  /** 模式二：lag 比率（Manim lag_ratio）。 */
+  lag?: number;
+  /** 模式三：拟装入的窗口总长（帧）。 */
+  fit?: {total: number};
+  /** 相邻起点期望下限，默认 2 帧；fit 紧窗时可按优先级退至 1 帧。 */
+  minStride?: number;
+  /** 子项时长期望下限，默认 3 帧；fit 为守住窗口可退至 1 帧。 */
+  minDur?: number;
+};
+export type Schedule = {starts: number[]; dur: number};
+
+export function schedule(n: number, o: ScheduleOpts): Schedule {
+  const minStride = o.minStride ?? 2;
+  const minDur = o.minDur ?? 3;
+  const modes = [o.stride !== undefined, o.lag !== undefined, o.fit !== undefined].filter(
+    Boolean,
+  ).length;
+  if (modes > 1) {
+    throw new Error('schedule: stride / lag / fit 三选一');
+  }
+  let dur = Math.max(minDur, o.dur ?? 5);
+  if (n <= 0) {
+    return {starts: [], dur};
+  }
+  let stride: number;
+  if (o.fit) {
+    const total = Math.max(1, o.fit.total);
+    if (n > 1 && total < n) {
+      throw new Error(
+        `schedule: fit.total=${total} 无法容纳 ${n} 个至少 1 帧且起点间隔至少 1 帧的子项`,
+      );
+    }
+    dur = Math.min(dur, total);
+    stride = n === 1 ? 0 : (total - dur) / (n - 1);
+    const targetStride = Math.max(1, minStride);
+    if (n > 1 && stride < targetStride) {
+      // 先缩时长争取期望步长；仍不足时牺牲步长，但至少保留 1 帧先后。
+      dur = Math.max(1, Math.min(dur, total - targetStride * (n - 1)));
+      stride = (total - dur) / (n - 1);
+    }
+  } else if (o.lag !== undefined) {
+    stride = dur * o.lag;
+  } else {
+    stride = o.stride ?? minStride;
+  }
+  stride = Math.max(n === 1 || o.lag === 0 ? 0 : 1, stride);
+  return {starts: Array.from({length: n}, (_, i) => Math.round(i * stride)), dur};
+}
diff --git a/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/tokens.ts b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/tokens.ts
new file mode 100644
index 000000000..457448260
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/tokens.ts
@@ -0,0 +1,87 @@
+/** 运动令牌——时长标尺 / 缓动曲线 / 弹簧手感 的单一事实源。
+ *
+ * 只放纯数据与纯函数：不 import remotion、不读 theme（颜色一律经参数注入）——
+ * 这是本层能以 frozen 档跨两个系列共享的前提（两系列 theme token 名已分叉：
+ * CC 用 core/mech/deny、SE 用 danger），判据同 test_chrome_motifs_only_read_base_theme_tokens。
+ *
+ * 取值依据（勿凭感觉改；改前先在本集校准轮逐幕目视复测，依据写回此处注释）：
+ * - 时长六档取 IBM Carbon DTCG（70/110/150/240/400/700ms）@30fps 四舍五入。
+ *   弃 Material 十六档：30fps 量化下其 15 个相邻对里 6 对落进同一帧数（伪选择）。
+ * - 缓动控制点取 Material 3 标准三件；曲线本体在 hooks.ts 经 Remotion Easing.bezier 求值。
+ * - 弹簧预设锚定本仓实测手感：settle=200 即既有 9/10 调用点的惯用值（延续成片观感），
+ *   snap=12 来自 P4「插头咬合」的过冲；ζ 与过冲峰值的关系由 motion.test.ts 用
+ *   Mp = exp(-πζ/√(1-ζ²)) 钉死。
+ * - effects 不变量：不透明度/颜色永不过冲——effects 类动画一律时长+缓动，
+ *   弹簧只用于空间位移（M3 spatial/effects 二分的落地）。
+ */
+
+/** 时长标尺（帧 @30fps）。叙事节拍（4–8s）不用此表——那是 window/schedule 的职责。 */
+export const DUR = {
+  /** 70ms：微反馈（辉光起点、光标） */
+  f1: 2,
+  /** 110ms：快速子项（列表错峰的单项时长） */
+  f2: 3,
+  /** 150ms：标准入场 */
+  f3: 5,
+  /** 200ms：强调入场 */
+  f4: 7,
+  /** 400ms：大位移 / 镜头推近 / 描线 */
+  f5: 12,
+  /** 700ms：幕级大动作（少用） */
+  f6: 21,
+} as const;
+export type DurToken = keyof typeof DUR;
+
+/** 缓动令牌。 */
+export type EasingToken = 'standard' | 'decelerate' | 'accelerate' | 'linear';
+
+/** 贝塞尔控制点（x1,y1,x2,y2）；linear 无控制点。 */
+export const EASING_CP: Record<
+  Exclude<EasingToken, 'linear'>,
+  readonly [number, number, number, number]
+> = {
+  // M3 standard：入场默认
+  standard: [0.2, 0, 0, 1],
+  // M3 decelerate：强减速（大位移入场、镜头推近）
+  decelerate: [0.05, 0.7, 0.1, 1],
+  // M3 accelerate：出场加速
+  accelerate: [0.3, 0, 0.8, 0.15],
+};
+
+/** 弹簧预设（直传 Remotion spring config；ζ = c/(2√(k·m))）。 */
+export type SpringPreset = 'settle' | 'settleSoft' | 'snap';
+export const SPRING: Record<SpringPreset, {damping: number; stiffness: number; mass: number}> = {
+  // ζ≈10：无过冲平滑滑入——本仓主流手感（既有场景 9/10 处 damping 200）
+  settle: {damping: 200, stiffness: 100, mass: 1},
+  // ζ≈8.5：更绵一点（P0/P1 既有 180/170 档的收敛）
+  settleSoft: {damping: 170, stiffness: 100, mass: 1},
+  // ζ≈0.6：轻微过冲（咬合/弹入——原 P4 damping 12）
+  snap: {damping: 12, stiffness: 100, mass: 1},
+};
+
+/** 阻尼比 ζ。设计系统文档普遍给 ζ（无量纲），Remotion 取阻尼系数 c——直抄会得
+ *  ζ≈0.02 的暴力弹跳且能通过渲染体检，这是迁移期最高风险项（单测钉死）。 */
+export const dampingRatio = (s: {
+  damping: number;
+  stiffness: number;
+  mass: number;
+}): number => s.damping / (2 * Math.sqrt(s.stiffness * s.mass));
+
+/** 欠阻尼弹簧的峰值位置（1 = 恰好到终点不过冲；ζ ≥ 1 恒 1）。
+ *  Mp = exp(-πζ/√(1-ζ²)) 是超出终点的幅度，峰值 = 1 + Mp。 */
+export const overshootPeak = (zeta: number): number =>
+  zeta >= 1 ? 1 : 1 + Math.exp((-Math.PI * zeta) / Math.sqrt(1 - zeta * zeta));
+
+/** 出场快于入场的系数（MDC 实测 400ms 入 / 150ms 出 ≈ 0.375，取 0.4 禁手填）。 */
+export const EXIT_FACTOR = 0.4;
+
+/** 字幕安全带上沿：1080 - qa_frames.SUBTITLE_BAND_PX(160)，与体检口径同源。 */
+export const SAFE_TOP_Y = 920;
+
+/** 自下方入场的行程安全钳制：落位态底边 restBottom 之上才是可用的进场空间。
+ *  ISSUE-170 的手工逐卡反算收敛于此——该缺陷类从「评审抽帧抓」变「构造不可能」。 */
+export const clampRiseDist = (
+  dist: number,
+  restBottom: number,
+  safeTop: number = SAFE_TOP_Y,
+): number => Math.max(0, Math.min(dist, safeTop - restBottom));
diff --git a/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/window.ts b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/window.ts
new file mode 100644
index 000000000..69bd59c7a
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-multiagent-video/video/src/motion/window.ts
@@ -0,0 +1,43 @@
+/** 运动窗口纯函数——「父级持有绝对时间，子动画只是父进度上的窗口」。
+ *
+ * 这是 audio-first 时序与可复用运动模型兼容的核心机制：beat 的绝对帧来自
+ * beatWindow()（数据源是 TTS 实测 manifest），子动画不写死帧数、只声明自己在
+ * beat 进度上的 [start, end] 窗口 ⇒ 旁白实测时长变化时全部窗口自动重定时，
+ * 「写死帧数与口播脱钩」缺陷类（skills/08 实录）由构造消灭。
+ *
+ * 语义借 MDC TransitionUtils.lerp(startFraction, endFraction)：窗外钳制端点。
+ * 本模块零依赖（不 import remotion / theme）——frozen 跨系列共享与 node 单测的前提。
+ */
+
+/** 钳制到 [0,1]——一切进度的唯一出口，防负值/超 1 渗进 transform。 */
+export const clamp01 = (x: number): number => (x < 0 ? 0 : x > 1 ? 1 : x);
+
+/** 子动画窗口：父进度 p(0..1) 在 [s,e] 片段上的局部进度。 */
+export const win = (p: number, w: readonly [number, number]): number =>
+  clamp01((p - w[0]) / (w[1] - w[0]));
+
+/** beat 进度：局部帧 → 该 beat 的 0..1 进度。 */
+export const beatProgress = (
+  frame: number,
+  from: number,
+  durationInFrames: number,
+): number => clamp01((frame - from) / Math.max(1, durationInFrames));
+
+/** 帧域进度：[at, at+dur] 上的 0..1（dur ≤ 0 视作 1，防除零）。 */
+export const progress = (frame: number, at: number, dur: number): number =>
+  clamp01((frame - at) / Math.max(1, dur));
+
+/** 已过帧数 → 可见字符数；cps 随实际 fps 换算，显式帧间隔不受 fps 影响。 */
+export const revealCharCount = (
+  elapsedFrames: number,
+  fps: number,
+  cps: number,
+  framesPerChar?: number,
+): number => {
+  const elapsed = Math.max(0, elapsedFrames);
+  const count =
+    framesPerChar === undefined
+      ? Math.floor((elapsed / fps) * cps)
+      : Math.floor(elapsed / Math.max(1, framesPerChar));
+  return Math.max(0, count);
+};
diff --git a/apps/negentropy-influence/episodes/claude-code-planning-video/video/package.json b/apps/negentropy-influence/episodes/claude-code-planning-video/video/package.json
index ea8b2e8e6..f16567046 100644
--- a/apps/negentropy-influence/episodes/claude-code-planning-video/video/package.json
+++ b/apps/negentropy-influence/episodes/claude-code-planning-video/video/package.json
@@ -19,10 +19,5 @@
   "devDependencies": {
     "@types/react": "^19.0.0",
     "typescript": "^5.6.0"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild"
-    ]
   }
 }
diff --git a/apps/negentropy-influence/episodes/claude-code-planning-video/video/pnpm-workspace.yaml b/apps/negentropy-influence/episodes/claude-code-planning-video/video/pnpm-workspace.yaml
index f2686ac7d..add822dbe 100644
--- a/apps/negentropy-influence/episodes/claude-code-planning-video/video/pnpm-workspace.yaml
+++ b/apps/negentropy-influence/episodes/claude-code-planning-video/video/pnpm-workspace.yaml
@@ -1,4 +1,9 @@
-# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的唯一理由。
+# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的首要理由。
 # pnpm 12 起仅靠 `--ignore-workspace` 不够：pnpm 仍会沿 packageManager 向上锚定到仓库根，
 # 用本工程的解析结果覆写根 pnpm-lock.yaml（overrides 全丢）且当场不报错。见 ISSUE-175。
 packages: []
+# pnpm 12 的构建脚本许可（package.json 的 pnpm.onlyBuiltDependencies 已不被读取，
+# 静默忽略会使安装以 ERR_PNPM_IGNORED_BUILDS 中断、node_modules 半残）。键名与取值
+# 与 `pnpm approve-builds esbuild --yes` 实际写入的形态逐字一致——勿改回旧键名。
+allowBuilds:
+  esbuild: true
diff --git a/apps/negentropy-influence/episodes/claude-code-planning-video/video/scripts/motion.test.ts b/apps/negentropy-influence/episodes/claude-code-planning-video/video/scripts/motion.test.ts
new file mode 100644
index 000000000..5e29cab52
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-planning-video/video/scripts/motion.test.ts
@@ -0,0 +1,141 @@
+/**
+ * 运动层纯函数单测——`node --test scripts/motion.test.ts`（Node ≥ 23.6 原生跑 TS）。
+ *
+ * 刻意放在 video/ 而非 src/：tsconfig include 只有 src（frozen，不为测试改动），
+ * 而本文件 import 需带 .ts 后缀（Node ESM 解析规则）——tsc 若收编会因
+ * allowImportingTsExtensions 未开而报错。src/ 的类型覆盖由 tsc --noEmit 全量保证，
+ * 本文件只测纯函数行为，不做类型承重。
+ *
+ * 只 import 纯模块（tokens/window/schedule——零 remotion/react 依赖）：
+ * hooks 是它们的薄包装，行为由 MotionGallery 目视 + 场景抽帧覆盖。
+ */
+import {strict as assert} from 'node:assert';
+import test from 'node:test';
+
+import {DUR, EASING_CP, EXIT_FACTOR, SAFE_TOP_Y, SPRING, clampRiseDist, dampingRatio, overshootPeak} from '../src/motion/tokens.ts';
+import {beatProgress, clamp01, progress, revealCharCount, win} from '../src/motion/window.ts';
+import {schedule} from '../src/motion/schedule.ts';
+
+// ── tokens ────────────────────────────────────────────────────────────
+
+test('时长标尺在 30fps 下相邻档可辨（≥1 帧差）', () => {
+  const v = Object.values(DUR) as number[];
+  for (let i = 1; i < v.length; i++) {
+    assert.ok(v[i] - v[i - 1] >= 1, `第 ${i} 档与前一档同帧数（伪选择）`);
+  }
+  assert.ok(v.length === 6);
+});
+
+test('ζ→过冲换算钉死：snap 轻过冲、settle 零过冲（直抄 dampingRatio 的反例护栏）', () => {
+  const zSnap = dampingRatio(SPRING.snap);
+  const zSettle = dampingRatio(SPRING.settle);
+  assert.ok(zSnap > 0.4 && zSnap < 0.9, `snap ζ=${zSnap}`);
+  // Mp = exp(-πζ/√(1-ζ²)) 是超出幅度；峰值 = 1 + Mp（ζ=0.6 → 峰值 ≈1.095）
+  assert.ok(overshootPeak(zSnap) > 1.02 && overshootPeak(zSnap) < 1.2, `snap 峰值 ${overshootPeak(zSnap)}`);
+  assert.ok(zSettle > 1, 'settle 须过阻尼');
+  assert.equal(overshootPeak(zSettle), 1);
+  // 反例：把设计系统的 ζ 当 damping 直填（0.8）→ ζ≈0.04、峰值≈1.88 暴力弹跳
+  const wrong = dampingRatio({damping: 0.8, stiffness: 100, mass: 1});
+  assert.ok(overshootPeak(wrong) > 1.8, `直抄 ζ 的峰值=${overshootPeak(wrong)}，必须被此断言抓住`);
+});
+
+test('缓动控制点合法（CSS 规则 x∈[0,1]，且 x(t) 数值单调——可作函数求值）', () => {
+  for (const cp of Object.values(EASING_CP)) {
+    const [x1, , x2] = cp;
+    assert.ok(x1 >= 0 && x1 <= 1 && x2 >= 0 && x2 <= 1, `x 越界：${cp}`);
+    // x1<x2 是充分不必要（M3 standard (0.2,0,0,1) 的 x2<x1 仍单调）——判据用导数采样
+    for (let i = 0; i <= 50; i++) {
+      const t = i / 50;
+      const dx =
+        3 * (1 - t) ** 2 * x1 + 6 * (1 - t) * t * (x2 - x1) + 3 * t * t * (1 - x2);
+      assert.ok(dx > -1e-9, `x(t) 非单调 @t=${t}：${cp}`);
+    }
+  }
+});
+
+test('出场快于入场系数与安全带口径为常量', () => {
+  assert.equal(EXIT_FACTOR, 0.4);
+  assert.equal(SAFE_TOP_Y, 920);
+});
+
+test('clampRiseDist：自下方入场行程不探进字幕安全带', () => {
+  assert.equal(clampRiseDist(120, 836), 84, 'ISSUE-170 实测几何：rest 836 → 行程封顶 84');
+  assert.equal(clampRiseDist(40, 836), 40, '未超限不动');
+  assert.equal(clampRiseDist(120, 960), 0, '落位已在安全带内 → 零行程（退化但安全）');
+});
+
+// ── window ────────────────────────────────────────────────────────────
+
+test('clamp01 / progress / win 的钳制语义', () => {
+  assert.equal(clamp01(-1), 0);
+  assert.equal(clamp01(2), 1);
+  assert.equal(progress(10, 10, 10), 0, '起点为 0');
+  assert.equal(progress(20, 10, 10), 1, '终点为 1');
+  assert.equal(progress(5, 10, 10), 0, '窗外前钳 0');
+  assert.equal(progress(99, 10, 10), 1, '窗外后钳 1');
+  assert.equal(win(0.5, [0.25, 0.75]), 0.5);
+  assert.equal(win(0.1, [0.25, 0.75]), 0);
+  assert.equal(win(0.9, [0.25, 0.75]), 1);
+  assert.equal(beatProgress(0, -30, 90), 1 / 3);
+});
+
+test('逐字揭示：cps 按实际 fps 换算并向下取整，framesPerChar 保持固定帧间隔', () => {
+  assert.equal(revealCharCount(29, 60, 12), 5);
+  assert.equal(revealCharCount(30, 60, 12), 6);
+  assert.equal(revealCharCount(30, 24, 12, 3), 10);
+  assert.equal(revealCharCount(30, 120, 12, 3), 10);
+});
+
+// ── schedule ──────────────────────────────────────────────────────────
+
+test('fit 模式：末项恰在窗口末完成、不外溢', () => {
+  const p = schedule(5, {dur: 10, fit: {total: 90}});
+  const last = p.starts[4] + p.dur;
+  assert.ok(last <= 90 + 1, `末项 ${last} 外溢`);
+  assert.ok(last >= 89, `末项 ${last} 未到窗口末`);
+});
+
+test('fit 装不下时缩子项时长，不外溢窗口（优先级：不外溢 > 最小步长 > 子项时长）', () => {
+  // total 30 时 (30-12)/7≈2.57 ≥ minStride=2 仍装得下；压到 24 才触发缩时长
+  const p = schedule(8, {dur: 12, fit: {total: 24}});
+  const last = p.starts[7] + p.dur;
+  assert.ok(last <= 24, `末项 ${last} 外溢`);
+  assert.ok(p.dur >= 3, '子项时长跌破下限');
+  assert.ok(p.dur < 12, '装不下却未缩子项时长');
+});
+
+test('fit 窗口连 1 帧子项也容不下时显式拒绝，不返回外溢计划', () => {
+  assert.throws(() => schedule(8, {dur: 12, fit: {total: 5}}), /fit\.total=5.*8/);
+});
+
+test('fit 可行极限先牺牲子项时长，仍完整落在窗口内', () => {
+  const p = schedule(8, {dur: 12, fit: {total: 8}});
+  assert.equal(p.dur, 1);
+  assert.equal(p.starts[7] + p.dur, 8);
+});
+
+test('lag 模式：Manim 语义 start[i] = i·dur·lag', () => {
+  const p = schedule(3, {dur: 10, lag: 0.5});
+  assert.deepEqual(p.starts, [0, 5, 10]);
+  assert.deepEqual(schedule(3, {dur: 10, lag: 0}).starts, [0, 0, 0], 'lag=0 须同刻齐动');
+});
+
+test('stride 模式与三选一守卫', () => {
+  assert.deepEqual(schedule(3, {dur: 5, stride: 4}).starts, [0, 4, 8]);
+  assert.throws(() => schedule(3, {dur: 5, stride: 4, lag: 1}));
+  assert.throws(() => schedule(3, {dur: 5, lag: 1, fit: {total: 40}}));
+});
+
+test('最小步长与空集', () => {
+  assert.deepEqual(schedule(0, {dur: 5, stride: 4}), {starts: [], dur: 5});
+  const p = schedule(2, {dur: 5, stride: 0}); // 非法步长 → 抬到下限
+  assert.ok(p.starts[1] - p.starts[0] >= 1);
+});
+
+test('起点取整且单调不减', () => {
+  const p = schedule(6, {dur: 7, fit: {total: 53}});
+  for (let i = 1; i < p.starts.length; i++) {
+    assert.ok(p.starts[i] >= p.starts[i - 1], '起点须单调不减');
+    assert.ok(Number.isInteger(p.starts[i]));
+  }
+});
diff --git a/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/gallery.tsx b/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/gallery.tsx
new file mode 100644
index 000000000..a71737133
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/gallery.tsx
@@ -0,0 +1,265 @@
+/** MotionGallery——运动层的评审面（独立 Remotion 入口，不经 Root.tsx）。
+ *
+ * 用法（在 video/ 目录，.bin 直调防污染根 workspace）：
+ *   ./node_modules/.bin/remotion still src/motion/gallery.tsx MotionGallery \
+ *       out/motion-gallery.png --frame=30
+ *
+ * 全部模型 × 变体一屏可渲：秒级出图，供 token 校准轮逐格目视。
+ * 色板为本文件内字面量（dev 工具面，不进成片、不读 theme——保持 frozen 跨系列共享）。
+ */
+import React from 'react';
+import {AbsoluteFill, Composition, registerRoot} from 'remotion';
+import {
+  useAccelTravel,
+  useBreathe,
+  useCount,
+  useDim,
+  useDraw,
+  useEnter,
+  useFadeOut,
+  useFlowDash,
+  useImpulse,
+  usePushIn,
+  useReveal,
+  useShake,
+  useStagger,
+  useTravel,
+} from './hooks';
+
+const COLS = 5;
+const CW = 340;
+const CH = 230;
+const GAP = 18;
+
+/** dev 工具面字面量色板（与各集 theme 底座同值但刻意独立声明——不读 theme）。 */
+const C = {
+  bg: '#0E1116',
+  panel: '#171C26',
+  border: '#2A3242',
+  text: '#F2F5FA',
+  dim: '#9AA7B8',
+  core: '#D97757',
+  mech: '#64C4C0',
+  deny: '#EF6461',
+};
+
+/** 单元格壳：定位 + 角标。 */
+const Cell: React.FC<{i: number; name: string; children: React.ReactNode}> = ({i, name, children}) => (
+  <div
+    style={{
+      position: 'absolute',
+      left: 72 + (i % COLS) * (CW + GAP),
+      top: 96 + Math.floor(i / COLS) * (CH + GAP),
+      width: CW,
+      height: CH,
+      background: C.panel,
+      border: `2px solid ${C.border}`,
+      borderRadius: 12,
+    }}
+  >
+    <div
+      style={{
+        position: 'absolute',
+        inset: '28px 0 34px 0',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+      }}
+    >
+      {children}
+    </div>
+    <div style={{position: 'absolute', left: 12, bottom: 8, fontFamily: 'monospace', fontSize: 15, color: C.dim}}>
+      {name}
+    </div>
+  </div>
+);
+
+const Box: React.FC<{color?: string; w?: number; h?: number; style?: React.CSSProperties}> = ({
+  color = C.core,
+  w = 200,
+  h = 80,
+  style,
+}) => <div style={{width: w, height: h, background: C.panel, border: `2px solid ${color}`, borderRadius: 10, ...style}} />;
+
+// ── 每格一个组件：hooks 各归其位（Rules of Hooks 的最简守法形态） ────────
+
+const EnterCell: React.FC<{kind: Parameters<typeof useEnter>[0]}> = ({kind}) => {
+  const e = useEnter(kind, {});
+  return <Box style={{opacity: e.opacity, transform: e.transform}} />;
+};
+
+const StaggerCell: React.FC = () => {
+  const ps = useStagger(5, {dur: 5, fit: {total: 60}});
+  return (
+    <div style={{display: 'flex', gap: 10}}>
+      {ps.map((p, i) => (
+        <div
+          key={i}
+          style={{
+            width: 34,
+            height: 80,
+            background: C.panel,
+            border: `2px solid ${C.mech}`,
+            borderRadius: 8,
+            opacity: p,
+            transform: `translateY(${(1 - p) * 14}px)`,
+          }}
+        />
+      ))}
+    </div>
+  );
+};
+
+const DrawCell: React.FC = () => {
+  const d = useDraw(0, 24);
+  return (
+    <svg width={280} height={110}>
+      <path {...d} d="M10 90 C 90 10, 190 100, 270 20" stroke={C.core} strokeWidth={5} fill="none" strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ImpulseCell: React.FC = () => {
+  const g = useImpulse({dur: 30, peak: 1});
+  return (
+    <div
+      style={{
+        width: 90,
+        height: 90,
+        borderRadius: '50%',
+        background: C.core,
+        opacity: 0.3 + 0.7 * g,
+        boxShadow: `0 0 ${10 + 30 * g}px ${C.core}`,
+      }}
+    />
+  );
+};
+
+const BreatheCell: React.FC = () => {
+  const b = useBreathe({period: 30});
+  return (
+    <svg width={160} height={110}>
+      <circle cx={80} cy={55} r={40} fill="none" stroke={C.mech} strokeWidth={5} opacity={b} />
+    </svg>
+  );
+};
+
+const TravelCell: React.FC = () => {
+  const t = useTravel({cx: 140, cy: 55, r: 42, secPerLap: 3});
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} />
+      <circle cx={t.x} cy={t.y} r={9} fill={C.core} />
+    </svg>
+  );
+};
+
+const AccelCell: React.FC = () => {
+  const t = useAccelTravel({cx: 140, cy: 55, r: 42, durs: [28, 20, 14], at: 4});
+  const heat = `rgb(${217 + Math.round(38 * t.heat)}, ${119 - Math.round(60 * t.heat)}, ${87 - Math.round(20 * t.heat)})`;
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} strokeDasharray="4 6" />
+      <circle cx={t.x} cy={t.y} r={9} fill={heat} />
+    </svg>
+  );
+};
+
+const CountCell: React.FC = () => {
+  const v = useCount({to: 255, dur: 40});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 44, color: C.text, fontVariantNumeric: 'tabular-nums'}}>
+      {Math.round(v)}
+    </div>
+  );
+};
+
+const RevealCell: React.FC = () => {
+  const s = useReveal('while (true) { think(); act(); }', {cps: 14});
+  const blink = useBreathe({period: 16, amp: 0.5, base: 0.5});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 20, color: C.text, whiteSpace: 'nowrap'}}>
+      {s}
+      <span style={{opacity: blink}}>▍</span>
+    </div>
+  );
+};
+
+const PushInCell: React.FC = () => {
+  const t = usePushIn(0, {scale: 0.12});
+  return <Box w={160} h={90} color={C.mech} style={{transform: t}} />;
+};
+
+const DimCell: React.FC = () => {
+  const dim = useDim({at: 40, to: 0.35});
+  return (
+    <div style={{display: 'flex', gap: 12}}>
+      <Box w={64} h={80} style={{opacity: dim}} />
+      <Box w={64} h={80} color={C.core} />
+      <Box w={64} h={80} style={{opacity: dim}} />
+    </div>
+  );
+};
+
+const FlowCell: React.FC = () => {
+  const f = useFlowDash({period: 24});
+  return (
+    <svg width={280} height={60}>
+      <line x1={10} y1={30} x2={270} y2={30} stroke={C.mech} strokeWidth={5} {...f} strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ShakeCell: React.FC = () => {
+  const x = useShake({at: 10, amp: 5, decay: true, dur: 40});
+  return <Box w={150} h={80} color={C.deny} style={{transform: `translateX(${x}px)`}} />;
+};
+
+const FadeCell: React.FC = () => {
+  const op = useFadeOut(90, {frames: 36});
+  return (
+    <div style={{position: 'relative', width: 220, height: 90}}>
+      <Box w={220} h={90} color={C.core} style={{position: 'absolute', inset: 0}} />
+      <div style={{position: 'absolute', inset: 0, background: '#000', opacity: 1 - op}} />
+    </div>
+  );
+};
+
+const CELLS: Array<[string, React.ReactNode]> = [
+  ['enter:fall', <EnterCell kind="fall" />],
+  ['enter:rise', <EnterCell kind="rise" />],
+  ['enter:slideL', <EnterCell kind="slideL" />],
+  ['enter:pop', <EnterCell kind="pop" />],
+  ['enter:flyIn', <EnterCell kind="flyIn" />],
+  ['enter:fade', <EnterCell kind="fade" />],
+  ['stagger×5 fit60', <StaggerCell />],
+  ['draw 24f', <DrawCell />],
+  ['impulse 30f', <ImpulseCell />],
+  ['breathe p30', <BreatheCell />],
+  ['travel 3s/lap', <TravelCell />],
+  ['accelTravel', <AccelCell />],
+  ['count→255', <CountCell />],
+  ['reveal 14cps', <RevealCell />],
+  ['pushIn .12', <PushInCell />],
+  ['dim .35@40', <DimCell />],
+  ['flowDash p24', <FlowCell />],
+  ['shake decay', <ShakeCell />],
+  ['fadeOut 36f', <FadeCell />],
+];
+
+const MotionGallery: React.FC = () => (
+  <AbsoluteFill style={{background: C.bg}}>
+    <div style={{position: 'absolute', left: 72, top: 44, fontFamily: 'monospace', fontSize: 24, color: C.text}}>
+      MotionGallery · 30fps · 120f
+    </div>
+    {CELLS.map(([name, node], i) => (
+      <Cell key={name} i={i} name={name}>
+        {node}
+      </Cell>
+    ))}
+  </AbsoluteFill>
+);
+
+registerRoot(() => (
+  <Composition id="MotionGallery" component={MotionGallery} width={1920} height={1080} fps={30} durationInFrames={120} defaultProps={{}} />
+));
diff --git a/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/hooks.ts b/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/hooks.ts
new file mode 100644
index 000000000..f87b8a129
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/hooks.ts
@@ -0,0 +1,303 @@
+/** 运动模型（hooks）——分镜「动效」列动词到帧数学的唯一映射。
+ *
+ * 设计约束（违反任何一条即失去本层存在意义）：
+ * 1. hooks 返回数值 / CSS 片段，不渲染 DOM——FadeUp 式包装组件打不进 svg/<g>/
+ *    absolute 布局，是「组件存在却零调用」的实测根因；数值可落进任意 JSX。
+ * 2. 弹簧一律吃局部帧（frame - at）：spring() 每次调用从第 0 帧重模拟，喂全局帧
+ *    会让长片末帧每个 spring 跑两万余次迭代。
+ * 3. effects（不透明度/颜色）永不吃弹簧——一律时长+缓动（tokens 的二分不变量）。
+ * 4. 不读 theme：颜色一律经参数传入（frozen 跨系列共享的前提）。
+ * 5. `at` 锚点一律来自句边界（rel(beat, '句id')），禁写死帧数。
+ */
+import {Easing, interpolate, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {
+  DUR,
+  EASING_CP,
+  SPRING,
+  clampRiseDist,
+  type DurToken,
+  type EasingToken,
+  type SpringPreset,
+} from './tokens';
+import {progress, revealCharCount} from './window';
+import {schedule, type ScheduleOpts} from './schedule';
+
+/** 帧数解析：token 或直接帧数；缺省用 def。 */
+export const frames = (d: number | DurToken | undefined, def: number): number =>
+  d === undefined ? def : typeof d === 'number' ? d : DUR[d];
+
+/** 缓动令牌 → Remotion 缓动函数（linear 直通）。 */
+export const easeF = (t: EasingToken): ((x: number) => number) =>
+  t === 'linear'
+    ? Easing.linear
+    : Easing.bezier(
+        ...(EASING_CP[t] as [number, number, number, number]),
+      );
+
+/** 缓动后的 0..1 进度（各模型共用的原子）。 */
+const eased = (
+  frame: number,
+  at: number,
+  dur: number,
+  e: EasingToken,
+): number => interpolate(progress(frame, at, dur), [0, 1], [0, 1], {easing: easeF(e)});
+
+/** 缓动数值进度——「clamped 0→1 手写 interpolate」惯用形的统一替身：
+ *  时机值走 token，缓动默认 standard（线性原版会被这一档替换——质量提升点之一）。 */
+export function useProgress(
+  at: number,
+  dur: number | DurToken = DUR.f5,
+  easing: EasingToken = 'standard',
+): number {
+  const frame = useCurrentFrame();
+  return eased(frame, at, frames(dur, DUR.f5), easing);
+}
+
+/** 弹簧数值进度（驱动几何量/位移；effects 通道用 useProgress——tokens 二分不变量）。
+ *  局部帧 + 可选 durationInFrames 截停（防窗口外余振；缺省不设上限，与既有手写等价）。 */
+export function useSpring(
+  preset: SpringPreset,
+  o: {at?: number; dur?: number | DurToken} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const cfg: Parameters<typeof spring>[0] = {
+    frame: frame - (o.at ?? 0),
+    fps,
+    config: SPRING[preset],
+  };
+  if (o.dur !== undefined) {
+    cfg.durationInFrames = frames(o.dur, DUR.f5);
+  }
+  return spring(cfg);
+}
+
+// ── 入场（enter：落下/上浮/滑入/弹出/飞入/淡入） ────────────────────────
+
+export type EnterKind = 'fall' | 'rise' | 'slideL' | 'slideR' | 'pop' | 'flyIn' | 'fade';
+export type EnterOpts = {
+  /** 句边界锚（局部帧）。 */
+  at?: number;
+  dur?: number | DurToken;
+  easing?: EasingToken;
+  /** 空间通道用弹簧（位移类才有意义；fade/pop 无效）。 */
+  springPreset?: SpringPreset;
+  /** 位移像素（fall/rise/slide*；缺省 30）。 */
+  dist?: number;
+  /** rise 专用：落位态底边 y——行程经 clampRiseDist 钳进字幕安全带之上。 */
+  restBottom?: number;
+};
+export type EnterStyle = {opacity: number; transform: string};
+
+export function useEnter(kind: EnterKind, o: EnterOpts = {}): EnterStyle {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const at = o.at ?? 0;
+  const dur = frames(o.dur, DUR.f4);
+  let dist = o.dist ?? 30;
+  if (kind === 'rise' && o.restBottom !== undefined) {
+    dist = clampRiseDist(dist, o.restBottom);
+  }
+  // effects 通道：纯缓动、略快于空间通道（元素先「看见」再「落位」）
+  const opacity = progress(frame, at, Math.max(2, Math.round(dur * 0.8)));
+  // spatial 通道：可选弹簧（局部帧 + durationInFrames 截停，防窗口外余振）
+  const p = o.springPreset
+    ? spring({
+        frame: frame - at,
+        fps,
+        config: SPRING[o.springPreset],
+        durationInFrames: dur,
+      })
+    : eased(frame, at, dur, o.easing ?? 'standard');
+  const inv = 1 - p;
+  const t: string[] = [];
+  if (kind === 'fall') t.push(`translateY(${-inv * dist}px)`);
+  if (kind === 'rise') t.push(`translateY(${inv * dist}px)`);
+  if (kind === 'slideL') t.push(`translateX(${-inv * dist}px)`);
+  if (kind === 'slideR') t.push(`translateX(${inv * dist}px)`);
+  if (kind === 'pop') t.push(`scale(${0.9 + 0.1 * p})`);
+  if (kind === 'flyIn') t.push(`scale(${0.6 + 0.4 * p})`);
+  return {opacity, transform: t.length ? t.join(' ') : 'none'};
+}
+
+// ── 序列错峰（stagger：依次/逐行/逐条/逐格） ───────────────────────────
+
+export type StaggerOpts = ScheduleOpts & {at?: number; easing?: EasingToken};
+
+/** 返回 n 个 0..1 进度——第 i 项随编排依次入场。 */
+export function useStagger(n: number, o: StaggerOpts = {}): number[] {
+  const frame = useCurrentFrame();
+  const {at = 0, easing = 'standard'} = o;
+  const plan = schedule(n, o);
+  return plan.starts.map((s) => eased(frame, at + s, plan.dur, easing));
+}
+
+// ── 描线（draw：红线三由构造保证——只产 pathLength 归一化三元组） ────────
+
+export type DrawProps = {pathLength: 1; strokeDasharray: 1; strokeDashoffset: number};
+
+export function useDraw(at: number, dur: number | DurToken = DUR.f5): DrawProps {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(dur, DUR.f5), 'decelerate');
+  return {pathLength: 1, strokeDasharray: 1, strokeDashoffset: 1 - p};
+}
+
+// ── 脉冲 / 呼吸（glow 语法：impulse=一次性强调，breathe=持续辉光） ───────
+
+/** 一次性冲击：sin(πp) 包络，起于 0 归于 0，峰值 peak。 */
+export function useImpulse(o: {at?: number; dur?: number | DurToken; peak?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const p = progress(frame, o.at ?? 0, frames(o.dur, DUR.f5));
+  return Math.sin(Math.PI * p) * (o.peak ?? 1);
+}
+
+/** 持续呼吸（原 0.55+0.45·sin(frame/K) 散写的收敛；period 帧一周期——注意与
+ *  原除数 K 的换算 period = 2πK，如 sin(frame/26) → period 163）。offset 为相位
+ *  平移（错峰辉光的 per-index 形态）。 */
+export function useBreathe(
+  o: {period?: number; amp?: number; base?: number; offset?: number} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {amp = 0.45, base = 0.55, period = 26, offset = 0} = o;
+  return base + amp * Math.sin((2 * Math.PI * (frame - offset)) / period);
+}
+
+// ── 巡游（travel：环形为主；absorb 原 useRingDot 与加速绕行累加器克隆） ──
+
+export type TravelPos = {x: number; y: number; angle: number};
+
+/** 匀速环形巡游（angle 单位度，-90 = 12 点方向起）。 */
+export function useTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  secPerLap?: number;
+  offset?: number;
+}): TravelPos {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const lap = (frame / (fps * (o.secPerLap ?? 2.5)) + (o.offset ?? 0)) % 1;
+  const a = -90 + lap * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), angle: a};
+}
+
+/** 加速绕行：逐圈时长 durs[]（如 [40,30,22,16]），跑完全部圈后冻结在终点。
+ *  heat 0..1 随圈数推进（「失控感」的配色偏移系数）。 */
+export function useAccelTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  durs: number[];
+  at?: number;
+  heatPerLap?: number;
+}): {x: number; y: number; heat: number} {
+  const frame = useCurrentFrame();
+  let t = Math.max(0, frame - (o.at ?? 0));
+  let lap = 0;
+  while (lap < o.durs.length && t >= o.durs[lap]) {
+    t -= o.durs[lap];
+    lap += 1;
+  }
+  const within = lap >= o.durs.length ? 1 : t / o.durs[lap];
+  const heat = Math.min(1, lap / (o.heatPerLap ?? o.durs.length));
+  const a = -90 + within * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), heat};
+}
+
+// ── 计数 / 水位（meter 语法；显示层自行 Math.round / toFixed） ──────────
+
+export function useCount(o: {
+  from?: number;
+  to: number;
+  at?: number;
+  dur?: number | DurToken;
+  ease?: EasingToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {from = 0, to, at = 0} = o;
+  const p = eased(frame, at, frames(o.dur, DUR.f6), o.ease ?? 'standard');
+  return from + (to - from) * p;
+}
+
+// ── 打字机 / 逐字流出（type；Terminal 之外的泛化） ──────────────────────
+
+export function useReveal(
+  text: string,
+  o: {at?: number; cps?: number; framesPerChar?: number} = {},
+): string {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const elapsed = Math.max(0, frame - (o.at ?? 0));
+  const n = revealCharCount(elapsed, fps, o.cps ?? 12, o.framesPerChar);
+  return text.slice(0, Math.min(text.length, n));
+}
+
+// ── 镜头推近（pushIn 语法：beat 切换的镜头语言，替代纯淡入） ────────────
+
+export function usePushIn(at: number, o: {scale?: number; dur?: number | DurToken} = {}): string {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(o.dur, DUR.f5), 'decelerate');
+  return `scale(${1 + (o.scale ?? 0.06) * p})`;
+}
+
+// ── 压暗 / 提亮（emphasis 反向：让主体从群像中浮出） ─────────────────────
+
+/** 返回目标透明度系数（1 = 原；to 0.4 即压暗到 40%）。 */
+export function useDim(o: {at: number; to?: number; dur?: number | DurToken}): number {
+  const frame = useCurrentFrame();
+  const p = eased(frame, o.at, frames(o.dur, DUR.f4), 'standard');
+  return 1 + ((o.to ?? 0.4) - 1) * p;
+}
+
+// ── 流光（flow 语法：连线上的行进虚线） ─────────────────────────────────
+
+/** 返回可直接展开到 <line>/<path> 的描边属性（像素 dasharray——与 draw 的
+ *  pathLength 归一化描线是两个正交特性，勿混用于同一元素：红线三）。 */
+export function useFlowDash(o: {
+  dash?: number;
+  gap?: number;
+  /** 帧速率：每 period 帧行进一个 dash+gap 周期。 */
+  period?: number;
+}): {strokeDasharray: string; strokeDashoffset: number} {
+  const frame = useCurrentFrame();
+  const {dash = 10, gap = 14, period = 40} = o;
+  return {
+    strokeDasharray: `${dash} ${gap}`,
+    strokeDashoffset: -(frame * (dash + gap)) / period,
+  };
+}
+
+// ── 抖动（错误/故障语义；收敛 P2/P3 两处克隆） ──────────────────────────
+
+/** 返回 translateX 像素值。active 缺省 true；decay=true 时按 dur 衰减归零。 */
+export function useShake(o: {
+  at: number;
+  active?: boolean;
+  amp?: number;
+  /** 相位分母（原手写 /1.6、/2.2 的口径）。 */
+  freq?: number;
+  decay?: boolean;
+  dur?: number | DurToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {amp = 3, freq = 1.6} = o;
+  const t = frame - o.at;
+  if (o.active === false || t < 0) {
+    return 0;
+  }
+  if (o.decay) {
+    const env = 1 - progress(frame, o.at, frames(o.dur, DUR.f5));
+    return amp * env * Math.sin(t / freq);
+  }
+  return amp * Math.sin(t / freq);
+}
+
+// ── 片尾渐黑（红线四：从 beat 总时长推导，勿用末句时长） ────────────────
+
+export function useFadeOut(durationInFrames: number, o: {frames?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const f = o.frames ?? 36; // 1.2s
+  return 1 - progress(frame, durationInFrames - f, f);
+}
diff --git a/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/index.ts b/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/index.ts
new file mode 100644
index 000000000..97fd22a5c
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/index.ts
@@ -0,0 +1,5 @@
+/** 运动层门面——场景代码统一 `import {...} from '../motion'`。 */
+export * from './tokens';
+export * from './window';
+export * from './schedule';
+export * from './hooks';
diff --git a/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/schedule.ts b/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/schedule.ts
new file mode 100644
index 000000000..5703e3315
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/schedule.ts
@@ -0,0 +1,65 @@
+/** 错峰编排（stagger）纯函数——收敛手写 `frame - i*N`（跨 8 集约 356 处、
+ *  步长 K∈{2,3,4,5,6,8,10} 任意取值、无节奏标尺）。
+ *
+ * 三种模式（互斥，参数即文档）：
+ * - stride：固定步长（与旧手写行为一致——迁移期的保守选项）；
+ * - lag：Manim LaggedStart 语义 start[i] = i·dur·lagRatio（0 = 同刻齐动，1 = 首尾相接）；
+ * - fit：n 个子项恰好装进窗口 total（末项恰在窗口末完成——「随句推进」的首选）。
+ *
+ * 钳制优先级（motion.test.ts 钉死，自左向右）：不外溢窗口 > 最小步长 > 子项时长。
+ * 窗口属于 beat 时间轴，外溢会踩进下一 beat；装不下时先缩子项时长，连 1 帧
+ * 子项都无法错开时显式抛错，不返回违反 fit 契约的计划。
+ */
+export type ScheduleOpts = {
+  /** 子项时长（帧；缺省 DUR.f3=5——「快速子项」档）。 */
+  dur?: number;
+  /** 模式一：固定步长。 */
+  stride?: number;
+  /** 模式二：lag 比率（Manim lag_ratio）。 */
+  lag?: number;
+  /** 模式三：拟装入的窗口总长（帧）。 */
+  fit?: {total: number};
+  /** 相邻起点期望下限，默认 2 帧；fit 紧窗时可按优先级退至 1 帧。 */
+  minStride?: number;
+  /** 子项时长期望下限，默认 3 帧；fit 为守住窗口可退至 1 帧。 */
+  minDur?: number;
+};
+export type Schedule = {starts: number[]; dur: number};
+
+export function schedule(n: number, o: ScheduleOpts): Schedule {
+  const minStride = o.minStride ?? 2;
+  const minDur = o.minDur ?? 3;
+  const modes = [o.stride !== undefined, o.lag !== undefined, o.fit !== undefined].filter(
+    Boolean,
+  ).length;
+  if (modes > 1) {
+    throw new Error('schedule: stride / lag / fit 三选一');
+  }
+  let dur = Math.max(minDur, o.dur ?? 5);
+  if (n <= 0) {
+    return {starts: [], dur};
+  }
+  let stride: number;
+  if (o.fit) {
+    const total = Math.max(1, o.fit.total);
+    if (n > 1 && total < n) {
+      throw new Error(
+        `schedule: fit.total=${total} 无法容纳 ${n} 个至少 1 帧且起点间隔至少 1 帧的子项`,
+      );
+    }
+    dur = Math.min(dur, total);
+    stride = n === 1 ? 0 : (total - dur) / (n - 1);
+    const targetStride = Math.max(1, minStride);
+    if (n > 1 && stride < targetStride) {
+      // 先缩时长争取期望步长；仍不足时牺牲步长，但至少保留 1 帧先后。
+      dur = Math.max(1, Math.min(dur, total - targetStride * (n - 1)));
+      stride = (total - dur) / (n - 1);
+    }
+  } else if (o.lag !== undefined) {
+    stride = dur * o.lag;
+  } else {
+    stride = o.stride ?? minStride;
+  }
+  stride = Math.max(n === 1 || o.lag === 0 ? 0 : 1, stride);
+  return {starts: Array.from({length: n}, (_, i) => Math.round(i * stride)), dur};
+}
diff --git a/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/tokens.ts b/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/tokens.ts
new file mode 100644
index 000000000..457448260
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/tokens.ts
@@ -0,0 +1,87 @@
+/** 运动令牌——时长标尺 / 缓动曲线 / 弹簧手感 的单一事实源。
+ *
+ * 只放纯数据与纯函数：不 import remotion、不读 theme（颜色一律经参数注入）——
+ * 这是本层能以 frozen 档跨两个系列共享的前提（两系列 theme token 名已分叉：
+ * CC 用 core/mech/deny、SE 用 danger），判据同 test_chrome_motifs_only_read_base_theme_tokens。
+ *
+ * 取值依据（勿凭感觉改；改前先在本集校准轮逐幕目视复测，依据写回此处注释）：
+ * - 时长六档取 IBM Carbon DTCG（70/110/150/240/400/700ms）@30fps 四舍五入。
+ *   弃 Material 十六档：30fps 量化下其 15 个相邻对里 6 对落进同一帧数（伪选择）。
+ * - 缓动控制点取 Material 3 标准三件；曲线本体在 hooks.ts 经 Remotion Easing.bezier 求值。
+ * - 弹簧预设锚定本仓实测手感：settle=200 即既有 9/10 调用点的惯用值（延续成片观感），
+ *   snap=12 来自 P4「插头咬合」的过冲；ζ 与过冲峰值的关系由 motion.test.ts 用
+ *   Mp = exp(-πζ/√(1-ζ²)) 钉死。
+ * - effects 不变量：不透明度/颜色永不过冲——effects 类动画一律时长+缓动，
+ *   弹簧只用于空间位移（M3 spatial/effects 二分的落地）。
+ */
+
+/** 时长标尺（帧 @30fps）。叙事节拍（4–8s）不用此表——那是 window/schedule 的职责。 */
+export const DUR = {
+  /** 70ms：微反馈（辉光起点、光标） */
+  f1: 2,
+  /** 110ms：快速子项（列表错峰的单项时长） */
+  f2: 3,
+  /** 150ms：标准入场 */
+  f3: 5,
+  /** 200ms：强调入场 */
+  f4: 7,
+  /** 400ms：大位移 / 镜头推近 / 描线 */
+  f5: 12,
+  /** 700ms：幕级大动作（少用） */
+  f6: 21,
+} as const;
+export type DurToken = keyof typeof DUR;
+
+/** 缓动令牌。 */
+export type EasingToken = 'standard' | 'decelerate' | 'accelerate' | 'linear';
+
+/** 贝塞尔控制点（x1,y1,x2,y2）；linear 无控制点。 */
+export const EASING_CP: Record<
+  Exclude<EasingToken, 'linear'>,
+  readonly [number, number, number, number]
+> = {
+  // M3 standard：入场默认
+  standard: [0.2, 0, 0, 1],
+  // M3 decelerate：强减速（大位移入场、镜头推近）
+  decelerate: [0.05, 0.7, 0.1, 1],
+  // M3 accelerate：出场加速
+  accelerate: [0.3, 0, 0.8, 0.15],
+};
+
+/** 弹簧预设（直传 Remotion spring config；ζ = c/(2√(k·m))）。 */
+export type SpringPreset = 'settle' | 'settleSoft' | 'snap';
+export const SPRING: Record<SpringPreset, {damping: number; stiffness: number; mass: number}> = {
+  // ζ≈10：无过冲平滑滑入——本仓主流手感（既有场景 9/10 处 damping 200）
+  settle: {damping: 200, stiffness: 100, mass: 1},
+  // ζ≈8.5：更绵一点（P0/P1 既有 180/170 档的收敛）
+  settleSoft: {damping: 170, stiffness: 100, mass: 1},
+  // ζ≈0.6：轻微过冲（咬合/弹入——原 P4 damping 12）
+  snap: {damping: 12, stiffness: 100, mass: 1},
+};
+
+/** 阻尼比 ζ。设计系统文档普遍给 ζ（无量纲），Remotion 取阻尼系数 c——直抄会得
+ *  ζ≈0.02 的暴力弹跳且能通过渲染体检，这是迁移期最高风险项（单测钉死）。 */
+export const dampingRatio = (s: {
+  damping: number;
+  stiffness: number;
+  mass: number;
+}): number => s.damping / (2 * Math.sqrt(s.stiffness * s.mass));
+
+/** 欠阻尼弹簧的峰值位置（1 = 恰好到终点不过冲；ζ ≥ 1 恒 1）。
+ *  Mp = exp(-πζ/√(1-ζ²)) 是超出终点的幅度，峰值 = 1 + Mp。 */
+export const overshootPeak = (zeta: number): number =>
+  zeta >= 1 ? 1 : 1 + Math.exp((-Math.PI * zeta) / Math.sqrt(1 - zeta * zeta));
+
+/** 出场快于入场的系数（MDC 实测 400ms 入 / 150ms 出 ≈ 0.375，取 0.4 禁手填）。 */
+export const EXIT_FACTOR = 0.4;
+
+/** 字幕安全带上沿：1080 - qa_frames.SUBTITLE_BAND_PX(160)，与体检口径同源。 */
+export const SAFE_TOP_Y = 920;
+
+/** 自下方入场的行程安全钳制：落位态底边 restBottom 之上才是可用的进场空间。
+ *  ISSUE-170 的手工逐卡反算收敛于此——该缺陷类从「评审抽帧抓」变「构造不可能」。 */
+export const clampRiseDist = (
+  dist: number,
+  restBottom: number,
+  safeTop: number = SAFE_TOP_Y,
+): number => Math.max(0, Math.min(dist, safeTop - restBottom));
diff --git a/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/window.ts b/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/window.ts
new file mode 100644
index 000000000..69bd59c7a
--- /dev/null
+++ b/apps/negentropy-influence/episodes/claude-code-planning-video/video/src/motion/window.ts
@@ -0,0 +1,43 @@
+/** 运动窗口纯函数——「父级持有绝对时间，子动画只是父进度上的窗口」。
+ *
+ * 这是 audio-first 时序与可复用运动模型兼容的核心机制：beat 的绝对帧来自
+ * beatWindow()（数据源是 TTS 实测 manifest），子动画不写死帧数、只声明自己在
+ * beat 进度上的 [start, end] 窗口 ⇒ 旁白实测时长变化时全部窗口自动重定时，
+ * 「写死帧数与口播脱钩」缺陷类（skills/08 实录）由构造消灭。
+ *
+ * 语义借 MDC TransitionUtils.lerp(startFraction, endFraction)：窗外钳制端点。
+ * 本模块零依赖（不 import remotion / theme）——frozen 跨系列共享与 node 单测的前提。
+ */
+
+/** 钳制到 [0,1]——一切进度的唯一出口，防负值/超 1 渗进 transform。 */
+export const clamp01 = (x: number): number => (x < 0 ? 0 : x > 1 ? 1 : x);
+
+/** 子动画窗口：父进度 p(0..1) 在 [s,e] 片段上的局部进度。 */
+export const win = (p: number, w: readonly [number, number]): number =>
+  clamp01((p - w[0]) / (w[1] - w[0]));
+
+/** beat 进度：局部帧 → 该 beat 的 0..1 进度。 */
+export const beatProgress = (
+  frame: number,
+  from: number,
+  durationInFrames: number,
+): number => clamp01((frame - from) / Math.max(1, durationInFrames));
+
+/** 帧域进度：[at, at+dur] 上的 0..1（dur ≤ 0 视作 1，防除零）。 */
+export const progress = (frame: number, at: number, dur: number): number =>
+  clamp01((frame - at) / Math.max(1, dur));
+
+/** 已过帧数 → 可见字符数；cps 随实际 fps 换算，显式帧间隔不受 fps 影响。 */
+export const revealCharCount = (
+  elapsedFrames: number,
+  fps: number,
+  cps: number,
+  framesPerChar?: number,
+): number => {
+  const elapsed = Math.max(0, elapsedFrames);
+  const count =
+    framesPerChar === undefined
+      ? Math.floor((elapsed / fps) * cps)
+      : Math.floor(elapsed / Math.max(1, framesPerChar));
+  return Math.max(0, count);
+};
diff --git a/apps/negentropy-influence/episodes/experience-era-agents-video/video/package.json b/apps/negentropy-influence/episodes/experience-era-agents-video/video/package.json
index 36c1d75d9..50d5e8bb9 100644
--- a/apps/negentropy-influence/episodes/experience-era-agents-video/video/package.json
+++ b/apps/negentropy-influence/episodes/experience-era-agents-video/video/package.json
@@ -19,10 +19,5 @@
   "devDependencies": {
     "@types/react": "^19.0.0",
     "typescript": "^5.6.0"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild"
-    ]
   }
 }
diff --git a/apps/negentropy-influence/episodes/experience-era-agents-video/video/pnpm-workspace.yaml b/apps/negentropy-influence/episodes/experience-era-agents-video/video/pnpm-workspace.yaml
index f2686ac7d..add822dbe 100644
--- a/apps/negentropy-influence/episodes/experience-era-agents-video/video/pnpm-workspace.yaml
+++ b/apps/negentropy-influence/episodes/experience-era-agents-video/video/pnpm-workspace.yaml
@@ -1,4 +1,9 @@
-# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的唯一理由。
+# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的首要理由。
 # pnpm 12 起仅靠 `--ignore-workspace` 不够：pnpm 仍会沿 packageManager 向上锚定到仓库根，
 # 用本工程的解析结果覆写根 pnpm-lock.yaml（overrides 全丢）且当场不报错。见 ISSUE-175。
 packages: []
+# pnpm 12 的构建脚本许可（package.json 的 pnpm.onlyBuiltDependencies 已不被读取，
+# 静默忽略会使安装以 ERR_PNPM_IGNORED_BUILDS 中断、node_modules 半残）。键名与取值
+# 与 `pnpm approve-builds esbuild --yes` 实际写入的形态逐字一致——勿改回旧键名。
+allowBuilds:
+  esbuild: true
diff --git a/apps/negentropy-influence/episodes/experience-era-agents-video/video/scripts/motion.test.ts b/apps/negentropy-influence/episodes/experience-era-agents-video/video/scripts/motion.test.ts
new file mode 100644
index 000000000..5e29cab52
--- /dev/null
+++ b/apps/negentropy-influence/episodes/experience-era-agents-video/video/scripts/motion.test.ts
@@ -0,0 +1,141 @@
+/**
+ * 运动层纯函数单测——`node --test scripts/motion.test.ts`（Node ≥ 23.6 原生跑 TS）。
+ *
+ * 刻意放在 video/ 而非 src/：tsconfig include 只有 src（frozen，不为测试改动），
+ * 而本文件 import 需带 .ts 后缀（Node ESM 解析规则）——tsc 若收编会因
+ * allowImportingTsExtensions 未开而报错。src/ 的类型覆盖由 tsc --noEmit 全量保证，
+ * 本文件只测纯函数行为，不做类型承重。
+ *
+ * 只 import 纯模块（tokens/window/schedule——零 remotion/react 依赖）：
+ * hooks 是它们的薄包装，行为由 MotionGallery 目视 + 场景抽帧覆盖。
+ */
+import {strict as assert} from 'node:assert';
+import test from 'node:test';
+
+import {DUR, EASING_CP, EXIT_FACTOR, SAFE_TOP_Y, SPRING, clampRiseDist, dampingRatio, overshootPeak} from '../src/motion/tokens.ts';
+import {beatProgress, clamp01, progress, revealCharCount, win} from '../src/motion/window.ts';
+import {schedule} from '../src/motion/schedule.ts';
+
+// ── tokens ────────────────────────────────────────────────────────────
+
+test('时长标尺在 30fps 下相邻档可辨（≥1 帧差）', () => {
+  const v = Object.values(DUR) as number[];
+  for (let i = 1; i < v.length; i++) {
+    assert.ok(v[i] - v[i - 1] >= 1, `第 ${i} 档与前一档同帧数（伪选择）`);
+  }
+  assert.ok(v.length === 6);
+});
+
+test('ζ→过冲换算钉死：snap 轻过冲、settle 零过冲（直抄 dampingRatio 的反例护栏）', () => {
+  const zSnap = dampingRatio(SPRING.snap);
+  const zSettle = dampingRatio(SPRING.settle);
+  assert.ok(zSnap > 0.4 && zSnap < 0.9, `snap ζ=${zSnap}`);
+  // Mp = exp(-πζ/√(1-ζ²)) 是超出幅度；峰值 = 1 + Mp（ζ=0.6 → 峰值 ≈1.095）
+  assert.ok(overshootPeak(zSnap) > 1.02 && overshootPeak(zSnap) < 1.2, `snap 峰值 ${overshootPeak(zSnap)}`);
+  assert.ok(zSettle > 1, 'settle 须过阻尼');
+  assert.equal(overshootPeak(zSettle), 1);
+  // 反例：把设计系统的 ζ 当 damping 直填（0.8）→ ζ≈0.04、峰值≈1.88 暴力弹跳
+  const wrong = dampingRatio({damping: 0.8, stiffness: 100, mass: 1});
+  assert.ok(overshootPeak(wrong) > 1.8, `直抄 ζ 的峰值=${overshootPeak(wrong)}，必须被此断言抓住`);
+});
+
+test('缓动控制点合法（CSS 规则 x∈[0,1]，且 x(t) 数值单调——可作函数求值）', () => {
+  for (const cp of Object.values(EASING_CP)) {
+    const [x1, , x2] = cp;
+    assert.ok(x1 >= 0 && x1 <= 1 && x2 >= 0 && x2 <= 1, `x 越界：${cp}`);
+    // x1<x2 是充分不必要（M3 standard (0.2,0,0,1) 的 x2<x1 仍单调）——判据用导数采样
+    for (let i = 0; i <= 50; i++) {
+      const t = i / 50;
+      const dx =
+        3 * (1 - t) ** 2 * x1 + 6 * (1 - t) * t * (x2 - x1) + 3 * t * t * (1 - x2);
+      assert.ok(dx > -1e-9, `x(t) 非单调 @t=${t}：${cp}`);
+    }
+  }
+});
+
+test('出场快于入场系数与安全带口径为常量', () => {
+  assert.equal(EXIT_FACTOR, 0.4);
+  assert.equal(SAFE_TOP_Y, 920);
+});
+
+test('clampRiseDist：自下方入场行程不探进字幕安全带', () => {
+  assert.equal(clampRiseDist(120, 836), 84, 'ISSUE-170 实测几何：rest 836 → 行程封顶 84');
+  assert.equal(clampRiseDist(40, 836), 40, '未超限不动');
+  assert.equal(clampRiseDist(120, 960), 0, '落位已在安全带内 → 零行程（退化但安全）');
+});
+
+// ── window ────────────────────────────────────────────────────────────
+
+test('clamp01 / progress / win 的钳制语义', () => {
+  assert.equal(clamp01(-1), 0);
+  assert.equal(clamp01(2), 1);
+  assert.equal(progress(10, 10, 10), 0, '起点为 0');
+  assert.equal(progress(20, 10, 10), 1, '终点为 1');
+  assert.equal(progress(5, 10, 10), 0, '窗外前钳 0');
+  assert.equal(progress(99, 10, 10), 1, '窗外后钳 1');
+  assert.equal(win(0.5, [0.25, 0.75]), 0.5);
+  assert.equal(win(0.1, [0.25, 0.75]), 0);
+  assert.equal(win(0.9, [0.25, 0.75]), 1);
+  assert.equal(beatProgress(0, -30, 90), 1 / 3);
+});
+
+test('逐字揭示：cps 按实际 fps 换算并向下取整，framesPerChar 保持固定帧间隔', () => {
+  assert.equal(revealCharCount(29, 60, 12), 5);
+  assert.equal(revealCharCount(30, 60, 12), 6);
+  assert.equal(revealCharCount(30, 24, 12, 3), 10);
+  assert.equal(revealCharCount(30, 120, 12, 3), 10);
+});
+
+// ── schedule ──────────────────────────────────────────────────────────
+
+test('fit 模式：末项恰在窗口末完成、不外溢', () => {
+  const p = schedule(5, {dur: 10, fit: {total: 90}});
+  const last = p.starts[4] + p.dur;
+  assert.ok(last <= 90 + 1, `末项 ${last} 外溢`);
+  assert.ok(last >= 89, `末项 ${last} 未到窗口末`);
+});
+
+test('fit 装不下时缩子项时长，不外溢窗口（优先级：不外溢 > 最小步长 > 子项时长）', () => {
+  // total 30 时 (30-12)/7≈2.57 ≥ minStride=2 仍装得下；压到 24 才触发缩时长
+  const p = schedule(8, {dur: 12, fit: {total: 24}});
+  const last = p.starts[7] + p.dur;
+  assert.ok(last <= 24, `末项 ${last} 外溢`);
+  assert.ok(p.dur >= 3, '子项时长跌破下限');
+  assert.ok(p.dur < 12, '装不下却未缩子项时长');
+});
+
+test('fit 窗口连 1 帧子项也容不下时显式拒绝，不返回外溢计划', () => {
+  assert.throws(() => schedule(8, {dur: 12, fit: {total: 5}}), /fit\.total=5.*8/);
+});
+
+test('fit 可行极限先牺牲子项时长，仍完整落在窗口内', () => {
+  const p = schedule(8, {dur: 12, fit: {total: 8}});
+  assert.equal(p.dur, 1);
+  assert.equal(p.starts[7] + p.dur, 8);
+});
+
+test('lag 模式：Manim 语义 start[i] = i·dur·lag', () => {
+  const p = schedule(3, {dur: 10, lag: 0.5});
+  assert.deepEqual(p.starts, [0, 5, 10]);
+  assert.deepEqual(schedule(3, {dur: 10, lag: 0}).starts, [0, 0, 0], 'lag=0 须同刻齐动');
+});
+
+test('stride 模式与三选一守卫', () => {
+  assert.deepEqual(schedule(3, {dur: 5, stride: 4}).starts, [0, 4, 8]);
+  assert.throws(() => schedule(3, {dur: 5, stride: 4, lag: 1}));
+  assert.throws(() => schedule(3, {dur: 5, lag: 1, fit: {total: 40}}));
+});
+
+test('最小步长与空集', () => {
+  assert.deepEqual(schedule(0, {dur: 5, stride: 4}), {starts: [], dur: 5});
+  const p = schedule(2, {dur: 5, stride: 0}); // 非法步长 → 抬到下限
+  assert.ok(p.starts[1] - p.starts[0] >= 1);
+});
+
+test('起点取整且单调不减', () => {
+  const p = schedule(6, {dur: 7, fit: {total: 53}});
+  for (let i = 1; i < p.starts.length; i++) {
+    assert.ok(p.starts[i] >= p.starts[i - 1], '起点须单调不减');
+    assert.ok(Number.isInteger(p.starts[i]));
+  }
+});
diff --git a/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/gallery.tsx b/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/gallery.tsx
new file mode 100644
index 000000000..a71737133
--- /dev/null
+++ b/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/gallery.tsx
@@ -0,0 +1,265 @@
+/** MotionGallery——运动层的评审面（独立 Remotion 入口，不经 Root.tsx）。
+ *
+ * 用法（在 video/ 目录，.bin 直调防污染根 workspace）：
+ *   ./node_modules/.bin/remotion still src/motion/gallery.tsx MotionGallery \
+ *       out/motion-gallery.png --frame=30
+ *
+ * 全部模型 × 变体一屏可渲：秒级出图，供 token 校准轮逐格目视。
+ * 色板为本文件内字面量（dev 工具面，不进成片、不读 theme——保持 frozen 跨系列共享）。
+ */
+import React from 'react';
+import {AbsoluteFill, Composition, registerRoot} from 'remotion';
+import {
+  useAccelTravel,
+  useBreathe,
+  useCount,
+  useDim,
+  useDraw,
+  useEnter,
+  useFadeOut,
+  useFlowDash,
+  useImpulse,
+  usePushIn,
+  useReveal,
+  useShake,
+  useStagger,
+  useTravel,
+} from './hooks';
+
+const COLS = 5;
+const CW = 340;
+const CH = 230;
+const GAP = 18;
+
+/** dev 工具面字面量色板（与各集 theme 底座同值但刻意独立声明——不读 theme）。 */
+const C = {
+  bg: '#0E1116',
+  panel: '#171C26',
+  border: '#2A3242',
+  text: '#F2F5FA',
+  dim: '#9AA7B8',
+  core: '#D97757',
+  mech: '#64C4C0',
+  deny: '#EF6461',
+};
+
+/** 单元格壳：定位 + 角标。 */
+const Cell: React.FC<{i: number; name: string; children: React.ReactNode}> = ({i, name, children}) => (
+  <div
+    style={{
+      position: 'absolute',
+      left: 72 + (i % COLS) * (CW + GAP),
+      top: 96 + Math.floor(i / COLS) * (CH + GAP),
+      width: CW,
+      height: CH,
+      background: C.panel,
+      border: `2px solid ${C.border}`,
+      borderRadius: 12,
+    }}
+  >
+    <div
+      style={{
+        position: 'absolute',
+        inset: '28px 0 34px 0',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+      }}
+    >
+      {children}
+    </div>
+    <div style={{position: 'absolute', left: 12, bottom: 8, fontFamily: 'monospace', fontSize: 15, color: C.dim}}>
+      {name}
+    </div>
+  </div>
+);
+
+const Box: React.FC<{color?: string; w?: number; h?: number; style?: React.CSSProperties}> = ({
+  color = C.core,
+  w = 200,
+  h = 80,
+  style,
+}) => <div style={{width: w, height: h, background: C.panel, border: `2px solid ${color}`, borderRadius: 10, ...style}} />;
+
+// ── 每格一个组件：hooks 各归其位（Rules of Hooks 的最简守法形态） ────────
+
+const EnterCell: React.FC<{kind: Parameters<typeof useEnter>[0]}> = ({kind}) => {
+  const e = useEnter(kind, {});
+  return <Box style={{opacity: e.opacity, transform: e.transform}} />;
+};
+
+const StaggerCell: React.FC = () => {
+  const ps = useStagger(5, {dur: 5, fit: {total: 60}});
+  return (
+    <div style={{display: 'flex', gap: 10}}>
+      {ps.map((p, i) => (
+        <div
+          key={i}
+          style={{
+            width: 34,
+            height: 80,
+            background: C.panel,
+            border: `2px solid ${C.mech}`,
+            borderRadius: 8,
+            opacity: p,
+            transform: `translateY(${(1 - p) * 14}px)`,
+          }}
+        />
+      ))}
+    </div>
+  );
+};
+
+const DrawCell: React.FC = () => {
+  const d = useDraw(0, 24);
+  return (
+    <svg width={280} height={110}>
+      <path {...d} d="M10 90 C 90 10, 190 100, 270 20" stroke={C.core} strokeWidth={5} fill="none" strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ImpulseCell: React.FC = () => {
+  const g = useImpulse({dur: 30, peak: 1});
+  return (
+    <div
+      style={{
+        width: 90,
+        height: 90,
+        borderRadius: '50%',
+        background: C.core,
+        opacity: 0.3 + 0.7 * g,
+        boxShadow: `0 0 ${10 + 30 * g}px ${C.core}`,
+      }}
+    />
+  );
+};
+
+const BreatheCell: React.FC = () => {
+  const b = useBreathe({period: 30});
+  return (
+    <svg width={160} height={110}>
+      <circle cx={80} cy={55} r={40} fill="none" stroke={C.mech} strokeWidth={5} opacity={b} />
+    </svg>
+  );
+};
+
+const TravelCell: React.FC = () => {
+  const t = useTravel({cx: 140, cy: 55, r: 42, secPerLap: 3});
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} />
+      <circle cx={t.x} cy={t.y} r={9} fill={C.core} />
+    </svg>
+  );
+};
+
+const AccelCell: React.FC = () => {
+  const t = useAccelTravel({cx: 140, cy: 55, r: 42, durs: [28, 20, 14], at: 4});
+  const heat = `rgb(${217 + Math.round(38 * t.heat)}, ${119 - Math.round(60 * t.heat)}, ${87 - Math.round(20 * t.heat)})`;
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} strokeDasharray="4 6" />
+      <circle cx={t.x} cy={t.y} r={9} fill={heat} />
+    </svg>
+  );
+};
+
+const CountCell: React.FC = () => {
+  const v = useCount({to: 255, dur: 40});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 44, color: C.text, fontVariantNumeric: 'tabular-nums'}}>
+      {Math.round(v)}
+    </div>
+  );
+};
+
+const RevealCell: React.FC = () => {
+  const s = useReveal('while (true) { think(); act(); }', {cps: 14});
+  const blink = useBreathe({period: 16, amp: 0.5, base: 0.5});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 20, color: C.text, whiteSpace: 'nowrap'}}>
+      {s}
+      <span style={{opacity: blink}}>▍</span>
+    </div>
+  );
+};
+
+const PushInCell: React.FC = () => {
+  const t = usePushIn(0, {scale: 0.12});
+  return <Box w={160} h={90} color={C.mech} style={{transform: t}} />;
+};
+
+const DimCell: React.FC = () => {
+  const dim = useDim({at: 40, to: 0.35});
+  return (
+    <div style={{display: 'flex', gap: 12}}>
+      <Box w={64} h={80} style={{opacity: dim}} />
+      <Box w={64} h={80} color={C.core} />
+      <Box w={64} h={80} style={{opacity: dim}} />
+    </div>
+  );
+};
+
+const FlowCell: React.FC = () => {
+  const f = useFlowDash({period: 24});
+  return (
+    <svg width={280} height={60}>
+      <line x1={10} y1={30} x2={270} y2={30} stroke={C.mech} strokeWidth={5} {...f} strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ShakeCell: React.FC = () => {
+  const x = useShake({at: 10, amp: 5, decay: true, dur: 40});
+  return <Box w={150} h={80} color={C.deny} style={{transform: `translateX(${x}px)`}} />;
+};
+
+const FadeCell: React.FC = () => {
+  const op = useFadeOut(90, {frames: 36});
+  return (
+    <div style={{position: 'relative', width: 220, height: 90}}>
+      <Box w={220} h={90} color={C.core} style={{position: 'absolute', inset: 0}} />
+      <div style={{position: 'absolute', inset: 0, background: '#000', opacity: 1 - op}} />
+    </div>
+  );
+};
+
+const CELLS: Array<[string, React.ReactNode]> = [
+  ['enter:fall', <EnterCell kind="fall" />],
+  ['enter:rise', <EnterCell kind="rise" />],
+  ['enter:slideL', <EnterCell kind="slideL" />],
+  ['enter:pop', <EnterCell kind="pop" />],
+  ['enter:flyIn', <EnterCell kind="flyIn" />],
+  ['enter:fade', <EnterCell kind="fade" />],
+  ['stagger×5 fit60', <StaggerCell />],
+  ['draw 24f', <DrawCell />],
+  ['impulse 30f', <ImpulseCell />],
+  ['breathe p30', <BreatheCell />],
+  ['travel 3s/lap', <TravelCell />],
+  ['accelTravel', <AccelCell />],
+  ['count→255', <CountCell />],
+  ['reveal 14cps', <RevealCell />],
+  ['pushIn .12', <PushInCell />],
+  ['dim .35@40', <DimCell />],
+  ['flowDash p24', <FlowCell />],
+  ['shake decay', <ShakeCell />],
+  ['fadeOut 36f', <FadeCell />],
+];
+
+const MotionGallery: React.FC = () => (
+  <AbsoluteFill style={{background: C.bg}}>
+    <div style={{position: 'absolute', left: 72, top: 44, fontFamily: 'monospace', fontSize: 24, color: C.text}}>
+      MotionGallery · 30fps · 120f
+    </div>
+    {CELLS.map(([name, node], i) => (
+      <Cell key={name} i={i} name={name}>
+        {node}
+      </Cell>
+    ))}
+  </AbsoluteFill>
+);
+
+registerRoot(() => (
+  <Composition id="MotionGallery" component={MotionGallery} width={1920} height={1080} fps={30} durationInFrames={120} defaultProps={{}} />
+));
diff --git a/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/hooks.ts b/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/hooks.ts
new file mode 100644
index 000000000..f87b8a129
--- /dev/null
+++ b/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/hooks.ts
@@ -0,0 +1,303 @@
+/** 运动模型（hooks）——分镜「动效」列动词到帧数学的唯一映射。
+ *
+ * 设计约束（违反任何一条即失去本层存在意义）：
+ * 1. hooks 返回数值 / CSS 片段，不渲染 DOM——FadeUp 式包装组件打不进 svg/<g>/
+ *    absolute 布局，是「组件存在却零调用」的实测根因；数值可落进任意 JSX。
+ * 2. 弹簧一律吃局部帧（frame - at）：spring() 每次调用从第 0 帧重模拟，喂全局帧
+ *    会让长片末帧每个 spring 跑两万余次迭代。
+ * 3. effects（不透明度/颜色）永不吃弹簧——一律时长+缓动（tokens 的二分不变量）。
+ * 4. 不读 theme：颜色一律经参数传入（frozen 跨系列共享的前提）。
+ * 5. `at` 锚点一律来自句边界（rel(beat, '句id')），禁写死帧数。
+ */
+import {Easing, interpolate, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {
+  DUR,
+  EASING_CP,
+  SPRING,
+  clampRiseDist,
+  type DurToken,
+  type EasingToken,
+  type SpringPreset,
+} from './tokens';
+import {progress, revealCharCount} from './window';
+import {schedule, type ScheduleOpts} from './schedule';
+
+/** 帧数解析：token 或直接帧数；缺省用 def。 */
+export const frames = (d: number | DurToken | undefined, def: number): number =>
+  d === undefined ? def : typeof d === 'number' ? d : DUR[d];
+
+/** 缓动令牌 → Remotion 缓动函数（linear 直通）。 */
+export const easeF = (t: EasingToken): ((x: number) => number) =>
+  t === 'linear'
+    ? Easing.linear
+    : Easing.bezier(
+        ...(EASING_CP[t] as [number, number, number, number]),
+      );
+
+/** 缓动后的 0..1 进度（各模型共用的原子）。 */
+const eased = (
+  frame: number,
+  at: number,
+  dur: number,
+  e: EasingToken,
+): number => interpolate(progress(frame, at, dur), [0, 1], [0, 1], {easing: easeF(e)});
+
+/** 缓动数值进度——「clamped 0→1 手写 interpolate」惯用形的统一替身：
+ *  时机值走 token，缓动默认 standard（线性原版会被这一档替换——质量提升点之一）。 */
+export function useProgress(
+  at: number,
+  dur: number | DurToken = DUR.f5,
+  easing: EasingToken = 'standard',
+): number {
+  const frame = useCurrentFrame();
+  return eased(frame, at, frames(dur, DUR.f5), easing);
+}
+
+/** 弹簧数值进度（驱动几何量/位移；effects 通道用 useProgress——tokens 二分不变量）。
+ *  局部帧 + 可选 durationInFrames 截停（防窗口外余振；缺省不设上限，与既有手写等价）。 */
+export function useSpring(
+  preset: SpringPreset,
+  o: {at?: number; dur?: number | DurToken} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const cfg: Parameters<typeof spring>[0] = {
+    frame: frame - (o.at ?? 0),
+    fps,
+    config: SPRING[preset],
+  };
+  if (o.dur !== undefined) {
+    cfg.durationInFrames = frames(o.dur, DUR.f5);
+  }
+  return spring(cfg);
+}
+
+// ── 入场（enter：落下/上浮/滑入/弹出/飞入/淡入） ────────────────────────
+
+export type EnterKind = 'fall' | 'rise' | 'slideL' | 'slideR' | 'pop' | 'flyIn' | 'fade';
+export type EnterOpts = {
+  /** 句边界锚（局部帧）。 */
+  at?: number;
+  dur?: number | DurToken;
+  easing?: EasingToken;
+  /** 空间通道用弹簧（位移类才有意义；fade/pop 无效）。 */
+  springPreset?: SpringPreset;
+  /** 位移像素（fall/rise/slide*；缺省 30）。 */
+  dist?: number;
+  /** rise 专用：落位态底边 y——行程经 clampRiseDist 钳进字幕安全带之上。 */
+  restBottom?: number;
+};
+export type EnterStyle = {opacity: number; transform: string};
+
+export function useEnter(kind: EnterKind, o: EnterOpts = {}): EnterStyle {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const at = o.at ?? 0;
+  const dur = frames(o.dur, DUR.f4);
+  let dist = o.dist ?? 30;
+  if (kind === 'rise' && o.restBottom !== undefined) {
+    dist = clampRiseDist(dist, o.restBottom);
+  }
+  // effects 通道：纯缓动、略快于空间通道（元素先「看见」再「落位」）
+  const opacity = progress(frame, at, Math.max(2, Math.round(dur * 0.8)));
+  // spatial 通道：可选弹簧（局部帧 + durationInFrames 截停，防窗口外余振）
+  const p = o.springPreset
+    ? spring({
+        frame: frame - at,
+        fps,
+        config: SPRING[o.springPreset],
+        durationInFrames: dur,
+      })
+    : eased(frame, at, dur, o.easing ?? 'standard');
+  const inv = 1 - p;
+  const t: string[] = [];
+  if (kind === 'fall') t.push(`translateY(${-inv * dist}px)`);
+  if (kind === 'rise') t.push(`translateY(${inv * dist}px)`);
+  if (kind === 'slideL') t.push(`translateX(${-inv * dist}px)`);
+  if (kind === 'slideR') t.push(`translateX(${inv * dist}px)`);
+  if (kind === 'pop') t.push(`scale(${0.9 + 0.1 * p})`);
+  if (kind === 'flyIn') t.push(`scale(${0.6 + 0.4 * p})`);
+  return {opacity, transform: t.length ? t.join(' ') : 'none'};
+}
+
+// ── 序列错峰（stagger：依次/逐行/逐条/逐格） ───────────────────────────
+
+export type StaggerOpts = ScheduleOpts & {at?: number; easing?: EasingToken};
+
+/** 返回 n 个 0..1 进度——第 i 项随编排依次入场。 */
+export function useStagger(n: number, o: StaggerOpts = {}): number[] {
+  const frame = useCurrentFrame();
+  const {at = 0, easing = 'standard'} = o;
+  const plan = schedule(n, o);
+  return plan.starts.map((s) => eased(frame, at + s, plan.dur, easing));
+}
+
+// ── 描线（draw：红线三由构造保证——只产 pathLength 归一化三元组） ────────
+
+export type DrawProps = {pathLength: 1; strokeDasharray: 1; strokeDashoffset: number};
+
+export function useDraw(at: number, dur: number | DurToken = DUR.f5): DrawProps {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(dur, DUR.f5), 'decelerate');
+  return {pathLength: 1, strokeDasharray: 1, strokeDashoffset: 1 - p};
+}
+
+// ── 脉冲 / 呼吸（glow 语法：impulse=一次性强调，breathe=持续辉光） ───────
+
+/** 一次性冲击：sin(πp) 包络，起于 0 归于 0，峰值 peak。 */
+export function useImpulse(o: {at?: number; dur?: number | DurToken; peak?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const p = progress(frame, o.at ?? 0, frames(o.dur, DUR.f5));
+  return Math.sin(Math.PI * p) * (o.peak ?? 1);
+}
+
+/** 持续呼吸（原 0.55+0.45·sin(frame/K) 散写的收敛；period 帧一周期——注意与
+ *  原除数 K 的换算 period = 2πK，如 sin(frame/26) → period 163）。offset 为相位
+ *  平移（错峰辉光的 per-index 形态）。 */
+export function useBreathe(
+  o: {period?: number; amp?: number; base?: number; offset?: number} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {amp = 0.45, base = 0.55, period = 26, offset = 0} = o;
+  return base + amp * Math.sin((2 * Math.PI * (frame - offset)) / period);
+}
+
+// ── 巡游（travel：环形为主；absorb 原 useRingDot 与加速绕行累加器克隆） ──
+
+export type TravelPos = {x: number; y: number; angle: number};
+
+/** 匀速环形巡游（angle 单位度，-90 = 12 点方向起）。 */
+export function useTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  secPerLap?: number;
+  offset?: number;
+}): TravelPos {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const lap = (frame / (fps * (o.secPerLap ?? 2.5)) + (o.offset ?? 0)) % 1;
+  const a = -90 + lap * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), angle: a};
+}
+
+/** 加速绕行：逐圈时长 durs[]（如 [40,30,22,16]），跑完全部圈后冻结在终点。
+ *  heat 0..1 随圈数推进（「失控感」的配色偏移系数）。 */
+export function useAccelTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  durs: number[];
+  at?: number;
+  heatPerLap?: number;
+}): {x: number; y: number; heat: number} {
+  const frame = useCurrentFrame();
+  let t = Math.max(0, frame - (o.at ?? 0));
+  let lap = 0;
+  while (lap < o.durs.length && t >= o.durs[lap]) {
+    t -= o.durs[lap];
+    lap += 1;
+  }
+  const within = lap >= o.durs.length ? 1 : t / o.durs[lap];
+  const heat = Math.min(1, lap / (o.heatPerLap ?? o.durs.length));
+  const a = -90 + within * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), heat};
+}
+
+// ── 计数 / 水位（meter 语法；显示层自行 Math.round / toFixed） ──────────
+
+export function useCount(o: {
+  from?: number;
+  to: number;
+  at?: number;
+  dur?: number | DurToken;
+  ease?: EasingToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {from = 0, to, at = 0} = o;
+  const p = eased(frame, at, frames(o.dur, DUR.f6), o.ease ?? 'standard');
+  return from + (to - from) * p;
+}
+
+// ── 打字机 / 逐字流出（type；Terminal 之外的泛化） ──────────────────────
+
+export function useReveal(
+  text: string,
+  o: {at?: number; cps?: number; framesPerChar?: number} = {},
+): string {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const elapsed = Math.max(0, frame - (o.at ?? 0));
+  const n = revealCharCount(elapsed, fps, o.cps ?? 12, o.framesPerChar);
+  return text.slice(0, Math.min(text.length, n));
+}
+
+// ── 镜头推近（pushIn 语法：beat 切换的镜头语言，替代纯淡入） ────────────
+
+export function usePushIn(at: number, o: {scale?: number; dur?: number | DurToken} = {}): string {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(o.dur, DUR.f5), 'decelerate');
+  return `scale(${1 + (o.scale ?? 0.06) * p})`;
+}
+
+// ── 压暗 / 提亮（emphasis 反向：让主体从群像中浮出） ─────────────────────
+
+/** 返回目标透明度系数（1 = 原；to 0.4 即压暗到 40%）。 */
+export function useDim(o: {at: number; to?: number; dur?: number | DurToken}): number {
+  const frame = useCurrentFrame();
+  const p = eased(frame, o.at, frames(o.dur, DUR.f4), 'standard');
+  return 1 + ((o.to ?? 0.4) - 1) * p;
+}
+
+// ── 流光（flow 语法：连线上的行进虚线） ─────────────────────────────────
+
+/** 返回可直接展开到 <line>/<path> 的描边属性（像素 dasharray——与 draw 的
+ *  pathLength 归一化描线是两个正交特性，勿混用于同一元素：红线三）。 */
+export function useFlowDash(o: {
+  dash?: number;
+  gap?: number;
+  /** 帧速率：每 period 帧行进一个 dash+gap 周期。 */
+  period?: number;
+}): {strokeDasharray: string; strokeDashoffset: number} {
+  const frame = useCurrentFrame();
+  const {dash = 10, gap = 14, period = 40} = o;
+  return {
+    strokeDasharray: `${dash} ${gap}`,
+    strokeDashoffset: -(frame * (dash + gap)) / period,
+  };
+}
+
+// ── 抖动（错误/故障语义；收敛 P2/P3 两处克隆） ──────────────────────────
+
+/** 返回 translateX 像素值。active 缺省 true；decay=true 时按 dur 衰减归零。 */
+export function useShake(o: {
+  at: number;
+  active?: boolean;
+  amp?: number;
+  /** 相位分母（原手写 /1.6、/2.2 的口径）。 */
+  freq?: number;
+  decay?: boolean;
+  dur?: number | DurToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {amp = 3, freq = 1.6} = o;
+  const t = frame - o.at;
+  if (o.active === false || t < 0) {
+    return 0;
+  }
+  if (o.decay) {
+    const env = 1 - progress(frame, o.at, frames(o.dur, DUR.f5));
+    return amp * env * Math.sin(t / freq);
+  }
+  return amp * Math.sin(t / freq);
+}
+
+// ── 片尾渐黑（红线四：从 beat 总时长推导，勿用末句时长） ────────────────
+
+export function useFadeOut(durationInFrames: number, o: {frames?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const f = o.frames ?? 36; // 1.2s
+  return 1 - progress(frame, durationInFrames - f, f);
+}
diff --git a/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/index.ts b/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/index.ts
new file mode 100644
index 000000000..97fd22a5c
--- /dev/null
+++ b/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/index.ts
@@ -0,0 +1,5 @@
+/** 运动层门面——场景代码统一 `import {...} from '../motion'`。 */
+export * from './tokens';
+export * from './window';
+export * from './schedule';
+export * from './hooks';
diff --git a/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/schedule.ts b/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/schedule.ts
new file mode 100644
index 000000000..5703e3315
--- /dev/null
+++ b/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/schedule.ts
@@ -0,0 +1,65 @@
+/** 错峰编排（stagger）纯函数——收敛手写 `frame - i*N`（跨 8 集约 356 处、
+ *  步长 K∈{2,3,4,5,6,8,10} 任意取值、无节奏标尺）。
+ *
+ * 三种模式（互斥，参数即文档）：
+ * - stride：固定步长（与旧手写行为一致——迁移期的保守选项）；
+ * - lag：Manim LaggedStart 语义 start[i] = i·dur·lagRatio（0 = 同刻齐动，1 = 首尾相接）；
+ * - fit：n 个子项恰好装进窗口 total（末项恰在窗口末完成——「随句推进」的首选）。
+ *
+ * 钳制优先级（motion.test.ts 钉死，自左向右）：不外溢窗口 > 最小步长 > 子项时长。
+ * 窗口属于 beat 时间轴，外溢会踩进下一 beat；装不下时先缩子项时长，连 1 帧
+ * 子项都无法错开时显式抛错，不返回违反 fit 契约的计划。
+ */
+export type ScheduleOpts = {
+  /** 子项时长（帧；缺省 DUR.f3=5——「快速子项」档）。 */
+  dur?: number;
+  /** 模式一：固定步长。 */
+  stride?: number;
+  /** 模式二：lag 比率（Manim lag_ratio）。 */
+  lag?: number;
+  /** 模式三：拟装入的窗口总长（帧）。 */
+  fit?: {total: number};
+  /** 相邻起点期望下限，默认 2 帧；fit 紧窗时可按优先级退至 1 帧。 */
+  minStride?: number;
+  /** 子项时长期望下限，默认 3 帧；fit 为守住窗口可退至 1 帧。 */
+  minDur?: number;
+};
+export type Schedule = {starts: number[]; dur: number};
+
+export function schedule(n: number, o: ScheduleOpts): Schedule {
+  const minStride = o.minStride ?? 2;
+  const minDur = o.minDur ?? 3;
+  const modes = [o.stride !== undefined, o.lag !== undefined, o.fit !== undefined].filter(
+    Boolean,
+  ).length;
+  if (modes > 1) {
+    throw new Error('schedule: stride / lag / fit 三选一');
+  }
+  let dur = Math.max(minDur, o.dur ?? 5);
+  if (n <= 0) {
+    return {starts: [], dur};
+  }
+  let stride: number;
+  if (o.fit) {
+    const total = Math.max(1, o.fit.total);
+    if (n > 1 && total < n) {
+      throw new Error(
+        `schedule: fit.total=${total} 无法容纳 ${n} 个至少 1 帧且起点间隔至少 1 帧的子项`,
+      );
+    }
+    dur = Math.min(dur, total);
+    stride = n === 1 ? 0 : (total - dur) / (n - 1);
+    const targetStride = Math.max(1, minStride);
+    if (n > 1 && stride < targetStride) {
+      // 先缩时长争取期望步长；仍不足时牺牲步长，但至少保留 1 帧先后。
+      dur = Math.max(1, Math.min(dur, total - targetStride * (n - 1)));
+      stride = (total - dur) / (n - 1);
+    }
+  } else if (o.lag !== undefined) {
+    stride = dur * o.lag;
+  } else {
+    stride = o.stride ?? minStride;
+  }
+  stride = Math.max(n === 1 || o.lag === 0 ? 0 : 1, stride);
+  return {starts: Array.from({length: n}, (_, i) => Math.round(i * stride)), dur};
+}
diff --git a/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/tokens.ts b/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/tokens.ts
new file mode 100644
index 000000000..457448260
--- /dev/null
+++ b/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/tokens.ts
@@ -0,0 +1,87 @@
+/** 运动令牌——时长标尺 / 缓动曲线 / 弹簧手感 的单一事实源。
+ *
+ * 只放纯数据与纯函数：不 import remotion、不读 theme（颜色一律经参数注入）——
+ * 这是本层能以 frozen 档跨两个系列共享的前提（两系列 theme token 名已分叉：
+ * CC 用 core/mech/deny、SE 用 danger），判据同 test_chrome_motifs_only_read_base_theme_tokens。
+ *
+ * 取值依据（勿凭感觉改；改前先在本集校准轮逐幕目视复测，依据写回此处注释）：
+ * - 时长六档取 IBM Carbon DTCG（70/110/150/240/400/700ms）@30fps 四舍五入。
+ *   弃 Material 十六档：30fps 量化下其 15 个相邻对里 6 对落进同一帧数（伪选择）。
+ * - 缓动控制点取 Material 3 标准三件；曲线本体在 hooks.ts 经 Remotion Easing.bezier 求值。
+ * - 弹簧预设锚定本仓实测手感：settle=200 即既有 9/10 调用点的惯用值（延续成片观感），
+ *   snap=12 来自 P4「插头咬合」的过冲；ζ 与过冲峰值的关系由 motion.test.ts 用
+ *   Mp = exp(-πζ/√(1-ζ²)) 钉死。
+ * - effects 不变量：不透明度/颜色永不过冲——effects 类动画一律时长+缓动，
+ *   弹簧只用于空间位移（M3 spatial/effects 二分的落地）。
+ */
+
+/** 时长标尺（帧 @30fps）。叙事节拍（4–8s）不用此表——那是 window/schedule 的职责。 */
+export const DUR = {
+  /** 70ms：微反馈（辉光起点、光标） */
+  f1: 2,
+  /** 110ms：快速子项（列表错峰的单项时长） */
+  f2: 3,
+  /** 150ms：标准入场 */
+  f3: 5,
+  /** 200ms：强调入场 */
+  f4: 7,
+  /** 400ms：大位移 / 镜头推近 / 描线 */
+  f5: 12,
+  /** 700ms：幕级大动作（少用） */
+  f6: 21,
+} as const;
+export type DurToken = keyof typeof DUR;
+
+/** 缓动令牌。 */
+export type EasingToken = 'standard' | 'decelerate' | 'accelerate' | 'linear';
+
+/** 贝塞尔控制点（x1,y1,x2,y2）；linear 无控制点。 */
+export const EASING_CP: Record<
+  Exclude<EasingToken, 'linear'>,
+  readonly [number, number, number, number]
+> = {
+  // M3 standard：入场默认
+  standard: [0.2, 0, 0, 1],
+  // M3 decelerate：强减速（大位移入场、镜头推近）
+  decelerate: [0.05, 0.7, 0.1, 1],
+  // M3 accelerate：出场加速
+  accelerate: [0.3, 0, 0.8, 0.15],
+};
+
+/** 弹簧预设（直传 Remotion spring config；ζ = c/(2√(k·m))）。 */
+export type SpringPreset = 'settle' | 'settleSoft' | 'snap';
+export const SPRING: Record<SpringPreset, {damping: number; stiffness: number; mass: number}> = {
+  // ζ≈10：无过冲平滑滑入——本仓主流手感（既有场景 9/10 处 damping 200）
+  settle: {damping: 200, stiffness: 100, mass: 1},
+  // ζ≈8.5：更绵一点（P0/P1 既有 180/170 档的收敛）
+  settleSoft: {damping: 170, stiffness: 100, mass: 1},
+  // ζ≈0.6：轻微过冲（咬合/弹入——原 P4 damping 12）
+  snap: {damping: 12, stiffness: 100, mass: 1},
+};
+
+/** 阻尼比 ζ。设计系统文档普遍给 ζ（无量纲），Remotion 取阻尼系数 c——直抄会得
+ *  ζ≈0.02 的暴力弹跳且能通过渲染体检，这是迁移期最高风险项（单测钉死）。 */
+export const dampingRatio = (s: {
+  damping: number;
+  stiffness: number;
+  mass: number;
+}): number => s.damping / (2 * Math.sqrt(s.stiffness * s.mass));
+
+/** 欠阻尼弹簧的峰值位置（1 = 恰好到终点不过冲；ζ ≥ 1 恒 1）。
+ *  Mp = exp(-πζ/√(1-ζ²)) 是超出终点的幅度，峰值 = 1 + Mp。 */
+export const overshootPeak = (zeta: number): number =>
+  zeta >= 1 ? 1 : 1 + Math.exp((-Math.PI * zeta) / Math.sqrt(1 - zeta * zeta));
+
+/** 出场快于入场的系数（MDC 实测 400ms 入 / 150ms 出 ≈ 0.375，取 0.4 禁手填）。 */
+export const EXIT_FACTOR = 0.4;
+
+/** 字幕安全带上沿：1080 - qa_frames.SUBTITLE_BAND_PX(160)，与体检口径同源。 */
+export const SAFE_TOP_Y = 920;
+
+/** 自下方入场的行程安全钳制：落位态底边 restBottom 之上才是可用的进场空间。
+ *  ISSUE-170 的手工逐卡反算收敛于此——该缺陷类从「评审抽帧抓」变「构造不可能」。 */
+export const clampRiseDist = (
+  dist: number,
+  restBottom: number,
+  safeTop: number = SAFE_TOP_Y,
+): number => Math.max(0, Math.min(dist, safeTop - restBottom));
diff --git a/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/window.ts b/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/window.ts
new file mode 100644
index 000000000..69bd59c7a
--- /dev/null
+++ b/apps/negentropy-influence/episodes/experience-era-agents-video/video/src/motion/window.ts
@@ -0,0 +1,43 @@
+/** 运动窗口纯函数——「父级持有绝对时间，子动画只是父进度上的窗口」。
+ *
+ * 这是 audio-first 时序与可复用运动模型兼容的核心机制：beat 的绝对帧来自
+ * beatWindow()（数据源是 TTS 实测 manifest），子动画不写死帧数、只声明自己在
+ * beat 进度上的 [start, end] 窗口 ⇒ 旁白实测时长变化时全部窗口自动重定时，
+ * 「写死帧数与口播脱钩」缺陷类（skills/08 实录）由构造消灭。
+ *
+ * 语义借 MDC TransitionUtils.lerp(startFraction, endFraction)：窗外钳制端点。
+ * 本模块零依赖（不 import remotion / theme）——frozen 跨系列共享与 node 单测的前提。
+ */
+
+/** 钳制到 [0,1]——一切进度的唯一出口，防负值/超 1 渗进 transform。 */
+export const clamp01 = (x: number): number => (x < 0 ? 0 : x > 1 ? 1 : x);
+
+/** 子动画窗口：父进度 p(0..1) 在 [s,e] 片段上的局部进度。 */
+export const win = (p: number, w: readonly [number, number]): number =>
+  clamp01((p - w[0]) / (w[1] - w[0]));
+
+/** beat 进度：局部帧 → 该 beat 的 0..1 进度。 */
+export const beatProgress = (
+  frame: number,
+  from: number,
+  durationInFrames: number,
+): number => clamp01((frame - from) / Math.max(1, durationInFrames));
+
+/** 帧域进度：[at, at+dur] 上的 0..1（dur ≤ 0 视作 1，防除零）。 */
+export const progress = (frame: number, at: number, dur: number): number =>
+  clamp01((frame - at) / Math.max(1, dur));
+
+/** 已过帧数 → 可见字符数；cps 随实际 fps 换算，显式帧间隔不受 fps 影响。 */
+export const revealCharCount = (
+  elapsedFrames: number,
+  fps: number,
+  cps: number,
+  framesPerChar?: number,
+): number => {
+  const elapsed = Math.max(0, elapsedFrames);
+  const count =
+    framesPerChar === undefined
+      ? Math.floor((elapsed / fps) * cps)
+      : Math.floor(elapsed / Math.max(1, framesPerChar));
+  return Math.max(0, count);
+};
diff --git a/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/package.json b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/package.json
index d27caa31f..15220012e 100644
--- a/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/package.json
+++ b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/package.json
@@ -19,10 +19,5 @@
   "devDependencies": {
     "@types/react": "^19.0.0",
     "typescript": "^5.6.0"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild"
-    ]
   }
 }
diff --git a/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/pnpm-workspace.yaml b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/pnpm-workspace.yaml
index f2686ac7d..add822dbe 100644
--- a/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/pnpm-workspace.yaml
+++ b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/pnpm-workspace.yaml
@@ -1,4 +1,9 @@
-# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的唯一理由。
+# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的首要理由。
 # pnpm 12 起仅靠 `--ignore-workspace` 不够：pnpm 仍会沿 packageManager 向上锚定到仓库根，
 # 用本工程的解析结果覆写根 pnpm-lock.yaml（overrides 全丢）且当场不报错。见 ISSUE-175。
 packages: []
+# pnpm 12 的构建脚本许可（package.json 的 pnpm.onlyBuiltDependencies 已不被读取，
+# 静默忽略会使安装以 ERR_PNPM_IGNORED_BUILDS 中断、node_modules 半残）。键名与取值
+# 与 `pnpm approve-builds esbuild --yes` 实际写入的形态逐字一致——勿改回旧键名。
+allowBuilds:
+  esbuild: true
diff --git a/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/scripts/motion.test.ts b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/scripts/motion.test.ts
new file mode 100644
index 000000000..5e29cab52
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/scripts/motion.test.ts
@@ -0,0 +1,141 @@
+/**
+ * 运动层纯函数单测——`node --test scripts/motion.test.ts`（Node ≥ 23.6 原生跑 TS）。
+ *
+ * 刻意放在 video/ 而非 src/：tsconfig include 只有 src（frozen，不为测试改动），
+ * 而本文件 import 需带 .ts 后缀（Node ESM 解析规则）——tsc 若收编会因
+ * allowImportingTsExtensions 未开而报错。src/ 的类型覆盖由 tsc --noEmit 全量保证，
+ * 本文件只测纯函数行为，不做类型承重。
+ *
+ * 只 import 纯模块（tokens/window/schedule——零 remotion/react 依赖）：
+ * hooks 是它们的薄包装，行为由 MotionGallery 目视 + 场景抽帧覆盖。
+ */
+import {strict as assert} from 'node:assert';
+import test from 'node:test';
+
+import {DUR, EASING_CP, EXIT_FACTOR, SAFE_TOP_Y, SPRING, clampRiseDist, dampingRatio, overshootPeak} from '../src/motion/tokens.ts';
+import {beatProgress, clamp01, progress, revealCharCount, win} from '../src/motion/window.ts';
+import {schedule} from '../src/motion/schedule.ts';
+
+// ── tokens ────────────────────────────────────────────────────────────
+
+test('时长标尺在 30fps 下相邻档可辨（≥1 帧差）', () => {
+  const v = Object.values(DUR) as number[];
+  for (let i = 1; i < v.length; i++) {
+    assert.ok(v[i] - v[i - 1] >= 1, `第 ${i} 档与前一档同帧数（伪选择）`);
+  }
+  assert.ok(v.length === 6);
+});
+
+test('ζ→过冲换算钉死：snap 轻过冲、settle 零过冲（直抄 dampingRatio 的反例护栏）', () => {
+  const zSnap = dampingRatio(SPRING.snap);
+  const zSettle = dampingRatio(SPRING.settle);
+  assert.ok(zSnap > 0.4 && zSnap < 0.9, `snap ζ=${zSnap}`);
+  // Mp = exp(-πζ/√(1-ζ²)) 是超出幅度；峰值 = 1 + Mp（ζ=0.6 → 峰值 ≈1.095）
+  assert.ok(overshootPeak(zSnap) > 1.02 && overshootPeak(zSnap) < 1.2, `snap 峰值 ${overshootPeak(zSnap)}`);
+  assert.ok(zSettle > 1, 'settle 须过阻尼');
+  assert.equal(overshootPeak(zSettle), 1);
+  // 反例：把设计系统的 ζ 当 damping 直填（0.8）→ ζ≈0.04、峰值≈1.88 暴力弹跳
+  const wrong = dampingRatio({damping: 0.8, stiffness: 100, mass: 1});
+  assert.ok(overshootPeak(wrong) > 1.8, `直抄 ζ 的峰值=${overshootPeak(wrong)}，必须被此断言抓住`);
+});
+
+test('缓动控制点合法（CSS 规则 x∈[0,1]，且 x(t) 数值单调——可作函数求值）', () => {
+  for (const cp of Object.values(EASING_CP)) {
+    const [x1, , x2] = cp;
+    assert.ok(x1 >= 0 && x1 <= 1 && x2 >= 0 && x2 <= 1, `x 越界：${cp}`);
+    // x1<x2 是充分不必要（M3 standard (0.2,0,0,1) 的 x2<x1 仍单调）——判据用导数采样
+    for (let i = 0; i <= 50; i++) {
+      const t = i / 50;
+      const dx =
+        3 * (1 - t) ** 2 * x1 + 6 * (1 - t) * t * (x2 - x1) + 3 * t * t * (1 - x2);
+      assert.ok(dx > -1e-9, `x(t) 非单调 @t=${t}：${cp}`);
+    }
+  }
+});
+
+test('出场快于入场系数与安全带口径为常量', () => {
+  assert.equal(EXIT_FACTOR, 0.4);
+  assert.equal(SAFE_TOP_Y, 920);
+});
+
+test('clampRiseDist：自下方入场行程不探进字幕安全带', () => {
+  assert.equal(clampRiseDist(120, 836), 84, 'ISSUE-170 实测几何：rest 836 → 行程封顶 84');
+  assert.equal(clampRiseDist(40, 836), 40, '未超限不动');
+  assert.equal(clampRiseDist(120, 960), 0, '落位已在安全带内 → 零行程（退化但安全）');
+});
+
+// ── window ────────────────────────────────────────────────────────────
+
+test('clamp01 / progress / win 的钳制语义', () => {
+  assert.equal(clamp01(-1), 0);
+  assert.equal(clamp01(2), 1);
+  assert.equal(progress(10, 10, 10), 0, '起点为 0');
+  assert.equal(progress(20, 10, 10), 1, '终点为 1');
+  assert.equal(progress(5, 10, 10), 0, '窗外前钳 0');
+  assert.equal(progress(99, 10, 10), 1, '窗外后钳 1');
+  assert.equal(win(0.5, [0.25, 0.75]), 0.5);
+  assert.equal(win(0.1, [0.25, 0.75]), 0);
+  assert.equal(win(0.9, [0.25, 0.75]), 1);
+  assert.equal(beatProgress(0, -30, 90), 1 / 3);
+});
+
+test('逐字揭示：cps 按实际 fps 换算并向下取整，framesPerChar 保持固定帧间隔', () => {
+  assert.equal(revealCharCount(29, 60, 12), 5);
+  assert.equal(revealCharCount(30, 60, 12), 6);
+  assert.equal(revealCharCount(30, 24, 12, 3), 10);
+  assert.equal(revealCharCount(30, 120, 12, 3), 10);
+});
+
+// ── schedule ──────────────────────────────────────────────────────────
+
+test('fit 模式：末项恰在窗口末完成、不外溢', () => {
+  const p = schedule(5, {dur: 10, fit: {total: 90}});
+  const last = p.starts[4] + p.dur;
+  assert.ok(last <= 90 + 1, `末项 ${last} 外溢`);
+  assert.ok(last >= 89, `末项 ${last} 未到窗口末`);
+});
+
+test('fit 装不下时缩子项时长，不外溢窗口（优先级：不外溢 > 最小步长 > 子项时长）', () => {
+  // total 30 时 (30-12)/7≈2.57 ≥ minStride=2 仍装得下；压到 24 才触发缩时长
+  const p = schedule(8, {dur: 12, fit: {total: 24}});
+  const last = p.starts[7] + p.dur;
+  assert.ok(last <= 24, `末项 ${last} 外溢`);
+  assert.ok(p.dur >= 3, '子项时长跌破下限');
+  assert.ok(p.dur < 12, '装不下却未缩子项时长');
+});
+
+test('fit 窗口连 1 帧子项也容不下时显式拒绝，不返回外溢计划', () => {
+  assert.throws(() => schedule(8, {dur: 12, fit: {total: 5}}), /fit\.total=5.*8/);
+});
+
+test('fit 可行极限先牺牲子项时长，仍完整落在窗口内', () => {
+  const p = schedule(8, {dur: 12, fit: {total: 8}});
+  assert.equal(p.dur, 1);
+  assert.equal(p.starts[7] + p.dur, 8);
+});
+
+test('lag 模式：Manim 语义 start[i] = i·dur·lag', () => {
+  const p = schedule(3, {dur: 10, lag: 0.5});
+  assert.deepEqual(p.starts, [0, 5, 10]);
+  assert.deepEqual(schedule(3, {dur: 10, lag: 0}).starts, [0, 0, 0], 'lag=0 须同刻齐动');
+});
+
+test('stride 模式与三选一守卫', () => {
+  assert.deepEqual(schedule(3, {dur: 5, stride: 4}).starts, [0, 4, 8]);
+  assert.throws(() => schedule(3, {dur: 5, stride: 4, lag: 1}));
+  assert.throws(() => schedule(3, {dur: 5, lag: 1, fit: {total: 40}}));
+});
+
+test('最小步长与空集', () => {
+  assert.deepEqual(schedule(0, {dur: 5, stride: 4}), {starts: [], dur: 5});
+  const p = schedule(2, {dur: 5, stride: 0}); // 非法步长 → 抬到下限
+  assert.ok(p.starts[1] - p.starts[0] >= 1);
+});
+
+test('起点取整且单调不减', () => {
+  const p = schedule(6, {dur: 7, fit: {total: 53}});
+  for (let i = 1; i < p.starts.length; i++) {
+    assert.ok(p.starts[i] >= p.starts[i - 1], '起点须单调不减');
+    assert.ok(Number.isInteger(p.starts[i]));
+  }
+});
diff --git a/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/gallery.tsx b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/gallery.tsx
new file mode 100644
index 000000000..a71737133
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/gallery.tsx
@@ -0,0 +1,265 @@
+/** MotionGallery——运动层的评审面（独立 Remotion 入口，不经 Root.tsx）。
+ *
+ * 用法（在 video/ 目录，.bin 直调防污染根 workspace）：
+ *   ./node_modules/.bin/remotion still src/motion/gallery.tsx MotionGallery \
+ *       out/motion-gallery.png --frame=30
+ *
+ * 全部模型 × 变体一屏可渲：秒级出图，供 token 校准轮逐格目视。
+ * 色板为本文件内字面量（dev 工具面，不进成片、不读 theme——保持 frozen 跨系列共享）。
+ */
+import React from 'react';
+import {AbsoluteFill, Composition, registerRoot} from 'remotion';
+import {
+  useAccelTravel,
+  useBreathe,
+  useCount,
+  useDim,
+  useDraw,
+  useEnter,
+  useFadeOut,
+  useFlowDash,
+  useImpulse,
+  usePushIn,
+  useReveal,
+  useShake,
+  useStagger,
+  useTravel,
+} from './hooks';
+
+const COLS = 5;
+const CW = 340;
+const CH = 230;
+const GAP = 18;
+
+/** dev 工具面字面量色板（与各集 theme 底座同值但刻意独立声明——不读 theme）。 */
+const C = {
+  bg: '#0E1116',
+  panel: '#171C26',
+  border: '#2A3242',
+  text: '#F2F5FA',
+  dim: '#9AA7B8',
+  core: '#D97757',
+  mech: '#64C4C0',
+  deny: '#EF6461',
+};
+
+/** 单元格壳：定位 + 角标。 */
+const Cell: React.FC<{i: number; name: string; children: React.ReactNode}> = ({i, name, children}) => (
+  <div
+    style={{
+      position: 'absolute',
+      left: 72 + (i % COLS) * (CW + GAP),
+      top: 96 + Math.floor(i / COLS) * (CH + GAP),
+      width: CW,
+      height: CH,
+      background: C.panel,
+      border: `2px solid ${C.border}`,
+      borderRadius: 12,
+    }}
+  >
+    <div
+      style={{
+        position: 'absolute',
+        inset: '28px 0 34px 0',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+      }}
+    >
+      {children}
+    </div>
+    <div style={{position: 'absolute', left: 12, bottom: 8, fontFamily: 'monospace', fontSize: 15, color: C.dim}}>
+      {name}
+    </div>
+  </div>
+);
+
+const Box: React.FC<{color?: string; w?: number; h?: number; style?: React.CSSProperties}> = ({
+  color = C.core,
+  w = 200,
+  h = 80,
+  style,
+}) => <div style={{width: w, height: h, background: C.panel, border: `2px solid ${color}`, borderRadius: 10, ...style}} />;
+
+// ── 每格一个组件：hooks 各归其位（Rules of Hooks 的最简守法形态） ────────
+
+const EnterCell: React.FC<{kind: Parameters<typeof useEnter>[0]}> = ({kind}) => {
+  const e = useEnter(kind, {});
+  return <Box style={{opacity: e.opacity, transform: e.transform}} />;
+};
+
+const StaggerCell: React.FC = () => {
+  const ps = useStagger(5, {dur: 5, fit: {total: 60}});
+  return (
+    <div style={{display: 'flex', gap: 10}}>
+      {ps.map((p, i) => (
+        <div
+          key={i}
+          style={{
+            width: 34,
+            height: 80,
+            background: C.panel,
+            border: `2px solid ${C.mech}`,
+            borderRadius: 8,
+            opacity: p,
+            transform: `translateY(${(1 - p) * 14}px)`,
+          }}
+        />
+      ))}
+    </div>
+  );
+};
+
+const DrawCell: React.FC = () => {
+  const d = useDraw(0, 24);
+  return (
+    <svg width={280} height={110}>
+      <path {...d} d="M10 90 C 90 10, 190 100, 270 20" stroke={C.core} strokeWidth={5} fill="none" strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ImpulseCell: React.FC = () => {
+  const g = useImpulse({dur: 30, peak: 1});
+  return (
+    <div
+      style={{
+        width: 90,
+        height: 90,
+        borderRadius: '50%',
+        background: C.core,
+        opacity: 0.3 + 0.7 * g,
+        boxShadow: `0 0 ${10 + 30 * g}px ${C.core}`,
+      }}
+    />
+  );
+};
+
+const BreatheCell: React.FC = () => {
+  const b = useBreathe({period: 30});
+  return (
+    <svg width={160} height={110}>
+      <circle cx={80} cy={55} r={40} fill="none" stroke={C.mech} strokeWidth={5} opacity={b} />
+    </svg>
+  );
+};
+
+const TravelCell: React.FC = () => {
+  const t = useTravel({cx: 140, cy: 55, r: 42, secPerLap: 3});
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} />
+      <circle cx={t.x} cy={t.y} r={9} fill={C.core} />
+    </svg>
+  );
+};
+
+const AccelCell: React.FC = () => {
+  const t = useAccelTravel({cx: 140, cy: 55, r: 42, durs: [28, 20, 14], at: 4});
+  const heat = `rgb(${217 + Math.round(38 * t.heat)}, ${119 - Math.round(60 * t.heat)}, ${87 - Math.round(20 * t.heat)})`;
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} strokeDasharray="4 6" />
+      <circle cx={t.x} cy={t.y} r={9} fill={heat} />
+    </svg>
+  );
+};
+
+const CountCell: React.FC = () => {
+  const v = useCount({to: 255, dur: 40});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 44, color: C.text, fontVariantNumeric: 'tabular-nums'}}>
+      {Math.round(v)}
+    </div>
+  );
+};
+
+const RevealCell: React.FC = () => {
+  const s = useReveal('while (true) { think(); act(); }', {cps: 14});
+  const blink = useBreathe({period: 16, amp: 0.5, base: 0.5});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 20, color: C.text, whiteSpace: 'nowrap'}}>
+      {s}
+      <span style={{opacity: blink}}>▍</span>
+    </div>
+  );
+};
+
+const PushInCell: React.FC = () => {
+  const t = usePushIn(0, {scale: 0.12});
+  return <Box w={160} h={90} color={C.mech} style={{transform: t}} />;
+};
+
+const DimCell: React.FC = () => {
+  const dim = useDim({at: 40, to: 0.35});
+  return (
+    <div style={{display: 'flex', gap: 12}}>
+      <Box w={64} h={80} style={{opacity: dim}} />
+      <Box w={64} h={80} color={C.core} />
+      <Box w={64} h={80} style={{opacity: dim}} />
+    </div>
+  );
+};
+
+const FlowCell: React.FC = () => {
+  const f = useFlowDash({period: 24});
+  return (
+    <svg width={280} height={60}>
+      <line x1={10} y1={30} x2={270} y2={30} stroke={C.mech} strokeWidth={5} {...f} strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ShakeCell: React.FC = () => {
+  const x = useShake({at: 10, amp: 5, decay: true, dur: 40});
+  return <Box w={150} h={80} color={C.deny} style={{transform: `translateX(${x}px)`}} />;
+};
+
+const FadeCell: React.FC = () => {
+  const op = useFadeOut(90, {frames: 36});
+  return (
+    <div style={{position: 'relative', width: 220, height: 90}}>
+      <Box w={220} h={90} color={C.core} style={{position: 'absolute', inset: 0}} />
+      <div style={{position: 'absolute', inset: 0, background: '#000', opacity: 1 - op}} />
+    </div>
+  );
+};
+
+const CELLS: Array<[string, React.ReactNode]> = [
+  ['enter:fall', <EnterCell kind="fall" />],
+  ['enter:rise', <EnterCell kind="rise" />],
+  ['enter:slideL', <EnterCell kind="slideL" />],
+  ['enter:pop', <EnterCell kind="pop" />],
+  ['enter:flyIn', <EnterCell kind="flyIn" />],
+  ['enter:fade', <EnterCell kind="fade" />],
+  ['stagger×5 fit60', <StaggerCell />],
+  ['draw 24f', <DrawCell />],
+  ['impulse 30f', <ImpulseCell />],
+  ['breathe p30', <BreatheCell />],
+  ['travel 3s/lap', <TravelCell />],
+  ['accelTravel', <AccelCell />],
+  ['count→255', <CountCell />],
+  ['reveal 14cps', <RevealCell />],
+  ['pushIn .12', <PushInCell />],
+  ['dim .35@40', <DimCell />],
+  ['flowDash p24', <FlowCell />],
+  ['shake decay', <ShakeCell />],
+  ['fadeOut 36f', <FadeCell />],
+];
+
+const MotionGallery: React.FC = () => (
+  <AbsoluteFill style={{background: C.bg}}>
+    <div style={{position: 'absolute', left: 72, top: 44, fontFamily: 'monospace', fontSize: 24, color: C.text}}>
+      MotionGallery · 30fps · 120f
+    </div>
+    {CELLS.map(([name, node], i) => (
+      <Cell key={name} i={i} name={name}>
+        {node}
+      </Cell>
+    ))}
+  </AbsoluteFill>
+);
+
+registerRoot(() => (
+  <Composition id="MotionGallery" component={MotionGallery} width={1920} height={1080} fps={30} durationInFrames={120} defaultProps={{}} />
+));
diff --git a/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/hooks.ts b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/hooks.ts
new file mode 100644
index 000000000..f87b8a129
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/hooks.ts
@@ -0,0 +1,303 @@
+/** 运动模型（hooks）——分镜「动效」列动词到帧数学的唯一映射。
+ *
+ * 设计约束（违反任何一条即失去本层存在意义）：
+ * 1. hooks 返回数值 / CSS 片段，不渲染 DOM——FadeUp 式包装组件打不进 svg/<g>/
+ *    absolute 布局，是「组件存在却零调用」的实测根因；数值可落进任意 JSX。
+ * 2. 弹簧一律吃局部帧（frame - at）：spring() 每次调用从第 0 帧重模拟，喂全局帧
+ *    会让长片末帧每个 spring 跑两万余次迭代。
+ * 3. effects（不透明度/颜色）永不吃弹簧——一律时长+缓动（tokens 的二分不变量）。
+ * 4. 不读 theme：颜色一律经参数传入（frozen 跨系列共享的前提）。
+ * 5. `at` 锚点一律来自句边界（rel(beat, '句id')），禁写死帧数。
+ */
+import {Easing, interpolate, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {
+  DUR,
+  EASING_CP,
+  SPRING,
+  clampRiseDist,
+  type DurToken,
+  type EasingToken,
+  type SpringPreset,
+} from './tokens';
+import {progress, revealCharCount} from './window';
+import {schedule, type ScheduleOpts} from './schedule';
+
+/** 帧数解析：token 或直接帧数；缺省用 def。 */
+export const frames = (d: number | DurToken | undefined, def: number): number =>
+  d === undefined ? def : typeof d === 'number' ? d : DUR[d];
+
+/** 缓动令牌 → Remotion 缓动函数（linear 直通）。 */
+export const easeF = (t: EasingToken): ((x: number) => number) =>
+  t === 'linear'
+    ? Easing.linear
+    : Easing.bezier(
+        ...(EASING_CP[t] as [number, number, number, number]),
+      );
+
+/** 缓动后的 0..1 进度（各模型共用的原子）。 */
+const eased = (
+  frame: number,
+  at: number,
+  dur: number,
+  e: EasingToken,
+): number => interpolate(progress(frame, at, dur), [0, 1], [0, 1], {easing: easeF(e)});
+
+/** 缓动数值进度——「clamped 0→1 手写 interpolate」惯用形的统一替身：
+ *  时机值走 token，缓动默认 standard（线性原版会被这一档替换——质量提升点之一）。 */
+export function useProgress(
+  at: number,
+  dur: number | DurToken = DUR.f5,
+  easing: EasingToken = 'standard',
+): number {
+  const frame = useCurrentFrame();
+  return eased(frame, at, frames(dur, DUR.f5), easing);
+}
+
+/** 弹簧数值进度（驱动几何量/位移；effects 通道用 useProgress——tokens 二分不变量）。
+ *  局部帧 + 可选 durationInFrames 截停（防窗口外余振；缺省不设上限，与既有手写等价）。 */
+export function useSpring(
+  preset: SpringPreset,
+  o: {at?: number; dur?: number | DurToken} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const cfg: Parameters<typeof spring>[0] = {
+    frame: frame - (o.at ?? 0),
+    fps,
+    config: SPRING[preset],
+  };
+  if (o.dur !== undefined) {
+    cfg.durationInFrames = frames(o.dur, DUR.f5);
+  }
+  return spring(cfg);
+}
+
+// ── 入场（enter：落下/上浮/滑入/弹出/飞入/淡入） ────────────────────────
+
+export type EnterKind = 'fall' | 'rise' | 'slideL' | 'slideR' | 'pop' | 'flyIn' | 'fade';
+export type EnterOpts = {
+  /** 句边界锚（局部帧）。 */
+  at?: number;
+  dur?: number | DurToken;
+  easing?: EasingToken;
+  /** 空间通道用弹簧（位移类才有意义；fade/pop 无效）。 */
+  springPreset?: SpringPreset;
+  /** 位移像素（fall/rise/slide*；缺省 30）。 */
+  dist?: number;
+  /** rise 专用：落位态底边 y——行程经 clampRiseDist 钳进字幕安全带之上。 */
+  restBottom?: number;
+};
+export type EnterStyle = {opacity: number; transform: string};
+
+export function useEnter(kind: EnterKind, o: EnterOpts = {}): EnterStyle {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const at = o.at ?? 0;
+  const dur = frames(o.dur, DUR.f4);
+  let dist = o.dist ?? 30;
+  if (kind === 'rise' && o.restBottom !== undefined) {
+    dist = clampRiseDist(dist, o.restBottom);
+  }
+  // effects 通道：纯缓动、略快于空间通道（元素先「看见」再「落位」）
+  const opacity = progress(frame, at, Math.max(2, Math.round(dur * 0.8)));
+  // spatial 通道：可选弹簧（局部帧 + durationInFrames 截停，防窗口外余振）
+  const p = o.springPreset
+    ? spring({
+        frame: frame - at,
+        fps,
+        config: SPRING[o.springPreset],
+        durationInFrames: dur,
+      })
+    : eased(frame, at, dur, o.easing ?? 'standard');
+  const inv = 1 - p;
+  const t: string[] = [];
+  if (kind === 'fall') t.push(`translateY(${-inv * dist}px)`);
+  if (kind === 'rise') t.push(`translateY(${inv * dist}px)`);
+  if (kind === 'slideL') t.push(`translateX(${-inv * dist}px)`);
+  if (kind === 'slideR') t.push(`translateX(${inv * dist}px)`);
+  if (kind === 'pop') t.push(`scale(${0.9 + 0.1 * p})`);
+  if (kind === 'flyIn') t.push(`scale(${0.6 + 0.4 * p})`);
+  return {opacity, transform: t.length ? t.join(' ') : 'none'};
+}
+
+// ── 序列错峰（stagger：依次/逐行/逐条/逐格） ───────────────────────────
+
+export type StaggerOpts = ScheduleOpts & {at?: number; easing?: EasingToken};
+
+/** 返回 n 个 0..1 进度——第 i 项随编排依次入场。 */
+export function useStagger(n: number, o: StaggerOpts = {}): number[] {
+  const frame = useCurrentFrame();
+  const {at = 0, easing = 'standard'} = o;
+  const plan = schedule(n, o);
+  return plan.starts.map((s) => eased(frame, at + s, plan.dur, easing));
+}
+
+// ── 描线（draw：红线三由构造保证——只产 pathLength 归一化三元组） ────────
+
+export type DrawProps = {pathLength: 1; strokeDasharray: 1; strokeDashoffset: number};
+
+export function useDraw(at: number, dur: number | DurToken = DUR.f5): DrawProps {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(dur, DUR.f5), 'decelerate');
+  return {pathLength: 1, strokeDasharray: 1, strokeDashoffset: 1 - p};
+}
+
+// ── 脉冲 / 呼吸（glow 语法：impulse=一次性强调，breathe=持续辉光） ───────
+
+/** 一次性冲击：sin(πp) 包络，起于 0 归于 0，峰值 peak。 */
+export function useImpulse(o: {at?: number; dur?: number | DurToken; peak?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const p = progress(frame, o.at ?? 0, frames(o.dur, DUR.f5));
+  return Math.sin(Math.PI * p) * (o.peak ?? 1);
+}
+
+/** 持续呼吸（原 0.55+0.45·sin(frame/K) 散写的收敛；period 帧一周期——注意与
+ *  原除数 K 的换算 period = 2πK，如 sin(frame/26) → period 163）。offset 为相位
+ *  平移（错峰辉光的 per-index 形态）。 */
+export function useBreathe(
+  o: {period?: number; amp?: number; base?: number; offset?: number} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {amp = 0.45, base = 0.55, period = 26, offset = 0} = o;
+  return base + amp * Math.sin((2 * Math.PI * (frame - offset)) / period);
+}
+
+// ── 巡游（travel：环形为主；absorb 原 useRingDot 与加速绕行累加器克隆） ──
+
+export type TravelPos = {x: number; y: number; angle: number};
+
+/** 匀速环形巡游（angle 单位度，-90 = 12 点方向起）。 */
+export function useTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  secPerLap?: number;
+  offset?: number;
+}): TravelPos {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const lap = (frame / (fps * (o.secPerLap ?? 2.5)) + (o.offset ?? 0)) % 1;
+  const a = -90 + lap * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), angle: a};
+}
+
+/** 加速绕行：逐圈时长 durs[]（如 [40,30,22,16]），跑完全部圈后冻结在终点。
+ *  heat 0..1 随圈数推进（「失控感」的配色偏移系数）。 */
+export function useAccelTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  durs: number[];
+  at?: number;
+  heatPerLap?: number;
+}): {x: number; y: number; heat: number} {
+  const frame = useCurrentFrame();
+  let t = Math.max(0, frame - (o.at ?? 0));
+  let lap = 0;
+  while (lap < o.durs.length && t >= o.durs[lap]) {
+    t -= o.durs[lap];
+    lap += 1;
+  }
+  const within = lap >= o.durs.length ? 1 : t / o.durs[lap];
+  const heat = Math.min(1, lap / (o.heatPerLap ?? o.durs.length));
+  const a = -90 + within * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), heat};
+}
+
+// ── 计数 / 水位（meter 语法；显示层自行 Math.round / toFixed） ──────────
+
+export function useCount(o: {
+  from?: number;
+  to: number;
+  at?: number;
+  dur?: number | DurToken;
+  ease?: EasingToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {from = 0, to, at = 0} = o;
+  const p = eased(frame, at, frames(o.dur, DUR.f6), o.ease ?? 'standard');
+  return from + (to - from) * p;
+}
+
+// ── 打字机 / 逐字流出（type；Terminal 之外的泛化） ──────────────────────
+
+export function useReveal(
+  text: string,
+  o: {at?: number; cps?: number; framesPerChar?: number} = {},
+): string {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const elapsed = Math.max(0, frame - (o.at ?? 0));
+  const n = revealCharCount(elapsed, fps, o.cps ?? 12, o.framesPerChar);
+  return text.slice(0, Math.min(text.length, n));
+}
+
+// ── 镜头推近（pushIn 语法：beat 切换的镜头语言，替代纯淡入） ────────────
+
+export function usePushIn(at: number, o: {scale?: number; dur?: number | DurToken} = {}): string {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(o.dur, DUR.f5), 'decelerate');
+  return `scale(${1 + (o.scale ?? 0.06) * p})`;
+}
+
+// ── 压暗 / 提亮（emphasis 反向：让主体从群像中浮出） ─────────────────────
+
+/** 返回目标透明度系数（1 = 原；to 0.4 即压暗到 40%）。 */
+export function useDim(o: {at: number; to?: number; dur?: number | DurToken}): number {
+  const frame = useCurrentFrame();
+  const p = eased(frame, o.at, frames(o.dur, DUR.f4), 'standard');
+  return 1 + ((o.to ?? 0.4) - 1) * p;
+}
+
+// ── 流光（flow 语法：连线上的行进虚线） ─────────────────────────────────
+
+/** 返回可直接展开到 <line>/<path> 的描边属性（像素 dasharray——与 draw 的
+ *  pathLength 归一化描线是两个正交特性，勿混用于同一元素：红线三）。 */
+export function useFlowDash(o: {
+  dash?: number;
+  gap?: number;
+  /** 帧速率：每 period 帧行进一个 dash+gap 周期。 */
+  period?: number;
+}): {strokeDasharray: string; strokeDashoffset: number} {
+  const frame = useCurrentFrame();
+  const {dash = 10, gap = 14, period = 40} = o;
+  return {
+    strokeDasharray: `${dash} ${gap}`,
+    strokeDashoffset: -(frame * (dash + gap)) / period,
+  };
+}
+
+// ── 抖动（错误/故障语义；收敛 P2/P3 两处克隆） ──────────────────────────
+
+/** 返回 translateX 像素值。active 缺省 true；decay=true 时按 dur 衰减归零。 */
+export function useShake(o: {
+  at: number;
+  active?: boolean;
+  amp?: number;
+  /** 相位分母（原手写 /1.6、/2.2 的口径）。 */
+  freq?: number;
+  decay?: boolean;
+  dur?: number | DurToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {amp = 3, freq = 1.6} = o;
+  const t = frame - o.at;
+  if (o.active === false || t < 0) {
+    return 0;
+  }
+  if (o.decay) {
+    const env = 1 - progress(frame, o.at, frames(o.dur, DUR.f5));
+    return amp * env * Math.sin(t / freq);
+  }
+  return amp * Math.sin(t / freq);
+}
+
+// ── 片尾渐黑（红线四：从 beat 总时长推导，勿用末句时长） ────────────────
+
+export function useFadeOut(durationInFrames: number, o: {frames?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const f = o.frames ?? 36; // 1.2s
+  return 1 - progress(frame, durationInFrames - f, f);
+}
diff --git a/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/index.ts b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/index.ts
new file mode 100644
index 000000000..97fd22a5c
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/index.ts
@@ -0,0 +1,5 @@
+/** 运动层门面——场景代码统一 `import {...} from '../motion'`。 */
+export * from './tokens';
+export * from './window';
+export * from './schedule';
+export * from './hooks';
diff --git a/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/schedule.ts b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/schedule.ts
new file mode 100644
index 000000000..5703e3315
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/schedule.ts
@@ -0,0 +1,65 @@
+/** 错峰编排（stagger）纯函数——收敛手写 `frame - i*N`（跨 8 集约 356 处、
+ *  步长 K∈{2,3,4,5,6,8,10} 任意取值、无节奏标尺）。
+ *
+ * 三种模式（互斥，参数即文档）：
+ * - stride：固定步长（与旧手写行为一致——迁移期的保守选项）；
+ * - lag：Manim LaggedStart 语义 start[i] = i·dur·lagRatio（0 = 同刻齐动，1 = 首尾相接）；
+ * - fit：n 个子项恰好装进窗口 total（末项恰在窗口末完成——「随句推进」的首选）。
+ *
+ * 钳制优先级（motion.test.ts 钉死，自左向右）：不外溢窗口 > 最小步长 > 子项时长。
+ * 窗口属于 beat 时间轴，外溢会踩进下一 beat；装不下时先缩子项时长，连 1 帧
+ * 子项都无法错开时显式抛错，不返回违反 fit 契约的计划。
+ */
+export type ScheduleOpts = {
+  /** 子项时长（帧；缺省 DUR.f3=5——「快速子项」档）。 */
+  dur?: number;
+  /** 模式一：固定步长。 */
+  stride?: number;
+  /** 模式二：lag 比率（Manim lag_ratio）。 */
+  lag?: number;
+  /** 模式三：拟装入的窗口总长（帧）。 */
+  fit?: {total: number};
+  /** 相邻起点期望下限，默认 2 帧；fit 紧窗时可按优先级退至 1 帧。 */
+  minStride?: number;
+  /** 子项时长期望下限，默认 3 帧；fit 为守住窗口可退至 1 帧。 */
+  minDur?: number;
+};
+export type Schedule = {starts: number[]; dur: number};
+
+export function schedule(n: number, o: ScheduleOpts): Schedule {
+  const minStride = o.minStride ?? 2;
+  const minDur = o.minDur ?? 3;
+  const modes = [o.stride !== undefined, o.lag !== undefined, o.fit !== undefined].filter(
+    Boolean,
+  ).length;
+  if (modes > 1) {
+    throw new Error('schedule: stride / lag / fit 三选一');
+  }
+  let dur = Math.max(minDur, o.dur ?? 5);
+  if (n <= 0) {
+    return {starts: [], dur};
+  }
+  let stride: number;
+  if (o.fit) {
+    const total = Math.max(1, o.fit.total);
+    if (n > 1 && total < n) {
+      throw new Error(
+        `schedule: fit.total=${total} 无法容纳 ${n} 个至少 1 帧且起点间隔至少 1 帧的子项`,
+      );
+    }
+    dur = Math.min(dur, total);
+    stride = n === 1 ? 0 : (total - dur) / (n - 1);
+    const targetStride = Math.max(1, minStride);
+    if (n > 1 && stride < targetStride) {
+      // 先缩时长争取期望步长；仍不足时牺牲步长，但至少保留 1 帧先后。
+      dur = Math.max(1, Math.min(dur, total - targetStride * (n - 1)));
+      stride = (total - dur) / (n - 1);
+    }
+  } else if (o.lag !== undefined) {
+    stride = dur * o.lag;
+  } else {
+    stride = o.stride ?? minStride;
+  }
+  stride = Math.max(n === 1 || o.lag === 0 ? 0 : 1, stride);
+  return {starts: Array.from({length: n}, (_, i) => Math.round(i * stride)), dur};
+}
diff --git a/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/tokens.ts b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/tokens.ts
new file mode 100644
index 000000000..457448260
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/tokens.ts
@@ -0,0 +1,87 @@
+/** 运动令牌——时长标尺 / 缓动曲线 / 弹簧手感 的单一事实源。
+ *
+ * 只放纯数据与纯函数：不 import remotion、不读 theme（颜色一律经参数注入）——
+ * 这是本层能以 frozen 档跨两个系列共享的前提（两系列 theme token 名已分叉：
+ * CC 用 core/mech/deny、SE 用 danger），判据同 test_chrome_motifs_only_read_base_theme_tokens。
+ *
+ * 取值依据（勿凭感觉改；改前先在本集校准轮逐幕目视复测，依据写回此处注释）：
+ * - 时长六档取 IBM Carbon DTCG（70/110/150/240/400/700ms）@30fps 四舍五入。
+ *   弃 Material 十六档：30fps 量化下其 15 个相邻对里 6 对落进同一帧数（伪选择）。
+ * - 缓动控制点取 Material 3 标准三件；曲线本体在 hooks.ts 经 Remotion Easing.bezier 求值。
+ * - 弹簧预设锚定本仓实测手感：settle=200 即既有 9/10 调用点的惯用值（延续成片观感），
+ *   snap=12 来自 P4「插头咬合」的过冲；ζ 与过冲峰值的关系由 motion.test.ts 用
+ *   Mp = exp(-πζ/√(1-ζ²)) 钉死。
+ * - effects 不变量：不透明度/颜色永不过冲——effects 类动画一律时长+缓动，
+ *   弹簧只用于空间位移（M3 spatial/effects 二分的落地）。
+ */
+
+/** 时长标尺（帧 @30fps）。叙事节拍（4–8s）不用此表——那是 window/schedule 的职责。 */
+export const DUR = {
+  /** 70ms：微反馈（辉光起点、光标） */
+  f1: 2,
+  /** 110ms：快速子项（列表错峰的单项时长） */
+  f2: 3,
+  /** 150ms：标准入场 */
+  f3: 5,
+  /** 200ms：强调入场 */
+  f4: 7,
+  /** 400ms：大位移 / 镜头推近 / 描线 */
+  f5: 12,
+  /** 700ms：幕级大动作（少用） */
+  f6: 21,
+} as const;
+export type DurToken = keyof typeof DUR;
+
+/** 缓动令牌。 */
+export type EasingToken = 'standard' | 'decelerate' | 'accelerate' | 'linear';
+
+/** 贝塞尔控制点（x1,y1,x2,y2）；linear 无控制点。 */
+export const EASING_CP: Record<
+  Exclude<EasingToken, 'linear'>,
+  readonly [number, number, number, number]
+> = {
+  // M3 standard：入场默认
+  standard: [0.2, 0, 0, 1],
+  // M3 decelerate：强减速（大位移入场、镜头推近）
+  decelerate: [0.05, 0.7, 0.1, 1],
+  // M3 accelerate：出场加速
+  accelerate: [0.3, 0, 0.8, 0.15],
+};
+
+/** 弹簧预设（直传 Remotion spring config；ζ = c/(2√(k·m))）。 */
+export type SpringPreset = 'settle' | 'settleSoft' | 'snap';
+export const SPRING: Record<SpringPreset, {damping: number; stiffness: number; mass: number}> = {
+  // ζ≈10：无过冲平滑滑入——本仓主流手感（既有场景 9/10 处 damping 200）
+  settle: {damping: 200, stiffness: 100, mass: 1},
+  // ζ≈8.5：更绵一点（P0/P1 既有 180/170 档的收敛）
+  settleSoft: {damping: 170, stiffness: 100, mass: 1},
+  // ζ≈0.6：轻微过冲（咬合/弹入——原 P4 damping 12）
+  snap: {damping: 12, stiffness: 100, mass: 1},
+};
+
+/** 阻尼比 ζ。设计系统文档普遍给 ζ（无量纲），Remotion 取阻尼系数 c——直抄会得
+ *  ζ≈0.02 的暴力弹跳且能通过渲染体检，这是迁移期最高风险项（单测钉死）。 */
+export const dampingRatio = (s: {
+  damping: number;
+  stiffness: number;
+  mass: number;
+}): number => s.damping / (2 * Math.sqrt(s.stiffness * s.mass));
+
+/** 欠阻尼弹簧的峰值位置（1 = 恰好到终点不过冲；ζ ≥ 1 恒 1）。
+ *  Mp = exp(-πζ/√(1-ζ²)) 是超出终点的幅度，峰值 = 1 + Mp。 */
+export const overshootPeak = (zeta: number): number =>
+  zeta >= 1 ? 1 : 1 + Math.exp((-Math.PI * zeta) / Math.sqrt(1 - zeta * zeta));
+
+/** 出场快于入场的系数（MDC 实测 400ms 入 / 150ms 出 ≈ 0.375，取 0.4 禁手填）。 */
+export const EXIT_FACTOR = 0.4;
+
+/** 字幕安全带上沿：1080 - qa_frames.SUBTITLE_BAND_PX(160)，与体检口径同源。 */
+export const SAFE_TOP_Y = 920;
+
+/** 自下方入场的行程安全钳制：落位态底边 restBottom 之上才是可用的进场空间。
+ *  ISSUE-170 的手工逐卡反算收敛于此——该缺陷类从「评审抽帧抓」变「构造不可能」。 */
+export const clampRiseDist = (
+  dist: number,
+  restBottom: number,
+  safeTop: number = SAFE_TOP_Y,
+): number => Math.max(0, Math.min(dist, safeTop - restBottom));
diff --git a/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/window.ts b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/window.ts
new file mode 100644
index 000000000..69bd59c7a
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-evolving-coding-agents-video/video/src/motion/window.ts
@@ -0,0 +1,43 @@
+/** 运动窗口纯函数——「父级持有绝对时间，子动画只是父进度上的窗口」。
+ *
+ * 这是 audio-first 时序与可复用运动模型兼容的核心机制：beat 的绝对帧来自
+ * beatWindow()（数据源是 TTS 实测 manifest），子动画不写死帧数、只声明自己在
+ * beat 进度上的 [start, end] 窗口 ⇒ 旁白实测时长变化时全部窗口自动重定时，
+ * 「写死帧数与口播脱钩」缺陷类（skills/08 实录）由构造消灭。
+ *
+ * 语义借 MDC TransitionUtils.lerp(startFraction, endFraction)：窗外钳制端点。
+ * 本模块零依赖（不 import remotion / theme）——frozen 跨系列共享与 node 单测的前提。
+ */
+
+/** 钳制到 [0,1]——一切进度的唯一出口，防负值/超 1 渗进 transform。 */
+export const clamp01 = (x: number): number => (x < 0 ? 0 : x > 1 ? 1 : x);
+
+/** 子动画窗口：父进度 p(0..1) 在 [s,e] 片段上的局部进度。 */
+export const win = (p: number, w: readonly [number, number]): number =>
+  clamp01((p - w[0]) / (w[1] - w[0]));
+
+/** beat 进度：局部帧 → 该 beat 的 0..1 进度。 */
+export const beatProgress = (
+  frame: number,
+  from: number,
+  durationInFrames: number,
+): number => clamp01((frame - from) / Math.max(1, durationInFrames));
+
+/** 帧域进度：[at, at+dur] 上的 0..1（dur ≤ 0 视作 1，防除零）。 */
+export const progress = (frame: number, at: number, dur: number): number =>
+  clamp01((frame - at) / Math.max(1, dur));
+
+/** 已过帧数 → 可见字符数；cps 随实际 fps 换算，显式帧间隔不受 fps 影响。 */
+export const revealCharCount = (
+  elapsedFrames: number,
+  fps: number,
+  cps: number,
+  framesPerChar?: number,
+): number => {
+  const elapsed = Math.max(0, elapsedFrames);
+  const count =
+    framesPerChar === undefined
+      ? Math.floor((elapsed / fps) * cps)
+      : Math.floor(elapsed / Math.max(1, framesPerChar));
+  return Math.max(0, count);
+};
diff --git a/apps/negentropy-influence/episodes/self-improving-agents-video/video/package.json b/apps/negentropy-influence/episodes/self-improving-agents-video/video/package.json
index 425279d55..c6e623823 100644
--- a/apps/negentropy-influence/episodes/self-improving-agents-video/video/package.json
+++ b/apps/negentropy-influence/episodes/self-improving-agents-video/video/package.json
@@ -19,10 +19,5 @@
   "devDependencies": {
     "@types/react": "^19.0.0",
     "typescript": "^5.6.0"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild"
-    ]
   }
 }
diff --git a/apps/negentropy-influence/episodes/self-improving-agents-video/video/pnpm-workspace.yaml b/apps/negentropy-influence/episodes/self-improving-agents-video/video/pnpm-workspace.yaml
index f2686ac7d..add822dbe 100644
--- a/apps/negentropy-influence/episodes/self-improving-agents-video/video/pnpm-workspace.yaml
+++ b/apps/negentropy-influence/episodes/self-improving-agents-video/video/pnpm-workspace.yaml
@@ -1,4 +1,9 @@
-# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的唯一理由。
+# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的首要理由。
 # pnpm 12 起仅靠 `--ignore-workspace` 不够：pnpm 仍会沿 packageManager 向上锚定到仓库根，
 # 用本工程的解析结果覆写根 pnpm-lock.yaml（overrides 全丢）且当场不报错。见 ISSUE-175。
 packages: []
+# pnpm 12 的构建脚本许可（package.json 的 pnpm.onlyBuiltDependencies 已不被读取，
+# 静默忽略会使安装以 ERR_PNPM_IGNORED_BUILDS 中断、node_modules 半残）。键名与取值
+# 与 `pnpm approve-builds esbuild --yes` 实际写入的形态逐字一致——勿改回旧键名。
+allowBuilds:
+  esbuild: true
diff --git a/apps/negentropy-influence/episodes/self-improving-agents-video/video/scripts/motion.test.ts b/apps/negentropy-influence/episodes/self-improving-agents-video/video/scripts/motion.test.ts
new file mode 100644
index 000000000..5e29cab52
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-improving-agents-video/video/scripts/motion.test.ts
@@ -0,0 +1,141 @@
+/**
+ * 运动层纯函数单测——`node --test scripts/motion.test.ts`（Node ≥ 23.6 原生跑 TS）。
+ *
+ * 刻意放在 video/ 而非 src/：tsconfig include 只有 src（frozen，不为测试改动），
+ * 而本文件 import 需带 .ts 后缀（Node ESM 解析规则）——tsc 若收编会因
+ * allowImportingTsExtensions 未开而报错。src/ 的类型覆盖由 tsc --noEmit 全量保证，
+ * 本文件只测纯函数行为，不做类型承重。
+ *
+ * 只 import 纯模块（tokens/window/schedule——零 remotion/react 依赖）：
+ * hooks 是它们的薄包装，行为由 MotionGallery 目视 + 场景抽帧覆盖。
+ */
+import {strict as assert} from 'node:assert';
+import test from 'node:test';
+
+import {DUR, EASING_CP, EXIT_FACTOR, SAFE_TOP_Y, SPRING, clampRiseDist, dampingRatio, overshootPeak} from '../src/motion/tokens.ts';
+import {beatProgress, clamp01, progress, revealCharCount, win} from '../src/motion/window.ts';
+import {schedule} from '../src/motion/schedule.ts';
+
+// ── tokens ────────────────────────────────────────────────────────────
+
+test('时长标尺在 30fps 下相邻档可辨（≥1 帧差）', () => {
+  const v = Object.values(DUR) as number[];
+  for (let i = 1; i < v.length; i++) {
+    assert.ok(v[i] - v[i - 1] >= 1, `第 ${i} 档与前一档同帧数（伪选择）`);
+  }
+  assert.ok(v.length === 6);
+});
+
+test('ζ→过冲换算钉死：snap 轻过冲、settle 零过冲（直抄 dampingRatio 的反例护栏）', () => {
+  const zSnap = dampingRatio(SPRING.snap);
+  const zSettle = dampingRatio(SPRING.settle);
+  assert.ok(zSnap > 0.4 && zSnap < 0.9, `snap ζ=${zSnap}`);
+  // Mp = exp(-πζ/√(1-ζ²)) 是超出幅度；峰值 = 1 + Mp（ζ=0.6 → 峰值 ≈1.095）
+  assert.ok(overshootPeak(zSnap) > 1.02 && overshootPeak(zSnap) < 1.2, `snap 峰值 ${overshootPeak(zSnap)}`);
+  assert.ok(zSettle > 1, 'settle 须过阻尼');
+  assert.equal(overshootPeak(zSettle), 1);
+  // 反例：把设计系统的 ζ 当 damping 直填（0.8）→ ζ≈0.04、峰值≈1.88 暴力弹跳
+  const wrong = dampingRatio({damping: 0.8, stiffness: 100, mass: 1});
+  assert.ok(overshootPeak(wrong) > 1.8, `直抄 ζ 的峰值=${overshootPeak(wrong)}，必须被此断言抓住`);
+});
+
+test('缓动控制点合法（CSS 规则 x∈[0,1]，且 x(t) 数值单调——可作函数求值）', () => {
+  for (const cp of Object.values(EASING_CP)) {
+    const [x1, , x2] = cp;
+    assert.ok(x1 >= 0 && x1 <= 1 && x2 >= 0 && x2 <= 1, `x 越界：${cp}`);
+    // x1<x2 是充分不必要（M3 standard (0.2,0,0,1) 的 x2<x1 仍单调）——判据用导数采样
+    for (let i = 0; i <= 50; i++) {
+      const t = i / 50;
+      const dx =
+        3 * (1 - t) ** 2 * x1 + 6 * (1 - t) * t * (x2 - x1) + 3 * t * t * (1 - x2);
+      assert.ok(dx > -1e-9, `x(t) 非单调 @t=${t}：${cp}`);
+    }
+  }
+});
+
+test('出场快于入场系数与安全带口径为常量', () => {
+  assert.equal(EXIT_FACTOR, 0.4);
+  assert.equal(SAFE_TOP_Y, 920);
+});
+
+test('clampRiseDist：自下方入场行程不探进字幕安全带', () => {
+  assert.equal(clampRiseDist(120, 836), 84, 'ISSUE-170 实测几何：rest 836 → 行程封顶 84');
+  assert.equal(clampRiseDist(40, 836), 40, '未超限不动');
+  assert.equal(clampRiseDist(120, 960), 0, '落位已在安全带内 → 零行程（退化但安全）');
+});
+
+// ── window ────────────────────────────────────────────────────────────
+
+test('clamp01 / progress / win 的钳制语义', () => {
+  assert.equal(clamp01(-1), 0);
+  assert.equal(clamp01(2), 1);
+  assert.equal(progress(10, 10, 10), 0, '起点为 0');
+  assert.equal(progress(20, 10, 10), 1, '终点为 1');
+  assert.equal(progress(5, 10, 10), 0, '窗外前钳 0');
+  assert.equal(progress(99, 10, 10), 1, '窗外后钳 1');
+  assert.equal(win(0.5, [0.25, 0.75]), 0.5);
+  assert.equal(win(0.1, [0.25, 0.75]), 0);
+  assert.equal(win(0.9, [0.25, 0.75]), 1);
+  assert.equal(beatProgress(0, -30, 90), 1 / 3);
+});
+
+test('逐字揭示：cps 按实际 fps 换算并向下取整，framesPerChar 保持固定帧间隔', () => {
+  assert.equal(revealCharCount(29, 60, 12), 5);
+  assert.equal(revealCharCount(30, 60, 12), 6);
+  assert.equal(revealCharCount(30, 24, 12, 3), 10);
+  assert.equal(revealCharCount(30, 120, 12, 3), 10);
+});
+
+// ── schedule ──────────────────────────────────────────────────────────
+
+test('fit 模式：末项恰在窗口末完成、不外溢', () => {
+  const p = schedule(5, {dur: 10, fit: {total: 90}});
+  const last = p.starts[4] + p.dur;
+  assert.ok(last <= 90 + 1, `末项 ${last} 外溢`);
+  assert.ok(last >= 89, `末项 ${last} 未到窗口末`);
+});
+
+test('fit 装不下时缩子项时长，不外溢窗口（优先级：不外溢 > 最小步长 > 子项时长）', () => {
+  // total 30 时 (30-12)/7≈2.57 ≥ minStride=2 仍装得下；压到 24 才触发缩时长
+  const p = schedule(8, {dur: 12, fit: {total: 24}});
+  const last = p.starts[7] + p.dur;
+  assert.ok(last <= 24, `末项 ${last} 外溢`);
+  assert.ok(p.dur >= 3, '子项时长跌破下限');
+  assert.ok(p.dur < 12, '装不下却未缩子项时长');
+});
+
+test('fit 窗口连 1 帧子项也容不下时显式拒绝，不返回外溢计划', () => {
+  assert.throws(() => schedule(8, {dur: 12, fit: {total: 5}}), /fit\.total=5.*8/);
+});
+
+test('fit 可行极限先牺牲子项时长，仍完整落在窗口内', () => {
+  const p = schedule(8, {dur: 12, fit: {total: 8}});
+  assert.equal(p.dur, 1);
+  assert.equal(p.starts[7] + p.dur, 8);
+});
+
+test('lag 模式：Manim 语义 start[i] = i·dur·lag', () => {
+  const p = schedule(3, {dur: 10, lag: 0.5});
+  assert.deepEqual(p.starts, [0, 5, 10]);
+  assert.deepEqual(schedule(3, {dur: 10, lag: 0}).starts, [0, 0, 0], 'lag=0 须同刻齐动');
+});
+
+test('stride 模式与三选一守卫', () => {
+  assert.deepEqual(schedule(3, {dur: 5, stride: 4}).starts, [0, 4, 8]);
+  assert.throws(() => schedule(3, {dur: 5, stride: 4, lag: 1}));
+  assert.throws(() => schedule(3, {dur: 5, lag: 1, fit: {total: 40}}));
+});
+
+test('最小步长与空集', () => {
+  assert.deepEqual(schedule(0, {dur: 5, stride: 4}), {starts: [], dur: 5});
+  const p = schedule(2, {dur: 5, stride: 0}); // 非法步长 → 抬到下限
+  assert.ok(p.starts[1] - p.starts[0] >= 1);
+});
+
+test('起点取整且单调不减', () => {
+  const p = schedule(6, {dur: 7, fit: {total: 53}});
+  for (let i = 1; i < p.starts.length; i++) {
+    assert.ok(p.starts[i] >= p.starts[i - 1], '起点须单调不减');
+    assert.ok(Number.isInteger(p.starts[i]));
+  }
+});
diff --git a/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/gallery.tsx b/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/gallery.tsx
new file mode 100644
index 000000000..a71737133
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/gallery.tsx
@@ -0,0 +1,265 @@
+/** MotionGallery——运动层的评审面（独立 Remotion 入口，不经 Root.tsx）。
+ *
+ * 用法（在 video/ 目录，.bin 直调防污染根 workspace）：
+ *   ./node_modules/.bin/remotion still src/motion/gallery.tsx MotionGallery \
+ *       out/motion-gallery.png --frame=30
+ *
+ * 全部模型 × 变体一屏可渲：秒级出图，供 token 校准轮逐格目视。
+ * 色板为本文件内字面量（dev 工具面，不进成片、不读 theme——保持 frozen 跨系列共享）。
+ */
+import React from 'react';
+import {AbsoluteFill, Composition, registerRoot} from 'remotion';
+import {
+  useAccelTravel,
+  useBreathe,
+  useCount,
+  useDim,
+  useDraw,
+  useEnter,
+  useFadeOut,
+  useFlowDash,
+  useImpulse,
+  usePushIn,
+  useReveal,
+  useShake,
+  useStagger,
+  useTravel,
+} from './hooks';
+
+const COLS = 5;
+const CW = 340;
+const CH = 230;
+const GAP = 18;
+
+/** dev 工具面字面量色板（与各集 theme 底座同值但刻意独立声明——不读 theme）。 */
+const C = {
+  bg: '#0E1116',
+  panel: '#171C26',
+  border: '#2A3242',
+  text: '#F2F5FA',
+  dim: '#9AA7B8',
+  core: '#D97757',
+  mech: '#64C4C0',
+  deny: '#EF6461',
+};
+
+/** 单元格壳：定位 + 角标。 */
+const Cell: React.FC<{i: number; name: string; children: React.ReactNode}> = ({i, name, children}) => (
+  <div
+    style={{
+      position: 'absolute',
+      left: 72 + (i % COLS) * (CW + GAP),
+      top: 96 + Math.floor(i / COLS) * (CH + GAP),
+      width: CW,
+      height: CH,
+      background: C.panel,
+      border: `2px solid ${C.border}`,
+      borderRadius: 12,
+    }}
+  >
+    <div
+      style={{
+        position: 'absolute',
+        inset: '28px 0 34px 0',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+      }}
+    >
+      {children}
+    </div>
+    <div style={{position: 'absolute', left: 12, bottom: 8, fontFamily: 'monospace', fontSize: 15, color: C.dim}}>
+      {name}
+    </div>
+  </div>
+);
+
+const Box: React.FC<{color?: string; w?: number; h?: number; style?: React.CSSProperties}> = ({
+  color = C.core,
+  w = 200,
+  h = 80,
+  style,
+}) => <div style={{width: w, height: h, background: C.panel, border: `2px solid ${color}`, borderRadius: 10, ...style}} />;
+
+// ── 每格一个组件：hooks 各归其位（Rules of Hooks 的最简守法形态） ────────
+
+const EnterCell: React.FC<{kind: Parameters<typeof useEnter>[0]}> = ({kind}) => {
+  const e = useEnter(kind, {});
+  return <Box style={{opacity: e.opacity, transform: e.transform}} />;
+};
+
+const StaggerCell: React.FC = () => {
+  const ps = useStagger(5, {dur: 5, fit: {total: 60}});
+  return (
+    <div style={{display: 'flex', gap: 10}}>
+      {ps.map((p, i) => (
+        <div
+          key={i}
+          style={{
+            width: 34,
+            height: 80,
+            background: C.panel,
+            border: `2px solid ${C.mech}`,
+            borderRadius: 8,
+            opacity: p,
+            transform: `translateY(${(1 - p) * 14}px)`,
+          }}
+        />
+      ))}
+    </div>
+  );
+};
+
+const DrawCell: React.FC = () => {
+  const d = useDraw(0, 24);
+  return (
+    <svg width={280} height={110}>
+      <path {...d} d="M10 90 C 90 10, 190 100, 270 20" stroke={C.core} strokeWidth={5} fill="none" strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ImpulseCell: React.FC = () => {
+  const g = useImpulse({dur: 30, peak: 1});
+  return (
+    <div
+      style={{
+        width: 90,
+        height: 90,
+        borderRadius: '50%',
+        background: C.core,
+        opacity: 0.3 + 0.7 * g,
+        boxShadow: `0 0 ${10 + 30 * g}px ${C.core}`,
+      }}
+    />
+  );
+};
+
+const BreatheCell: React.FC = () => {
+  const b = useBreathe({period: 30});
+  return (
+    <svg width={160} height={110}>
+      <circle cx={80} cy={55} r={40} fill="none" stroke={C.mech} strokeWidth={5} opacity={b} />
+    </svg>
+  );
+};
+
+const TravelCell: React.FC = () => {
+  const t = useTravel({cx: 140, cy: 55, r: 42, secPerLap: 3});
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} />
+      <circle cx={t.x} cy={t.y} r={9} fill={C.core} />
+    </svg>
+  );
+};
+
+const AccelCell: React.FC = () => {
+  const t = useAccelTravel({cx: 140, cy: 55, r: 42, durs: [28, 20, 14], at: 4});
+  const heat = `rgb(${217 + Math.round(38 * t.heat)}, ${119 - Math.round(60 * t.heat)}, ${87 - Math.round(20 * t.heat)})`;
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} strokeDasharray="4 6" />
+      <circle cx={t.x} cy={t.y} r={9} fill={heat} />
+    </svg>
+  );
+};
+
+const CountCell: React.FC = () => {
+  const v = useCount({to: 255, dur: 40});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 44, color: C.text, fontVariantNumeric: 'tabular-nums'}}>
+      {Math.round(v)}
+    </div>
+  );
+};
+
+const RevealCell: React.FC = () => {
+  const s = useReveal('while (true) { think(); act(); }', {cps: 14});
+  const blink = useBreathe({period: 16, amp: 0.5, base: 0.5});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 20, color: C.text, whiteSpace: 'nowrap'}}>
+      {s}
+      <span style={{opacity: blink}}>▍</span>
+    </div>
+  );
+};
+
+const PushInCell: React.FC = () => {
+  const t = usePushIn(0, {scale: 0.12});
+  return <Box w={160} h={90} color={C.mech} style={{transform: t}} />;
+};
+
+const DimCell: React.FC = () => {
+  const dim = useDim({at: 40, to: 0.35});
+  return (
+    <div style={{display: 'flex', gap: 12}}>
+      <Box w={64} h={80} style={{opacity: dim}} />
+      <Box w={64} h={80} color={C.core} />
+      <Box w={64} h={80} style={{opacity: dim}} />
+    </div>
+  );
+};
+
+const FlowCell: React.FC = () => {
+  const f = useFlowDash({period: 24});
+  return (
+    <svg width={280} height={60}>
+      <line x1={10} y1={30} x2={270} y2={30} stroke={C.mech} strokeWidth={5} {...f} strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ShakeCell: React.FC = () => {
+  const x = useShake({at: 10, amp: 5, decay: true, dur: 40});
+  return <Box w={150} h={80} color={C.deny} style={{transform: `translateX(${x}px)`}} />;
+};
+
+const FadeCell: React.FC = () => {
+  const op = useFadeOut(90, {frames: 36});
+  return (
+    <div style={{position: 'relative', width: 220, height: 90}}>
+      <Box w={220} h={90} color={C.core} style={{position: 'absolute', inset: 0}} />
+      <div style={{position: 'absolute', inset: 0, background: '#000', opacity: 1 - op}} />
+    </div>
+  );
+};
+
+const CELLS: Array<[string, React.ReactNode]> = [
+  ['enter:fall', <EnterCell kind="fall" />],
+  ['enter:rise', <EnterCell kind="rise" />],
+  ['enter:slideL', <EnterCell kind="slideL" />],
+  ['enter:pop', <EnterCell kind="pop" />],
+  ['enter:flyIn', <EnterCell kind="flyIn" />],
+  ['enter:fade', <EnterCell kind="fade" />],
+  ['stagger×5 fit60', <StaggerCell />],
+  ['draw 24f', <DrawCell />],
+  ['impulse 30f', <ImpulseCell />],
+  ['breathe p30', <BreatheCell />],
+  ['travel 3s/lap', <TravelCell />],
+  ['accelTravel', <AccelCell />],
+  ['count→255', <CountCell />],
+  ['reveal 14cps', <RevealCell />],
+  ['pushIn .12', <PushInCell />],
+  ['dim .35@40', <DimCell />],
+  ['flowDash p24', <FlowCell />],
+  ['shake decay', <ShakeCell />],
+  ['fadeOut 36f', <FadeCell />],
+];
+
+const MotionGallery: React.FC = () => (
+  <AbsoluteFill style={{background: C.bg}}>
+    <div style={{position: 'absolute', left: 72, top: 44, fontFamily: 'monospace', fontSize: 24, color: C.text}}>
+      MotionGallery · 30fps · 120f
+    </div>
+    {CELLS.map(([name, node], i) => (
+      <Cell key={name} i={i} name={name}>
+        {node}
+      </Cell>
+    ))}
+  </AbsoluteFill>
+);
+
+registerRoot(() => (
+  <Composition id="MotionGallery" component={MotionGallery} width={1920} height={1080} fps={30} durationInFrames={120} defaultProps={{}} />
+));
diff --git a/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/hooks.ts b/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/hooks.ts
new file mode 100644
index 000000000..f87b8a129
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/hooks.ts
@@ -0,0 +1,303 @@
+/** 运动模型（hooks）——分镜「动效」列动词到帧数学的唯一映射。
+ *
+ * 设计约束（违反任何一条即失去本层存在意义）：
+ * 1. hooks 返回数值 / CSS 片段，不渲染 DOM——FadeUp 式包装组件打不进 svg/<g>/
+ *    absolute 布局，是「组件存在却零调用」的实测根因；数值可落进任意 JSX。
+ * 2. 弹簧一律吃局部帧（frame - at）：spring() 每次调用从第 0 帧重模拟，喂全局帧
+ *    会让长片末帧每个 spring 跑两万余次迭代。
+ * 3. effects（不透明度/颜色）永不吃弹簧——一律时长+缓动（tokens 的二分不变量）。
+ * 4. 不读 theme：颜色一律经参数传入（frozen 跨系列共享的前提）。
+ * 5. `at` 锚点一律来自句边界（rel(beat, '句id')），禁写死帧数。
+ */
+import {Easing, interpolate, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {
+  DUR,
+  EASING_CP,
+  SPRING,
+  clampRiseDist,
+  type DurToken,
+  type EasingToken,
+  type SpringPreset,
+} from './tokens';
+import {progress, revealCharCount} from './window';
+import {schedule, type ScheduleOpts} from './schedule';
+
+/** 帧数解析：token 或直接帧数；缺省用 def。 */
+export const frames = (d: number | DurToken | undefined, def: number): number =>
+  d === undefined ? def : typeof d === 'number' ? d : DUR[d];
+
+/** 缓动令牌 → Remotion 缓动函数（linear 直通）。 */
+export const easeF = (t: EasingToken): ((x: number) => number) =>
+  t === 'linear'
+    ? Easing.linear
+    : Easing.bezier(
+        ...(EASING_CP[t] as [number, number, number, number]),
+      );
+
+/** 缓动后的 0..1 进度（各模型共用的原子）。 */
+const eased = (
+  frame: number,
+  at: number,
+  dur: number,
+  e: EasingToken,
+): number => interpolate(progress(frame, at, dur), [0, 1], [0, 1], {easing: easeF(e)});
+
+/** 缓动数值进度——「clamped 0→1 手写 interpolate」惯用形的统一替身：
+ *  时机值走 token，缓动默认 standard（线性原版会被这一档替换——质量提升点之一）。 */
+export function useProgress(
+  at: number,
+  dur: number | DurToken = DUR.f5,
+  easing: EasingToken = 'standard',
+): number {
+  const frame = useCurrentFrame();
+  return eased(frame, at, frames(dur, DUR.f5), easing);
+}
+
+/** 弹簧数值进度（驱动几何量/位移；effects 通道用 useProgress——tokens 二分不变量）。
+ *  局部帧 + 可选 durationInFrames 截停（防窗口外余振；缺省不设上限，与既有手写等价）。 */
+export function useSpring(
+  preset: SpringPreset,
+  o: {at?: number; dur?: number | DurToken} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const cfg: Parameters<typeof spring>[0] = {
+    frame: frame - (o.at ?? 0),
+    fps,
+    config: SPRING[preset],
+  };
+  if (o.dur !== undefined) {
+    cfg.durationInFrames = frames(o.dur, DUR.f5);
+  }
+  return spring(cfg);
+}
+
+// ── 入场（enter：落下/上浮/滑入/弹出/飞入/淡入） ────────────────────────
+
+export type EnterKind = 'fall' | 'rise' | 'slideL' | 'slideR' | 'pop' | 'flyIn' | 'fade';
+export type EnterOpts = {
+  /** 句边界锚（局部帧）。 */
+  at?: number;
+  dur?: number | DurToken;
+  easing?: EasingToken;
+  /** 空间通道用弹簧（位移类才有意义；fade/pop 无效）。 */
+  springPreset?: SpringPreset;
+  /** 位移像素（fall/rise/slide*；缺省 30）。 */
+  dist?: number;
+  /** rise 专用：落位态底边 y——行程经 clampRiseDist 钳进字幕安全带之上。 */
+  restBottom?: number;
+};
+export type EnterStyle = {opacity: number; transform: string};
+
+export function useEnter(kind: EnterKind, o: EnterOpts = {}): EnterStyle {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const at = o.at ?? 0;
+  const dur = frames(o.dur, DUR.f4);
+  let dist = o.dist ?? 30;
+  if (kind === 'rise' && o.restBottom !== undefined) {
+    dist = clampRiseDist(dist, o.restBottom);
+  }
+  // effects 通道：纯缓动、略快于空间通道（元素先「看见」再「落位」）
+  const opacity = progress(frame, at, Math.max(2, Math.round(dur * 0.8)));
+  // spatial 通道：可选弹簧（局部帧 + durationInFrames 截停，防窗口外余振）
+  const p = o.springPreset
+    ? spring({
+        frame: frame - at,
+        fps,
+        config: SPRING[o.springPreset],
+        durationInFrames: dur,
+      })
+    : eased(frame, at, dur, o.easing ?? 'standard');
+  const inv = 1 - p;
+  const t: string[] = [];
+  if (kind === 'fall') t.push(`translateY(${-inv * dist}px)`);
+  if (kind === 'rise') t.push(`translateY(${inv * dist}px)`);
+  if (kind === 'slideL') t.push(`translateX(${-inv * dist}px)`);
+  if (kind === 'slideR') t.push(`translateX(${inv * dist}px)`);
+  if (kind === 'pop') t.push(`scale(${0.9 + 0.1 * p})`);
+  if (kind === 'flyIn') t.push(`scale(${0.6 + 0.4 * p})`);
+  return {opacity, transform: t.length ? t.join(' ') : 'none'};
+}
+
+// ── 序列错峰（stagger：依次/逐行/逐条/逐格） ───────────────────────────
+
+export type StaggerOpts = ScheduleOpts & {at?: number; easing?: EasingToken};
+
+/** 返回 n 个 0..1 进度——第 i 项随编排依次入场。 */
+export function useStagger(n: number, o: StaggerOpts = {}): number[] {
+  const frame = useCurrentFrame();
+  const {at = 0, easing = 'standard'} = o;
+  const plan = schedule(n, o);
+  return plan.starts.map((s) => eased(frame, at + s, plan.dur, easing));
+}
+
+// ── 描线（draw：红线三由构造保证——只产 pathLength 归一化三元组） ────────
+
+export type DrawProps = {pathLength: 1; strokeDasharray: 1; strokeDashoffset: number};
+
+export function useDraw(at: number, dur: number | DurToken = DUR.f5): DrawProps {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(dur, DUR.f5), 'decelerate');
+  return {pathLength: 1, strokeDasharray: 1, strokeDashoffset: 1 - p};
+}
+
+// ── 脉冲 / 呼吸（glow 语法：impulse=一次性强调，breathe=持续辉光） ───────
+
+/** 一次性冲击：sin(πp) 包络，起于 0 归于 0，峰值 peak。 */
+export function useImpulse(o: {at?: number; dur?: number | DurToken; peak?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const p = progress(frame, o.at ?? 0, frames(o.dur, DUR.f5));
+  return Math.sin(Math.PI * p) * (o.peak ?? 1);
+}
+
+/** 持续呼吸（原 0.55+0.45·sin(frame/K) 散写的收敛；period 帧一周期——注意与
+ *  原除数 K 的换算 period = 2πK，如 sin(frame/26) → period 163）。offset 为相位
+ *  平移（错峰辉光的 per-index 形态）。 */
+export function useBreathe(
+  o: {period?: number; amp?: number; base?: number; offset?: number} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {amp = 0.45, base = 0.55, period = 26, offset = 0} = o;
+  return base + amp * Math.sin((2 * Math.PI * (frame - offset)) / period);
+}
+
+// ── 巡游（travel：环形为主；absorb 原 useRingDot 与加速绕行累加器克隆） ──
+
+export type TravelPos = {x: number; y: number; angle: number};
+
+/** 匀速环形巡游（angle 单位度，-90 = 12 点方向起）。 */
+export function useTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  secPerLap?: number;
+  offset?: number;
+}): TravelPos {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const lap = (frame / (fps * (o.secPerLap ?? 2.5)) + (o.offset ?? 0)) % 1;
+  const a = -90 + lap * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), angle: a};
+}
+
+/** 加速绕行：逐圈时长 durs[]（如 [40,30,22,16]），跑完全部圈后冻结在终点。
+ *  heat 0..1 随圈数推进（「失控感」的配色偏移系数）。 */
+export function useAccelTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  durs: number[];
+  at?: number;
+  heatPerLap?: number;
+}): {x: number; y: number; heat: number} {
+  const frame = useCurrentFrame();
+  let t = Math.max(0, frame - (o.at ?? 0));
+  let lap = 0;
+  while (lap < o.durs.length && t >= o.durs[lap]) {
+    t -= o.durs[lap];
+    lap += 1;
+  }
+  const within = lap >= o.durs.length ? 1 : t / o.durs[lap];
+  const heat = Math.min(1, lap / (o.heatPerLap ?? o.durs.length));
+  const a = -90 + within * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), heat};
+}
+
+// ── 计数 / 水位（meter 语法；显示层自行 Math.round / toFixed） ──────────
+
+export function useCount(o: {
+  from?: number;
+  to: number;
+  at?: number;
+  dur?: number | DurToken;
+  ease?: EasingToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {from = 0, to, at = 0} = o;
+  const p = eased(frame, at, frames(o.dur, DUR.f6), o.ease ?? 'standard');
+  return from + (to - from) * p;
+}
+
+// ── 打字机 / 逐字流出（type；Terminal 之外的泛化） ──────────────────────
+
+export function useReveal(
+  text: string,
+  o: {at?: number; cps?: number; framesPerChar?: number} = {},
+): string {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const elapsed = Math.max(0, frame - (o.at ?? 0));
+  const n = revealCharCount(elapsed, fps, o.cps ?? 12, o.framesPerChar);
+  return text.slice(0, Math.min(text.length, n));
+}
+
+// ── 镜头推近（pushIn 语法：beat 切换的镜头语言，替代纯淡入） ────────────
+
+export function usePushIn(at: number, o: {scale?: number; dur?: number | DurToken} = {}): string {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(o.dur, DUR.f5), 'decelerate');
+  return `scale(${1 + (o.scale ?? 0.06) * p})`;
+}
+
+// ── 压暗 / 提亮（emphasis 反向：让主体从群像中浮出） ─────────────────────
+
+/** 返回目标透明度系数（1 = 原；to 0.4 即压暗到 40%）。 */
+export function useDim(o: {at: number; to?: number; dur?: number | DurToken}): number {
+  const frame = useCurrentFrame();
+  const p = eased(frame, o.at, frames(o.dur, DUR.f4), 'standard');
+  return 1 + ((o.to ?? 0.4) - 1) * p;
+}
+
+// ── 流光（flow 语法：连线上的行进虚线） ─────────────────────────────────
+
+/** 返回可直接展开到 <line>/<path> 的描边属性（像素 dasharray——与 draw 的
+ *  pathLength 归一化描线是两个正交特性，勿混用于同一元素：红线三）。 */
+export function useFlowDash(o: {
+  dash?: number;
+  gap?: number;
+  /** 帧速率：每 period 帧行进一个 dash+gap 周期。 */
+  period?: number;
+}): {strokeDasharray: string; strokeDashoffset: number} {
+  const frame = useCurrentFrame();
+  const {dash = 10, gap = 14, period = 40} = o;
+  return {
+    strokeDasharray: `${dash} ${gap}`,
+    strokeDashoffset: -(frame * (dash + gap)) / period,
+  };
+}
+
+// ── 抖动（错误/故障语义；收敛 P2/P3 两处克隆） ──────────────────────────
+
+/** 返回 translateX 像素值。active 缺省 true；decay=true 时按 dur 衰减归零。 */
+export function useShake(o: {
+  at: number;
+  active?: boolean;
+  amp?: number;
+  /** 相位分母（原手写 /1.6、/2.2 的口径）。 */
+  freq?: number;
+  decay?: boolean;
+  dur?: number | DurToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {amp = 3, freq = 1.6} = o;
+  const t = frame - o.at;
+  if (o.active === false || t < 0) {
+    return 0;
+  }
+  if (o.decay) {
+    const env = 1 - progress(frame, o.at, frames(o.dur, DUR.f5));
+    return amp * env * Math.sin(t / freq);
+  }
+  return amp * Math.sin(t / freq);
+}
+
+// ── 片尾渐黑（红线四：从 beat 总时长推导，勿用末句时长） ────────────────
+
+export function useFadeOut(durationInFrames: number, o: {frames?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const f = o.frames ?? 36; // 1.2s
+  return 1 - progress(frame, durationInFrames - f, f);
+}
diff --git a/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/index.ts b/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/index.ts
new file mode 100644
index 000000000..97fd22a5c
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/index.ts
@@ -0,0 +1,5 @@
+/** 运动层门面——场景代码统一 `import {...} from '../motion'`。 */
+export * from './tokens';
+export * from './window';
+export * from './schedule';
+export * from './hooks';
diff --git a/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/schedule.ts b/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/schedule.ts
new file mode 100644
index 000000000..5703e3315
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/schedule.ts
@@ -0,0 +1,65 @@
+/** 错峰编排（stagger）纯函数——收敛手写 `frame - i*N`（跨 8 集约 356 处、
+ *  步长 K∈{2,3,4,5,6,8,10} 任意取值、无节奏标尺）。
+ *
+ * 三种模式（互斥，参数即文档）：
+ * - stride：固定步长（与旧手写行为一致——迁移期的保守选项）；
+ * - lag：Manim LaggedStart 语义 start[i] = i·dur·lagRatio（0 = 同刻齐动，1 = 首尾相接）；
+ * - fit：n 个子项恰好装进窗口 total（末项恰在窗口末完成——「随句推进」的首选）。
+ *
+ * 钳制优先级（motion.test.ts 钉死，自左向右）：不外溢窗口 > 最小步长 > 子项时长。
+ * 窗口属于 beat 时间轴，外溢会踩进下一 beat；装不下时先缩子项时长，连 1 帧
+ * 子项都无法错开时显式抛错，不返回违反 fit 契约的计划。
+ */
+export type ScheduleOpts = {
+  /** 子项时长（帧；缺省 DUR.f3=5——「快速子项」档）。 */
+  dur?: number;
+  /** 模式一：固定步长。 */
+  stride?: number;
+  /** 模式二：lag 比率（Manim lag_ratio）。 */
+  lag?: number;
+  /** 模式三：拟装入的窗口总长（帧）。 */
+  fit?: {total: number};
+  /** 相邻起点期望下限，默认 2 帧；fit 紧窗时可按优先级退至 1 帧。 */
+  minStride?: number;
+  /** 子项时长期望下限，默认 3 帧；fit 为守住窗口可退至 1 帧。 */
+  minDur?: number;
+};
+export type Schedule = {starts: number[]; dur: number};
+
+export function schedule(n: number, o: ScheduleOpts): Schedule {
+  const minStride = o.minStride ?? 2;
+  const minDur = o.minDur ?? 3;
+  const modes = [o.stride !== undefined, o.lag !== undefined, o.fit !== undefined].filter(
+    Boolean,
+  ).length;
+  if (modes > 1) {
+    throw new Error('schedule: stride / lag / fit 三选一');
+  }
+  let dur = Math.max(minDur, o.dur ?? 5);
+  if (n <= 0) {
+    return {starts: [], dur};
+  }
+  let stride: number;
+  if (o.fit) {
+    const total = Math.max(1, o.fit.total);
+    if (n > 1 && total < n) {
+      throw new Error(
+        `schedule: fit.total=${total} 无法容纳 ${n} 个至少 1 帧且起点间隔至少 1 帧的子项`,
+      );
+    }
+    dur = Math.min(dur, total);
+    stride = n === 1 ? 0 : (total - dur) / (n - 1);
+    const targetStride = Math.max(1, minStride);
+    if (n > 1 && stride < targetStride) {
+      // 先缩时长争取期望步长；仍不足时牺牲步长，但至少保留 1 帧先后。
+      dur = Math.max(1, Math.min(dur, total - targetStride * (n - 1)));
+      stride = (total - dur) / (n - 1);
+    }
+  } else if (o.lag !== undefined) {
+    stride = dur * o.lag;
+  } else {
+    stride = o.stride ?? minStride;
+  }
+  stride = Math.max(n === 1 || o.lag === 0 ? 0 : 1, stride);
+  return {starts: Array.from({length: n}, (_, i) => Math.round(i * stride)), dur};
+}
diff --git a/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/tokens.ts b/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/tokens.ts
new file mode 100644
index 000000000..457448260
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/tokens.ts
@@ -0,0 +1,87 @@
+/** 运动令牌——时长标尺 / 缓动曲线 / 弹簧手感 的单一事实源。
+ *
+ * 只放纯数据与纯函数：不 import remotion、不读 theme（颜色一律经参数注入）——
+ * 这是本层能以 frozen 档跨两个系列共享的前提（两系列 theme token 名已分叉：
+ * CC 用 core/mech/deny、SE 用 danger），判据同 test_chrome_motifs_only_read_base_theme_tokens。
+ *
+ * 取值依据（勿凭感觉改；改前先在本集校准轮逐幕目视复测，依据写回此处注释）：
+ * - 时长六档取 IBM Carbon DTCG（70/110/150/240/400/700ms）@30fps 四舍五入。
+ *   弃 Material 十六档：30fps 量化下其 15 个相邻对里 6 对落进同一帧数（伪选择）。
+ * - 缓动控制点取 Material 3 标准三件；曲线本体在 hooks.ts 经 Remotion Easing.bezier 求值。
+ * - 弹簧预设锚定本仓实测手感：settle=200 即既有 9/10 调用点的惯用值（延续成片观感），
+ *   snap=12 来自 P4「插头咬合」的过冲；ζ 与过冲峰值的关系由 motion.test.ts 用
+ *   Mp = exp(-πζ/√(1-ζ²)) 钉死。
+ * - effects 不变量：不透明度/颜色永不过冲——effects 类动画一律时长+缓动，
+ *   弹簧只用于空间位移（M3 spatial/effects 二分的落地）。
+ */
+
+/** 时长标尺（帧 @30fps）。叙事节拍（4–8s）不用此表——那是 window/schedule 的职责。 */
+export const DUR = {
+  /** 70ms：微反馈（辉光起点、光标） */
+  f1: 2,
+  /** 110ms：快速子项（列表错峰的单项时长） */
+  f2: 3,
+  /** 150ms：标准入场 */
+  f3: 5,
+  /** 200ms：强调入场 */
+  f4: 7,
+  /** 400ms：大位移 / 镜头推近 / 描线 */
+  f5: 12,
+  /** 700ms：幕级大动作（少用） */
+  f6: 21,
+} as const;
+export type DurToken = keyof typeof DUR;
+
+/** 缓动令牌。 */
+export type EasingToken = 'standard' | 'decelerate' | 'accelerate' | 'linear';
+
+/** 贝塞尔控制点（x1,y1,x2,y2）；linear 无控制点。 */
+export const EASING_CP: Record<
+  Exclude<EasingToken, 'linear'>,
+  readonly [number, number, number, number]
+> = {
+  // M3 standard：入场默认
+  standard: [0.2, 0, 0, 1],
+  // M3 decelerate：强减速（大位移入场、镜头推近）
+  decelerate: [0.05, 0.7, 0.1, 1],
+  // M3 accelerate：出场加速
+  accelerate: [0.3, 0, 0.8, 0.15],
+};
+
+/** 弹簧预设（直传 Remotion spring config；ζ = c/(2√(k·m))）。 */
+export type SpringPreset = 'settle' | 'settleSoft' | 'snap';
+export const SPRING: Record<SpringPreset, {damping: number; stiffness: number; mass: number}> = {
+  // ζ≈10：无过冲平滑滑入——本仓主流手感（既有场景 9/10 处 damping 200）
+  settle: {damping: 200, stiffness: 100, mass: 1},
+  // ζ≈8.5：更绵一点（P0/P1 既有 180/170 档的收敛）
+  settleSoft: {damping: 170, stiffness: 100, mass: 1},
+  // ζ≈0.6：轻微过冲（咬合/弹入——原 P4 damping 12）
+  snap: {damping: 12, stiffness: 100, mass: 1},
+};
+
+/** 阻尼比 ζ。设计系统文档普遍给 ζ（无量纲），Remotion 取阻尼系数 c——直抄会得
+ *  ζ≈0.02 的暴力弹跳且能通过渲染体检，这是迁移期最高风险项（单测钉死）。 */
+export const dampingRatio = (s: {
+  damping: number;
+  stiffness: number;
+  mass: number;
+}): number => s.damping / (2 * Math.sqrt(s.stiffness * s.mass));
+
+/** 欠阻尼弹簧的峰值位置（1 = 恰好到终点不过冲；ζ ≥ 1 恒 1）。
+ *  Mp = exp(-πζ/√(1-ζ²)) 是超出终点的幅度，峰值 = 1 + Mp。 */
+export const overshootPeak = (zeta: number): number =>
+  zeta >= 1 ? 1 : 1 + Math.exp((-Math.PI * zeta) / Math.sqrt(1 - zeta * zeta));
+
+/** 出场快于入场的系数（MDC 实测 400ms 入 / 150ms 出 ≈ 0.375，取 0.4 禁手填）。 */
+export const EXIT_FACTOR = 0.4;
+
+/** 字幕安全带上沿：1080 - qa_frames.SUBTITLE_BAND_PX(160)，与体检口径同源。 */
+export const SAFE_TOP_Y = 920;
+
+/** 自下方入场的行程安全钳制：落位态底边 restBottom 之上才是可用的进场空间。
+ *  ISSUE-170 的手工逐卡反算收敛于此——该缺陷类从「评审抽帧抓」变「构造不可能」。 */
+export const clampRiseDist = (
+  dist: number,
+  restBottom: number,
+  safeTop: number = SAFE_TOP_Y,
+): number => Math.max(0, Math.min(dist, safeTop - restBottom));
diff --git a/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/window.ts b/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/window.ts
new file mode 100644
index 000000000..69bd59c7a
--- /dev/null
+++ b/apps/negentropy-influence/episodes/self-improving-agents-video/video/src/motion/window.ts
@@ -0,0 +1,43 @@
+/** 运动窗口纯函数——「父级持有绝对时间，子动画只是父进度上的窗口」。
+ *
+ * 这是 audio-first 时序与可复用运动模型兼容的核心机制：beat 的绝对帧来自
+ * beatWindow()（数据源是 TTS 实测 manifest），子动画不写死帧数、只声明自己在
+ * beat 进度上的 [start, end] 窗口 ⇒ 旁白实测时长变化时全部窗口自动重定时，
+ * 「写死帧数与口播脱钩」缺陷类（skills/08 实录）由构造消灭。
+ *
+ * 语义借 MDC TransitionUtils.lerp(startFraction, endFraction)：窗外钳制端点。
+ * 本模块零依赖（不 import remotion / theme）——frozen 跨系列共享与 node 单测的前提。
+ */
+
+/** 钳制到 [0,1]——一切进度的唯一出口，防负值/超 1 渗进 transform。 */
+export const clamp01 = (x: number): number => (x < 0 ? 0 : x > 1 ? 1 : x);
+
+/** 子动画窗口：父进度 p(0..1) 在 [s,e] 片段上的局部进度。 */
+export const win = (p: number, w: readonly [number, number]): number =>
+  clamp01((p - w[0]) / (w[1] - w[0]));
+
+/** beat 进度：局部帧 → 该 beat 的 0..1 进度。 */
+export const beatProgress = (
+  frame: number,
+  from: number,
+  durationInFrames: number,
+): number => clamp01((frame - from) / Math.max(1, durationInFrames));
+
+/** 帧域进度：[at, at+dur] 上的 0..1（dur ≤ 0 视作 1，防除零）。 */
+export const progress = (frame: number, at: number, dur: number): number =>
+  clamp01((frame - at) / Math.max(1, dur));
+
+/** 已过帧数 → 可见字符数；cps 随实际 fps 换算，显式帧间隔不受 fps 影响。 */
+export const revealCharCount = (
+  elapsedFrames: number,
+  fps: number,
+  cps: number,
+  framesPerChar?: number,
+): number => {
+  const elapsed = Math.max(0, elapsedFrames);
+  const count =
+    framesPerChar === undefined
+      ? Math.floor((elapsed / fps) * cps)
+      : Math.floor(elapsed / Math.max(1, framesPerChar));
+  return Math.max(0, count);
+};
diff --git a/apps/negentropy-influence/pipeline/README.md b/apps/negentropy-influence/pipeline/README.md
index a5cda4e52..542f09b83 100644
--- a/apps/negentropy-influence/pipeline/README.md
+++ b/apps/negentropy-influence/pipeline/README.md
@@ -137,8 +137,9 @@ schema、默认值与校验的单一事实源是 [scripts/config.py](./scripts/c
 ## 四、复用边界（显式权衡）
 
 - **Python 脚本：集中共享（SSOT）**——三个纯文本变换工具，跨集零差异，中心化防 split-brain。
-- **Remotion 工程原语：复制适配，不做共享包**——`timing.ts` / `Subtitle` / `cards.tsx` / `theme.ts` 等每集复制后按本集视觉契约修改。理由：每集工程须保持 pnpm `--ignore-workspace` 独立可渲染（嵌套 workspace 隔离 + Remotion 版本自由），共享 TS 包会把「一集的视觉改动」泄漏进其他集。**复制源头是 [templates/video-skeleton/](./templates/video-skeleton/)**（15 个 frozen 文件 + skeleton.toml 档位清单），新集用 `scaffold.py` 实例化、「改任何一处须同步」由 `verify_skeleton.py` 机器执法——此前「以任一既有集为模板」的说法等于给 391 行冻结基建设 4 个同权真理声明者，且纸面义务从未被执行过（详见 skeleton.toml 内注）。同类做法：`go mod vendor` + `go mod verify`（物理副本 + 校验门）、Copier（模板 + 应答记录）。
+- **Remotion 工程原语：复制适配，不做共享包**——`timing.ts` / `Subtitle` / `cards.tsx` / `theme.ts` 等每集复制后按本集视觉契约修改。理由：每集工程须保持 pnpm `--ignore-workspace` 独立可渲染（嵌套 workspace 隔离 + Remotion 版本自由），共享 TS 包会把「一集的视觉改动」泄漏进其他集。**复制源头是 [templates/video-skeleton/](./templates/video-skeleton/)**（frozen 文件清单以 skeleton.toml 为准，勿在文档里维护数字），新集用 `scaffold.py` 实例化、「改任何一处须同步」由 `verify_skeleton.py` 机器执法——此前「以任一既有集为模板」的说法等于给 391 行冻结基建设 4 个同权真理声明者，且纸面义务从未被执行过（详见 skeleton.toml 内注）。同类做法：`go mod vendor` + `go mod verify`（物理副本 + 校验门）、Copier（模板 + 应答记录）。
 - **每集视觉契约独立设计**（色彩语义映射到本集核心概念），但底层规范复用：深色底 `#0E1116` 系、警示红 `#FF5C5C`、确认绿 `#7ED321`、金句卡衬线体、公式只作角标彩蛋。
+- **运动层（`video/src/motion/`，frozen）：共享的是「怎么动」，不是「画什么」**——时长/缓动/弹簧/错峰/巡游等时序语汇跨集一致（同一只手感），theme/motifs/场景构图仍各集自由。2026-09 重制 EP1 时引入：令牌（Carbon 六档时长 + M3 缓动 + 本仓实测弹簧手感）+ 窗口/编排纯函数 + 12 个运动模型 hooks + MotionGallery 评审面，规格与铁律见 [skills/06 运动层](./skills/06-remotion-implementation.md)。不读 theme token（两系列概念色名已分叉）是其可 frozen 的前提，由 tests/test_skeleton.py 执法。
 
 ## 五、音画同步机制（零手工对轨）
 
@@ -157,16 +158,15 @@ schema、默认值与校验的单一事实源是 [scripts/config.py](./scripts/c
    **刻意不生成 scenes/**（样例留在模板里）、不改根 `.gitignore`（已通配到分集级）、不写 series.json。
    跑完立刻 `uv run --no-project $R/verify_skeleton.py` 确认新集与模板零漂移。
 2. `theme.ts` 换本集概念色；`video/src/scenes/*` 与 `Main.tsx` 注册表全部新写。
-3. `cd video && pnpm install --ignore-workspace`（必须显式忽略根 workspace；`onlyBuiltDependencies: [esbuild]` 已在 package.json）；装完检查根 lockfile 零变更。
+3. `cd video && pnpm install --ignore-workspace`（必须显式忽略根 workspace；构建脚本许可已在
+   `video/pnpm-workspace.yaml` 的 `allowBuilds.esbuild` 配置）；装完检查根 lockfile 零变更。
    > pnpm 12 起只声明 `--ignore-workspace` 不够：pnpm 仍会沿 `packageManager` 向上锚定到仓库根，
    > **覆写根 `pnpm-lock.yaml`** 且当场不报错。隔离由 `video/pnpm-workspace.yaml` 真正兜住
    > （[ISSUE-175](../../../docs/.agents/issue.md)）。
-   > pnpm ≥ 11 会提示 `package.json` 的 `pnpm` 字段不再被读取，并报 `ERR_PNPM_IGNORED_BUILDS: esbuild`
-   > （[ISSUE-076](../../../docs/.agents/issue.md)）。**已实测确认对本工程无害**：esbuild 的平台二进制
-   > 是 optionalDependency，落地不依赖 postinstall —— 旧写法下 `remotion bundle` 端到端通过。
-   > 故**刻意不改** `.npmrc`/`package.json` 去消掉这条提示（改了会让 A 档冻结文件产生一处
-   > 只为静音噪声的跨集差异）。真正需要 postinstall 的依赖若将来出现，再按官方新家
-   > `pnpm-workspace.yaml` 的 `allowBuilds` 处理。
+   > pnpm ≥ 11 已不再读取 `package.json` 的 `pnpm.onlyBuiltDependencies`；构建脚本许可统一放在
+   > `pnpm-workspace.yaml` 的 `allowBuilds`（[ISSUE-076](../../../docs/.agents/issue.md)）。骨架已显式允许
+   > `esbuild`，勿改回旧字段；缺失该许可会以 `ERR_PNPM_IGNORED_BUILDS` 中断安装并留下半残
+   > `node_modules`。
 4. **登记到 [../series.json](../series.json)**（阻塞门：`check_series.py` 规则 4 反向执法——
    未登记目录一旦写下 `script/narration.md` 即 FAIL；脚手架期为 WARN 分级）：顶层是 `seriesList[]`，新系列追加一个 series 对象
    （`id` / `title` / `sourceKind` / `rule` / `episodes`），既有系列的新集追加到其 `episodes`。
diff --git a/apps/negentropy-influence/pipeline/scripts/build_narration.py b/apps/negentropy-influence/pipeline/scripts/build_narration.py
index e4454b45b..a9a280323 100644
--- a/apps/negentropy-influence/pipeline/scripts/build_narration.py
+++ b/apps/negentropy-influence/pipeline/scripts/build_narration.py
@@ -119,6 +119,50 @@ def main() -> None:
             f"发音标注: {marked} 句带 ttsText（字数与字幕仍取剥离后的 text）"
             + ("" if vocab else "；未找到 pinyin.vocab，已跳过「音节是否在表内」告警")
         )
+    emit_series_layers(root)
+
+
+def emit_series_layers(root: Path) -> None:
+    """series.json → video/src/series-layers.json（系列身份装置的数据面）。
+
+    skills/06 五层 Harness 栈的层序/层名**必须**从 series.json 派生（硬编码即漂移）；
+    Remotion 的打包根是 video/，读不到工程外文件，故由本脚本每次 build 重派生落盘。
+    仅取本集所属系列；集不在任何系列（脚手架期）则跳过不写。层短名取 cardSub
+    首段（「执行层 · 循环」→「执行层」）。next 为下一集标题（P6 呼吸预告用）。
+    """
+    series_json = root.parent.parent / "series.json"
+    if not series_json.is_file():
+        return
+    series_list = json.loads(series_json.read_text(encoding="utf-8"))["seriesList"]
+    for series in series_list:
+        eps = series["episodes"]
+        for k, ep in enumerate(eps):
+            if ep["path"] != f"episodes/{root.name}":
+                continue
+            layers = [
+                {
+                    "index": i + 1,
+                    "layer": e["cardSub"].split(" · ")[0],
+                    "title": e["title"],
+                    "published": e.get("status") == "ready"
+                    and "已上线" in e.get("voice", ""),
+                }
+                for i, e in enumerate(eps)
+            ]
+            payload = {
+                "seriesId": series["id"],
+                "layers": layers,
+                "activeIndex": k + 1,
+                "next": eps[k + 1]["title"] if k + 1 < len(eps) else None,
+            }
+            out = root / "video" / "src" / "series-layers.json"
+            out.parent.mkdir(parents=True, exist_ok=True)
+            out.write_text(
+                json.dumps(payload, ensure_ascii=False, indent=1) + "\n",
+                encoding="utf-8",
+            )
+            print(f"系列层: {series['id']} 第 {k + 1}/{len(eps)} 集 · layers 已派生")
+            return
 
 
 if __name__ == "__main__":
diff --git a/apps/negentropy-influence/pipeline/scripts/check_script.py b/apps/negentropy-influence/pipeline/scripts/check_script.py
index b5d338174..164a6b5a4 100644
--- a/apps/negentropy-influence/pipeline/scripts/check_script.py
+++ b/apps/negentropy-influence/pipeline/scripts/check_script.py
@@ -14,6 +14,13 @@
 可选 --check-scenes：从 video/src/scenes/*.tsx 提取 beatWindow/w('id','id')
 调用，与分镜表互比（WARN-only，TSX 正则本质近似）。
 
+可选 --check-motion：分镜「动效」列的 @动词 标注 ↔ 场景代码运动模型调用互比
+（WARN-only）。动效列可写 `@enter:fall`、`@stagger`、`@draw` 等（动词表从本集
+video/src/motion/hooks.ts 的 use* 导出**派生**，单一事实源不复制）；镜内声明了
+@动词 而该幕场景文件未调用对应 use 模型 → WARN——「FadeUp 写在分镜里却没进代码」
+（本仓实测发生过 3 处）这一缺陷类的机械化。反向（代码用了模型而分镜没写）不报：
+动效列是意图摘要而非全量清单。
+
 可选 --pre-tts（TTS 前置门）：只跑**不需要分镜**的检查——时长预算（估算口径；
 manifest 若在则含实测口径）+ 读法陷阱 + 发音标注合法性（build_narration 已在
 生成期拦非法标注，此处对 narration.json 再收口一遍）。两遍法草稿遍（A 遍）写完
@@ -279,6 +286,63 @@ def check_scenes(
         warn(msgs, f"场景代码区间 {pair[0]}..{pair[1]} 未在分镜表中登记（分镜陈旧）")
 
 
+#: 动效列的结构化标注：`@enter:fall` / `@stagger` / `@accelTravel` …
+MOTION_TAG_RE = re.compile(r"@([A-Za-z][A-Za-z0-9]*)")
+
+
+def parse_motion_tags(board: Path) -> list[tuple[str, str]]:
+    """返回 [(镜号, 动词)]。动效列 = 表格行第 4 单元格（| 镜 | 句区间 | 画面 | 动效 |）。"""
+    tags: list[tuple[str, str]] = []
+    for raw in board.read_text(encoding="utf-8").splitlines():
+        if not raw.startswith("|") or "---" in raw:
+            continue
+        cells = [c.strip() for c in raw.strip().strip("|").split("|")]
+        if len(cells) < 4 or not re.match(r"^\d+-[A-Z]\d*$", cells[0]):
+            continue
+        for m in MOTION_TAG_RE.finditer(cells[3]):
+            tags.append((cells[0], m.group(1)))
+    return tags
+
+
+def check_motion(root: Path, msgs: list[str]) -> None:
+    """@动词 标注 ↔ 场景代码运动模型调用互比（WARN-only）。
+
+    动词表从本集 video/src/motion/hooks.ts 派生（use 词首字母小写化），
+    不在本文件复制第二份——hooks.ts 加模型，这里自动跟随。
+    """
+    board = root / "script" / "storyboard.md"
+    hooks_ts = root / "video" / "src" / "motion" / "hooks.ts"
+    if not hooks_ts.is_file():
+        return  # 运动层未铺设的集（如已冻结的旧集）——此门静默不适用
+    verbs = {
+        m.group(1)[0].lower() + m.group(1)[1:]
+        for m in re.finditer(
+            r"export (?:async )?function use(\w+)", hooks_ts.read_text(encoding="utf-8")
+        )
+    }
+    # 场景文件 → 该文件调用的运动模型（import 来源限定 ../motion，防同名误配）
+    scenes_dir = root / "video" / "src" / "scenes"
+    per_file: dict[str, set[str]] = {}
+    for tsx in sorted(scenes_dir.glob("*.tsx")):
+        src = tsx.read_text(encoding="utf-8")
+        used = set()
+        if re.search(r"from ['\"]\.\./motion['\"]", src):
+            for m in re.finditer(r"\buse([A-Z][A-Za-z0-9]*)\s*\(", src):
+                v = m.group(1)[0].lower() + m.group(1)[1:]
+                if v in verbs:
+                    used.add(v)
+        per_file[tsx.name] = used
+    # beat 镜号数字前缀 → 幕场景文件（0-A → P0*.tsx）
+    for beat, verb in parse_motion_tags(board):
+        if verb not in verbs:
+            warn(msgs, f"镜 {beat}：@{verb} 不在运动模型词表（hooks.ts 派生；拼写？）")
+            continue
+        scene_pref = f"P{beat.split('-')[0]}"
+        owners = [n for n in per_file if n.startswith(scene_pref)]
+        if not owners or not any(verb in per_file[n] for n in owners):
+            warn(msgs, f"镜 {beat}：分镜声明 @{verb}，但 {scene_pref} 场景代码未调用")
+
+
 def main() -> None:
     ap = argparse.ArgumentParser(description="④⑤ 内容门：覆盖性/预算/淡入不变式")
     ap.add_argument("--project", default=".", help="视频工程根目录")
@@ -287,6 +351,11 @@ def main() -> None:
         action="store_true",
         help="附:分镜↔场景代码 beat 互比（WARN-only）",
     )
+    ap.add_argument(
+        "--check-motion",
+        action="store_true",
+        help="附:分镜动效列 @动词 标注 ↔ 场景代码运动模型互比（WARN-only）",
+    )
     ap.add_argument(
         "--pre-tts",
         action="store_true",
@@ -354,6 +423,8 @@ def main() -> None:
         check_fade_invariant(root, msgs)
         if args.check_scenes:
             check_scenes(root, beats, msgs)
+        if args.check_motion:
+            check_motion(root, msgs)
 
     fails = [m for m in msgs if m.startswith("FAIL")]
     warns = [m for m in msgs if m.startswith("WARN")]
diff --git a/apps/negentropy-influence/pipeline/scripts/pipeline.py b/apps/negentropy-influence/pipeline/scripts/pipeline.py
index f665af55d..929c2410f 100644
--- a/apps/negentropy-influence/pipeline/scripts/pipeline.py
+++ b/apps/negentropy-influence/pipeline/scripts/pipeline.py
@@ -187,8 +187,14 @@ def cmd_build(root: Path, _cfg: dict) -> int:
     return run(uv_no_project("build_narration.py", [], project=root))
 
 
-def cmd_check(root: Path, _cfg: dict, scenes: bool = False) -> int:
-    extra = ["--check-scenes"] if scenes else []
+def cmd_check(
+    root: Path, _cfg: dict, scenes: bool = False, motion: bool = False
+) -> int:
+    extra = []
+    if scenes:
+        extra.append("--check-scenes")
+    if motion:
+        extra.append("--check-motion")
     return run(uv_no_project("check_script.py", [], *extra, project=root))
 
 
@@ -201,6 +207,7 @@ def cmd_tts(
     style: str | None,
     allow_voice_switch: bool = False,
     skip_pre_tts: bool = False,
+    no_store: bool = False,
 ) -> int:
     if not skip_pre_tts:
         # TTS 前置门：预算/读法陷阱/标注合法性都是「合成前可判定的文本门」——
@@ -249,6 +256,8 @@ def cmd_tts(
         # 两遍法经单入口的放行阀：.engine 签名护栏会拦「换风格=整集重录」，
         # 草稿遍(A)/定稿遍(B)任一换档都须显式带上（护栏原理见 tts.py §音色签名）
         cmd.append("--allow-voice-switch")
+    if no_store:
+        cmd.append("--no-store")
     return run(cmd, cwd=root)
 
 
@@ -287,15 +296,21 @@ def cmd_qa(
     ids: list[str],
     check: bool,
     scale: float | None,
+    beat_heads: int | None = None,
+    compare: list[str] | None = None,
 ) -> int:
     cmd = ["uv", "run", "--no-project"]
-    if check:
+    if check or compare:
         cmd += ["--with", "pillow", "--with", "numpy"]
     cmd += [str(SCRIPTS / "qa_frames.py"), "--project", str(root)]
     for s in scene or []:
         cmd += ["--scene", s]
     if last_n:
         cmd += ["--last-n", str(last_n)]
+    if beat_heads:
+        cmd += ["--beat-heads", str(beat_heads)]
+    if compare:
+        cmd += ["--compare", *compare]
     if check:
         cmd += ["--check"]
         # 字幕带/亮块间隔是全分辨率像素常数：草渲（0.5x）不折算则带高×2、间隔×2，
@@ -483,11 +498,21 @@ def main() -> None:
         action="store_true",
         help="附:分镜↔场景代码 beat 互比（WARN-only）",
     )
+    p.add_argument(
+        "--check-motion",
+        action="store_true",
+        help="附:分镜动效标注↔场景运动模型互比（WARN-only）",
+    )
     sub.add_parser("captions", help="⑥+ 导出 srt/vtt")
     sub.add_parser("clean-samples", help="清理 .temp/voice-samples（生物特征）")
     p = sub.add_parser("tts", help="⑥ 配音合成（参数来自 pipeline.toml）")
     p.add_argument("--plan", action="store_true", help="只看排期不实跑")
     p.add_argument("--force", action="store_true", help="忽略缓存")
+    p.add_argument(
+        "--no-store",
+        action="store_true",
+        help="禁用 IndexTTS 音频版本库",
+    )
     p.add_argument("--steady", help="混合档选择器")
     p.add_argument("--style", help="覆写风格（两遍法草稿遍用 --style sunny）")
     p.add_argument(
@@ -513,6 +538,18 @@ def main() -> None:
     # 与 qa_frames 对齐：可重复传多幕（单值 store 会静默只留末幕，见 qa_frames 注释）
     p.add_argument("--scene", action="append", metavar="Pn")
     p.add_argument("--last-n", type=int)
+    p.add_argument(
+        "--beat-heads",
+        type=int,
+        metavar="N",
+        help="每 beat 头部连抽 N 帧（入场瞬态补盲，ISSUE-170）",
+    )
+    p.add_argument(
+        "--compare",
+        nargs=2,
+        metavar=("A.mp4", "B.mp4"),
+        help="A/B 对拍（重制/重构回归归因；advisory）",
+    )
     p.add_argument("--check", action="store_true", help="自动体检")
     p.add_argument(
         "--scale",
@@ -550,7 +587,7 @@ def main() -> None:
         "status": lambda: cmd_status(root, cfg),
         "doctor": lambda: cmd_doctor(root, cfg, origin),
         "build": lambda: cmd_build(root, cfg),
-        "check": lambda: cmd_check(root, cfg, args.check_scenes),
+        "check": lambda: cmd_check(root, cfg, args.check_scenes, args.check_motion),
         "tts": lambda: cmd_tts(
             root,
             cfg,
@@ -560,6 +597,7 @@ def main() -> None:
             args.style,
             args.allow_voice_switch,
             args.skip_pre_tts,
+            args.no_store,
         ),
         "captions": lambda: cmd_captions(root, cfg),
         "render": lambda: cmd_render(root, cfg, args.final),
@@ -572,6 +610,8 @@ def main() -> None:
             args.ids,
             args.check,
             args.scale,
+            getattr(args, "beat_heads", None),
+            getattr(args, "compare", None),
         ),
         "all": lambda: cmd_all(root, cfg),
         "clean-samples": lambda: cmd_clean_samples(root, cfg),
diff --git a/apps/negentropy-influence/pipeline/scripts/qa_frames.py b/apps/negentropy-influence/pipeline/scripts/qa_frames.py
index 55e762185..a063ec0e9 100644
--- a/apps/negentropy-influence/pipeline/scripts/qa_frames.py
+++ b/apps/negentropy-influence/pipeline/scripts/qa_frames.py
@@ -9,6 +9,16 @@
     <video.mp4> --scene P1         该幕抽样至多 ~8 帧
     <video.mp4> --last-n 6         末 N 句——直指「末句短于 beat → 渐黑提前 → 长黑尾」
                                    上线 bug 的抽样盲区（尾幕必查）
+    <video.mp4> --beat-heads N [--scene P4]
+                                   每 beat 头部连抽 N 帧（0..N-1）——ISSUE-170 的机械
+                                   补盲：句中点采样结构性错过亚秒入场瞬态。可与 --scene
+                                   组合过滤幕。此模式 --check 关闭冻帧判定（静止 beat
+                                   的头帧指纹相同是合法态）
+A/B 对拍（有帧时 advisory；零匹配帧硬失败，供重制/重构回归归因）：
+    --compare A.mp4 B.mp4 --scene P4|<句id>…
+                                   同帧号抽 A/B 两版逐帧差异（meanΔ / 差异像素占比 /
+                                   变化区域 bbox），按占比降序——「不外溢的意图变更」
+                                   之外的一切差异都应被归因后再接受
 
 自动体检（--check，惰性依赖 pillow+numpy）：
     黑帧/早渐黑    帧平均相对亮度 < 0.02 → FAIL（仅末 beat 且分镜末行写「渐黑」时豁免）
@@ -113,6 +123,59 @@ def stills_plan(root: Path, chars_per_sec: float) -> None:
         )
 
 
+def beat_head_samples(
+    beats: list[tuple[str, str, str, str]],
+    tl: dict[str, tuple[float, float]],
+    fps: int,
+    n: int,
+    offset: float = 0.0,
+    scene_filter: list[str] | None = None,
+) -> list[tuple[str, float]]:
+    """每 beat 头部连抽 N 帧的 (帧名, 时间戳)。beat 起点 = 其首句 start。
+
+    纯函数（tests/test_qa_checks 对拍黄金帧号）。scene_filter 形如 ['P4']：按
+    镜号数字前缀过滤（0-A → P0）。区间首句不在 manifest 时跳过该 beat（分镜陈旧）。
+    """
+    samples: list[tuple[str, float]] = []
+    for beat_id, left, _right, _cell in beats:
+        if scene_filter and beat_id.split("-")[0] not in {
+            sf.upper().lstrip("P") for sf in scene_filter
+        }:
+            continue
+        if left not in tl:
+            continue
+        start = tl[left][0]
+        for i in range(max(1, n)):
+            samples.append((f"{beat_id}-h{i}", start + i / fps - offset))
+    return samples
+
+
+def frame_diff(a: Path, b: Path) -> dict:
+    """两帧的差异摘要（纯函数，供 --compare 与单测）。
+
+    mean：RGB 三通道平均绝对差（0-255）；frac：任一通道差 > DIFF_JND 的像素占比；
+    bbox：差异像素的包围盒 (x0, y0, x1, y1)，全同帧为 None。JND 取 12——抗 jpeg
+    压缩噪声的经验下限，非感知模型。
+    """
+    import numpy as np
+    from PIL import Image
+
+    A = np.asarray(Image.open(a).convert("RGB"), dtype=np.float32)
+    B = np.asarray(Image.open(b).convert("RGB"), dtype=np.float32)
+    if A.shape != B.shape:
+        return {"mean": 255.0, "frac": 1.0, "bbox": None, "shape_mismatch": True}
+    d = np.abs(A - B).max(axis=2)
+    mask = d > DIFF_JND
+    if not mask.any():
+        return {"mean": float(np.abs(A - B).mean()), "frac": 0.0, "bbox": None}
+    ys, xs = np.nonzero(mask)
+    return {
+        "mean": float(np.abs(A - B).mean()),
+        "frac": float(mask.mean()),
+        "bbox": (int(xs.min()), int(ys.min()), int(xs.max()), int(ys.max())),
+    }
+
+
 def extract_frame(
     ffmpeg: list[str], video: Path, cwd: Path, ts: float, dst: Path
 ) -> None:
@@ -164,6 +227,8 @@ def extract_frame(
 #: 侵入物最小宽度（全分辨率像素，随 scale 折算）：窄于此的多是抗锯齿碎片
 INTRUSION_MIN_W_PX = 24
 CONTRAST_MIN = 4.5
+#: A/B 对拍的逐像素刚可辨差异（just-noticeable diff 的经验值）
+DIFF_JND = 12
 
 
 def bright_segments(col, threshold: float) -> list[tuple[int, int]]:
@@ -255,7 +320,13 @@ def tail_row_has_fade(board: Path) -> bool:
 
 
 def check_frames(
-    out: Path, ids: list[str], scale: float, fade_exempt_last: bool, msgs: list[str]
+    out: Path,
+    ids: list[str],
+    scale: float,
+    fade_exempt_last: bool,
+    msgs: list[str],
+    freeze_check: bool = True,
+    subtitle_check: bool = True,
 ) -> None:
     try:
         import numpy as np
@@ -284,7 +355,9 @@ def check_frames(
             )
         band = img[img.shape[0] - band_px :, :] if band_px else img
         bright_px = float((band > TEXT_BRIGHTNESS).mean())
-        if bright_px == 0:
+        # 字幕缺失只在句中点采样下有意义：beat 头帧落在句首淡入与句间空隙，
+        # 无字幕是合法态（--beat-heads 传 subtitle_check=False）
+        if subtitle_check and bright_px == 0:
             msgs.append(f"WARN {sid}: 字幕带内无文字亮度像素（字幕缺失？）")
         elif band_px > box_h_px:
             # 侵入检测按**几何**做（见 SUBTITLE_BOX_H_PX 注释）：只看字幕框上方那条窄带，
@@ -300,10 +373,11 @@ def check_frames(
             np.asarray(Image.open(png).convert("L").resize((16, 16)))
         )
 
-    for (a, _), (b, _) in zip(ordered, ordered[1:], strict=False):
-        if a.rsplit("-", 1)[0][:2] == b.rsplit("-", 1)[0][:2]:  # 同幕前缀
-            if hashes[a] == hashes[b]:
-                msgs.append(f"WARN {a} 与 {b} 帧指纹相同（疑似冻帧/beat 窗口错位）")
+    if freeze_check:
+        for (a, _), (b, _) in zip(ordered, ordered[1:], strict=False):
+            if a.rsplit("-", 1)[0][:2] == b.rsplit("-", 1)[0][:2]:  # 同幕前缀
+                if hashes[a] == hashes[b]:
+                    msgs.append(f"WARN {a} 与 {b} 帧指纹相同（疑似冻帧/beat 窗口错位）")
 
 
 # ---------------- main ----------------
@@ -329,6 +403,19 @@ def main() -> None:
     parser.add_argument(
         "--check", action="store_true", help="对抽出的帧做自动体检（需 pillow+numpy）"
     )
+    parser.add_argument(
+        "--beat-heads",
+        type=int,
+        metavar="N",
+        help="每 beat 头部连抽 N 帧（0..N-1，fps 间隔）——入场瞬态的机械补盲"
+        "（ISSUE-170）；只可与 --scene 组合，此模式下 --check 关闭冻帧判定",
+    )
+    parser.add_argument(
+        "--compare",
+        nargs=2,
+        metavar=("A.mp4", "B.mp4"),
+        help="A/B 对拍：同帧号抽两版逐帧差异（advisory；需 --scene/--last-n/ids 之一）",
+    )
     parser.add_argument(
         "--check-theme",
         action="store_true",
@@ -364,6 +451,12 @@ def main() -> None:
 
     root = Path(args.project).resolve()
 
+    # --compare 自带两个视频路径，不消费普通模式的 <video> 位置参数；argparse 仍会
+    # 把 compare 后的首个裸句 id 填进 video，须在选择器计数前归还给 ids。
+    if args.compare and args.video:
+        args.ids.insert(0, args.video)
+        args.video = None
+
     if args.stills_plan:
         stills_plan(root, args.chars_per_sec)
         return
@@ -377,15 +470,112 @@ def main() -> None:
         sys.exit(1 if any(m.startswith("FAIL") for m in msgs) else 0)
 
     selectors = sum(bool(x) for x in (args.scene, args.last_n, args.ids))
-    if not args.video or selectors != 1:
+    if args.beat_heads:
+        if args.last_n or args.ids:
+            parser.error("--beat-heads 只可与 --scene 组合过滤幕")
+        if not args.video:
+            parser.error("--beat-heads 需要 <video>")
+    elif args.compare:
+        if selectors != 1:
+            parser.error("--compare 需要 --scene / --last-n / ids 之一指定对拍帧")
+    elif not args.video or selectors != 1:
         parser.error(
             "需要 <video> 且 --scene / --last-n / ids 三选一（或用 --check-theme）"
         )
 
-    video = Path(args.video).resolve()
-    out = root / "out" / "frames"
     tl = timeline(root)
     offset = args.offset
+
+    if args.compare:
+        # A/B 对拍：同帧号抽两版，差异摘要按占比降序（advisory，退出码恒 0）
+        from check_script import parse_storyboard  # noqa: PLC0415 - 同目录模块
+
+        va, vb = (Path(x).resolve() for x in args.compare)
+        ids = (
+            [k for sc in args.scene for k in tl if k.startswith(sc.lower() + "-")]
+            if args.scene
+            else (list(tl)[-args.last_n :] if args.last_n else args.ids)
+        )
+        if not ids:
+            parser.error("--compare 未选中任何可对拍句")
+        out_ab = root / "out" / "frames-ab"
+        out_ab.mkdir(parents=True, exist_ok=True)
+        ffmpeg = ["pnpm", "exec", "remotion", "ffmpeg"]
+        rows: list[tuple[str, dict]] = []
+        for sid in ids:
+            if sid not in tl:
+                print(f"跳过未知句 id: {sid}")
+                continue
+            ts = tl[sid][0] + tl[sid][1] / 2 - offset
+            fa, fb = out_ab / f"{sid}.a.png", out_ab / f"{sid}.b.png"
+            extract_frame(ffmpeg, va, root / "video", ts, fa)
+            extract_frame(ffmpeg, vb, root / "video", ts, fb)
+            rows.append((sid, frame_diff(fa, fb)))
+            print(f"{sid} @ {ts:.2f}s 已对拍")
+        if not rows:
+            parser.error("--compare 未抽取到任何有效帧")
+        rows.sort(key=lambda r: r[1]["frac"], reverse=True)
+        print()
+        for sid, d in rows:
+            bbox = d["bbox"]
+            print(
+                f"  {sid}: meanΔ {d['mean']:6.2f} · 差异像素 {d['frac'] * 100:5.1f}%"
+                + (f" · bbox {bbox}" if bbox else "")
+            )
+        hot = sum(1 for _, d in rows if d["frac"] > 0.05)
+        print(
+            f">> A/B 对拍 {len(rows)} 帧 · 差异像素 >5% 共 {hot} 帧"
+            "（差异帧须逐一归因后才能接受；工具不替人判定「变好还是变坏」）"
+        )
+        return
+
+    video = Path(args.video).resolve()
+    out = root / "out" / "frames"
+    if args.beat_heads:
+        from check_script import parse_storyboard  # noqa: PLC0415 - 同目录模块
+
+        board = root / "script" / "storyboard.md"
+        if not board.is_file():
+            sys.exit(f"storyboard.md 不存在: {board} —— --beat-heads 需要分镜表")
+        samples = beat_head_samples(
+            parse_storyboard(board),
+            tl,
+            load_constants(root)["fps"],
+            args.beat_heads,
+            offset,
+            args.scene,
+        )
+        if not samples:
+            parser.error("--beat-heads 未选中任何可抽取 beat")
+        out.mkdir(parents=True, exist_ok=True)
+        ffmpeg = ["pnpm", "exec", "remotion", "ffmpeg"]
+        extracted: list[str] = []
+        for name, ts in samples:
+            dst = out / f"{name}.png"
+            extract_frame(ffmpeg, video, root / "video", ts, dst)
+            extracted.append(name)
+            print(f"{name} @ {ts:.2f}s -> {dst.relative_to(root)}")
+        if args.check:
+            board_fade = tail_row_has_fade(board)
+            msgs: list[str] = []
+            check_frames(
+                out,
+                extracted,
+                args.scale,
+                board_fade,
+                msgs,
+                freeze_check=False,
+                subtitle_check=False,
+            )
+            for m in msgs:
+                print(f"  {m}")
+            n_fail = sum(m.startswith("FAIL") for m in msgs)
+            print(
+                f">> beat 头部体检 · FAIL {n_fail} ·"
+                f" WARN {sum(m.startswith('WARN') for m in msgs)}（冻帧判定已关闭）"
+            )
+            sys.exit(1 if n_fail else 0)
+        return
     if args.scene:
         # 每幕**独立**抽样再拼接：抽样步长按各幕自身句数算，否则多幕合并后
         # 步长被总数放大，句少的幕会被整幕跳过（静默漏检，与 --scene 单值那个
diff --git a/apps/negentropy-influence/pipeline/scripts/tts.py b/apps/negentropy-influence/pipeline/scripts/tts.py
index 58231b0cd..615d181a4 100644
--- a/apps/negentropy-influence/pipeline/scripts/tts.py
+++ b/apps/negentropy-influence/pipeline/scripts/tts.py
@@ -9,6 +9,10 @@
     通过 --ref 提供参考音色样本、--style 选择风格（sunny 明快阳光为推荐位，
     sunny-steady 为其定稿档＝同参数 + 束宽 3；另有激情/轻快/自信/正能量）。
 - 幂等：参数与文本未变则跳过（SHA1 摘要 sidecar 缓存）。
+- 版本库（indextts）：合成成功的句子按 digest 存入机器级持久库（默认
+  ~/Library/Application Support/negentropy-influence/tts-store，环境变量 NE_TTS_STORE
+  覆盖，--no-store 禁用）；集内缓存未命中时先按 digest 回收——换 worktree / 清盘不再
+  丢整集合成成果，改稿只重配变更句。历史版本按 digest 文件名并存，不互相覆盖。
 
 用法：
   edge：    uv run --no-project --with edge-tts --with mutagen $R/tts.py \
@@ -30,7 +34,10 @@
 import hashlib
 import json
 import math
+import os
+import shutil
 import sys
+import tempfile
 import urllib.error
 import urllib.request
 from pathlib import Path
@@ -633,6 +640,118 @@ def digest_indextts(
     ).hexdigest()
 
 
+# ---------------- 音频版本库（内容寻址持久库，仅 indextts） ----------------
+#
+# 集内 audio/ 是 gitignored 本地产物 ⇒ 换 worktree / 清盘即丢整集合成成果
+# （Claude Code 系列的 mp3 曾在任何工作区都不剩一份，实测教训）。版本库按
+# 「句 id + digest 前 12 位」命名放在机器级持久目录，与任何 worktree 解耦：
+#   - 合成成功 → store_deposit 入库（同 digest 刷新为最新音频；不同 digest 并存=保留历史版本）；
+#   - 集内缓存未命中 → store_restore 按 digest 回收，命中即等价集内缓存命中；
+#   - 改稿/换风格 ⇒ 新 digest 自然 miss 重配，旧版本文件保留可回退。
+# 路径是机器属性：默认值在此 + NE_TTS_STORE 环境变量覆盖，永不写进受版本控制的
+# toml（与 config.py 对 tts.server 的立场一致；tts.py 不 import paths.py 的边界
+# 也不变——默认值是纯字面量）。仅接 indextts：edge 预置音色免密钥秒级重合成，
+# 无 2 小时级资产可丢。
+
+DEFAULT_STORE = "~/Library/Application Support/negentropy-influence/tts-store"
+
+
+def store_root(disabled: bool) -> Path | None:
+    """版本库根目录；--no-store 或 NE_TTS_STORE='' 时返回 None（全程直通不落盘）。"""
+    if disabled:
+        return None
+    env = os.environ.get("NE_TTS_STORE")
+    if env == "":
+        return None
+    return Path(DEFAULT_STORE if env is None else env).expanduser()
+
+
+def store_entry(store: Path | None, slug: str, sid: str, digest: str) -> Path | None:
+    """库内条目路径：<root>/<集 slug>/<sid>.<digest12>.mp3（同名 .sha 邻档存全量 digest）。"""
+    if store is None:
+        return None
+    return store / slug / f"{sid}.{digest[:12]}.mp3"
+
+
+def store_has(store: Path | None, slug: str, sid: str, digest: str) -> bool:
+    """--plan 用：库内是否存在该 digest 的句子（校验 .sha 邻档，防 12 位前缀巧合）。"""
+    if store is None:
+        return False
+    mp3 = store_entry(store, slug, sid, digest)
+    assert mp3 is not None
+    sha = mp3.with_suffix(".sha")
+    try:
+        return (
+            mp3.is_file()
+            and mp3.stat().st_size > 0
+            and sha.is_file()
+            and sha.read_text(encoding="utf-8") == digest
+        )
+    except (OSError, UnicodeError) as e:
+        print(f"WARN 版本库读取失败（{sid}）：{e}", file=sys.stderr)
+        return False
+
+
+def store_deposit(
+    mp3: Path, sid: str, digest: str, store: Path | None, slug: str
+) -> None:
+    """合成成功后入库。失败只 WARN 不断长跑——库是加速器，不是门。"""
+    if store is None:
+        return
+    dst = store_entry(store, slug, sid, digest)
+    assert dst is not None
+    sha = dst.with_suffix(".sha")
+    tmp_mp3: Path | None = None
+    tmp_sha: Path | None = None
+    try:
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        with tempfile.NamedTemporaryFile(
+            dir=dst.parent, prefix=f".{dst.name}.", suffix=".tmp", delete=False
+        ) as f:
+            tmp_mp3 = Path(f.name)
+        shutil.copyfile(mp3, tmp_mp3)
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            dir=dst.parent,
+            prefix=f".{sha.name}.",
+            suffix=".tmp",
+            delete=False,
+        ) as f:
+            tmp_sha = Path(f.name)
+            f.write(digest)
+        os.replace(tmp_mp3, dst)
+        tmp_mp3 = None
+        os.replace(tmp_sha, sha)
+        tmp_sha = None
+    except (OSError, UnicodeError) as e:
+        print(f"WARN 版本库入库失败（{sid}）：{e}", file=sys.stderr)
+    finally:
+        for tmp in (tmp_mp3, tmp_sha):
+            if tmp is not None:
+                try:
+                    tmp.unlink(missing_ok=True)
+                except OSError:
+                    pass
+
+
+def store_restore(
+    sid: str, digest: str, out_dir: Path, store: Path | None, slug: str
+) -> bool:
+    """集内缓存 miss 时先向库回收；命中则 mp3 + .sha 落位，等价集内缓存命中。"""
+    if not store_has(store, slug, sid, digest):
+        return False
+    src = store_entry(store, slug, sid, digest)
+    assert src is not None
+    try:
+        shutil.copyfile(src, out_dir / f"{sid}.mp3")
+        (out_dir / f"{sid}.sha").write_text(digest, encoding="utf-8")
+        return True
+    except (OSError, UnicodeError) as e:
+        print(f"WARN 版本库回收失败（{sid}）：{e}", file=sys.stderr)
+        return False
+
+
 async def synth_indextts(
     sem: asyncio.Semaphore,
     item: dict,
@@ -652,6 +771,8 @@ async def synth_indextts(
     emo_ref_sha1: str | None = None,
     emo_text: str | None = None,
     sampling: dict | None = None,
+    store: Path | None = None,
+    slug: str = "",
 ) -> dict:
     sid, text = item["id"], synth_source_text(item)
     mp3 = out_dir / f"{sid}.mp3"
@@ -671,14 +792,17 @@ async def synth_indextts(
         sampling,
     )
 
-    if (
+    local_hit = (
         not force
         and mp3.exists()
         and mp3.stat().st_size > 0
         and meta.exists()
         and meta.read_text() == digest
-    ):
+    )
+    if local_hit:
         pass
+    elif not force and store_restore(sid, digest, out_dir, store, slug):
+        pass  # 版本库回收命中：mp3 + .sha 已落位，等价集内缓存命中（--force 不走库）
     else:
         async with sem:
             last_err: Exception | None = None
@@ -709,6 +833,7 @@ async def synth_indextts(
                     if mp3.stat().st_size == 0:
                         raise RuntimeError("空音频文件")
                     meta.write_text(digest)
+                    store_deposit(mp3, sid, digest, store, slug)
                     break
                 except NonRetryableError:
                     raise
@@ -719,6 +844,8 @@ async def synth_indextts(
                 raise RuntimeError(f"{sid} 合成失败: {last_err}")
 
     duration = mp3_duration(mp3)
+    if local_hit and not store_has(store, slug, sid, digest):
+        store_deposit(mp3, sid, digest, store, slug)
     return {**item, "durationSec": round(duration, 3)}
 
 
@@ -743,6 +870,11 @@ async def main() -> None:
     )
     parser.add_argument("--rate", default=DEFAULT_RATE, help="[edge] 语速（默认 +4%%）")
     parser.add_argument("--force", action="store_true", help="忽略缓存强制重合成")
+    parser.add_argument(
+        "--no-store",
+        action="store_true",
+        help="[indextts] 禁用音频版本库（默认启用；库根目录可用环境变量 NE_TTS_STORE 覆盖）",
+    )
     parser.add_argument(
         "--allow-voice-switch",
         action="store_true",
@@ -1015,6 +1147,8 @@ async def main() -> None:
     out_dir = root / "video" / "public" / "audio"
     items = json.loads(src.read_text(encoding="utf-8"))
     out_dir.mkdir(parents=True, exist_ok=True)
+    store = store_root(args.no_store)
+    slug = root.name
 
     if args.engine == "edge":
         signature = f"edge|{args.voice}|{args.rate}"
@@ -1129,6 +1263,7 @@ async def main() -> None:
             )
             todo = {b: 0 for b in sorted(set(beams_of.values()))}
             cached = dict(todo)
+            store_hits = dict(todo)
             for i in items:
                 b = beams_of[i["id"]]
                 d = digest_indextts(
@@ -1154,20 +1289,35 @@ async def main() -> None:
                     and meta.read_text() == d
                 )
                 (cached if hit else todo)[b] += 1
+                if not hit and not args.force and store_has(store, slug, i["id"], d):
+                    store_hits[b] += 1
             # 估时用**整集长跑折算口径**（含降频、机器争用与逐句开销），不是单句空闲口径：
             # 1 束 RTF≈13（三集 596 句实测 8.5 h 折算）、≥2 束≈45（短句 A/B 实测约 3.2 倍）；
             # 每句音频按 4.2s（三集均值）。单句空闲时可快到 RTF 6–7，故本估算偏保守。
             est = sum(
-                n * AVG_SEC_PER_LINE * (RTF_1BEAM if b == 1 else RTF_MULTIBEAM)
+                (n - store_hits[b])
+                * AVG_SEC_PER_LINE
+                * (RTF_1BEAM if b == 1 else RTF_MULTIBEAM)
                 for b, n in todo.items()
             )
             for b in sorted(todo):
                 print(
                     f"   束宽 {b}：待合成 {todo[b]:>3} 句 · 已缓存 {cached[b]:>3} 句"
+                    + (
+                        f" · 版本库可回收 {store_hits[b]:>3} 句"
+                        if store_hits[b]
+                        else ""
+                    )
                     + ("" if b == 1 else "（高束宽档）")
                 )
             print(
-                f">> 待合成合计 {sum(todo.values())} 句，估算墙钟约 {est / 3600:.1f} 小时"
+                f">> 待合成合计 {sum(todo.values())} 句"
+                + (
+                    f"（其中 {sum(store_hits.values())} 句由版本库直收，不占合成时间）"
+                    if sum(store_hits.values())
+                    else ""
+                )
+                + f"，估算墙钟约 {est / 3600:.1f} 小时"
                 f"（长跑折算口径 RTF 1 束≈{RTF_1BEAM:g} / 高束宽≈{RTF_MULTIBEAM:g}，"
                 f"机器负载会显著影响，仅作排期参考）"
             )
@@ -1238,6 +1388,8 @@ async def main() -> None:
                     emo_ref_sha1=emo_ref_sha1,
                     emo_text=args.emo_text,
                     sampling=sampling,
+                    store=store,
+                    slug=slug,
                 )
                 for i in items
             )
diff --git a/apps/negentropy-influence/pipeline/skills/06-remotion-implementation.md b/apps/negentropy-influence/pipeline/skills/06-remotion-implementation.md
index 302ac5c90..9b9e341d0 100644
--- a/apps/negentropy-influence/pipeline/skills/06-remotion-implementation.md
+++ b/apps/negentropy-influence/pipeline/skills/06-remotion-implementation.md
@@ -20,7 +20,7 @@ uv run --no-project $R/verify_skeleton.py --strict  # 有未登记漂移即失
 
 要点（详见 skeleton.toml 内注）：
 
-- **A 档 · frozen 逐字节保留**（15 个文件，含 `src/timing.ts` 的 computeTimeline + beatWindow + SCENE_FADE_FRAMES、`@remotion/media` 的 NarrationAudio、fitText 的 Subtitle、幕间呼吸淡入淡出的 SceneFade、cards、三份薄包装与全部工程配置）。改任何一处 = 改模板 + 改各集，`--strict` 会盯住。
+- **A 档 · frozen 逐字节保留**（清单见 skeleton.toml，含 `src/timing.ts` 的 computeTimeline + beatWindow + SCENE_FADE_FRAMES、`@remotion/media` 的 NarrationAudio、fitText 的 Subtitle、幕间呼吸淡入淡出的 SceneFade、cards、`src/motion/` 运动层（见下节）、三份薄包装与全部工程配置）。改任何一处 = 改模板 + 改各集，`--strict` 会盯住。
 - **B 档 · overridable**：`src/timing.json`（时序常数 SSOT——timing.ts 与 Python 侧共读同一文件，**改常量只改此处**）。覆写许可存在但四集从未行使过。
 - **regioned**：`src/Main.tsx` 区外冻结（每集内容只有场景 import 与 SCENE_COMPONENTS 注册表）；**structured**：`package.json` 门住依赖零漂移、忽略 name/description。
 - **每集改写**：`src/design/theme.ts`（本集色板）、`src/scenes/*`（全部重写；骨架样例见模板里的 scenes-EXAMPLE.tsx.txt）。
@@ -66,6 +66,44 @@ uv run --no-project $R/verify_skeleton.py --strict  # 有未登记漂移即失
   （本集实测：size < 260 必须关掉）。
 - 「用无动效表达无聊」是有效手法：金句期间让主体继续匀速运动、**不加任何强调动效**。
 
+## 运动层（video/src/motion/，frozen 跨集共享）
+
+**共享的是「怎么动」（机制），不是「画什么」（策略）**：时长/缓动/弹簧/错峰/巡游
+等时序语汇跨集一致（同一只手感），theme/motifs/场景构图仍各集自由。落地为
+`src/motion/` 七文件（tokens/window/schedule/hooks/index/gallery + 单测），frozen 档
+md5 门执法——判据与「不读 theme token」约束见 tests/test_skeleton.py 的 motion 三条。
+
+- **令牌（tokens.ts）**：时长六档 `DUR.f1..f6`（2/3/5/7/12/21 帧，Carbon DTCG 六档
+  @30fps；弃 M3 十六档——30fps 量化下 6 对相邻档同帧数，伪选择）；缓动
+  `standard/decelerate/accelerate/linear`（M3 贝塞尔控制点）；弹簧 `settle`(damping 200，
+  本仓既有 9/10 调用点的实测手感——**刻意不抄规格散文里的 stiffness 120/damping 18**，
+  视觉连续性优先于纸面参数) / `settleSoft`(170) / `snap`(12，轻过冲)；`SAFE_TOP_Y=920`
+  字幕安全带 SSOT；`EXIT_FACTOR=0.4` 出场快于入场。
+- **窗口（window.ts）**：`progress/win/beatProgress/clamp01` 纯函数——「clamped 0→1
+  手写 interpolate」惯用形的统一替身；父级持有绝对帧、子动画是 beat 进度上的窗口，
+  TTS 实测时长变化 ⇒ 全部窗口自动重定时（写死帧数缺陷类由构造消灭）。
+- **编排（schedule.ts）**：`schedule(n, {dur, stride|lag|fit, minStride, minDur})`——
+  错峰三模式（固定步长 / Manim lag_ratio / 拟合进 beat 窗口），钳制优先级
+  「不外溢窗口 > 最小步长 > 子项时长」。
+- **模型（hooks.ts）**：`useProgress`（缓动数值进度）`useSpring`（弹簧数值进度）
+  `useEnter`（入场 fall/rise/slide/pop/flyIn/fade；rise 自带 `restBottom` 安全带钳制——
+  ISSUE-170 缺陷类构造性消灭）`useStagger`（序列错峰）`useDraw`（描线，红线三构造保证）
+  `useImpulse`（一次性强调）`useBreathe`（持续辉光，period=2π·除数）`useTravel`
+  `useAccelTravel`（加速绕行，吸收两处克隆）`useCount`（计数/水位=meter）`useReveal`
+  （打字机）`usePushIn`（镜头推近）`useDim`（压暗/提亮）`useFlowDash`（flow 行进虚线）
+  `useShake` `useFadeOut`（片尾渐黑，红线四构造保证）。
+- **铁律**：① hooks 只在组件顶层调用（map/条件内用纯函数 `progress`/`spring`+`SPRING`）；
+  ② 弹簧只喂局部帧（`frame - at`）——全局帧会让 spring() 每帧从 0 重模拟 O(frame)；
+  ③ effects（不透明度/颜色）永不吃弹簧（M3 spatial/effects 二分）；④ 时长取最近 token
+  （±3 帧内），不落标尺的 beat 级动作保留显式帧数并注释；⑤ 动画时点一律由句边界
+  推导（`rel(beat,'句id')`）。
+- **逃生舱（反模板化对冲）**：裸 `interpolate`/内联正弦是**合法**的——每集保留 ≥1 个
+  豁免运动层的 bespoke 签名镜头（EP1 的 0-B 命名帧合拢即例）；等速线性运动在「机械感
+  是主题」时优先于缓动（EP1 0-A 搬运弧线即例）。模型是词汇不是牢笼。
+- **评审面**：`./node_modules/.bin/remotion still src/motion/gallery.tsx MotionGallery
+  ../out/motion-gallery.png --frame=30`——全部模型 × 变体一屏秒级出图；纯函数单测
+  `node --test scripts/motion.test.ts`（Node ≥ 23.6 原生跑 TS）。
+
 ## 场景组件模式
 
 ```tsx
@@ -84,7 +122,7 @@ export const P2FiveObjects: React.FC<{scene: SceneRange}> = ({scene}) => {
 
 - 一幕一文件 `P<n><Name>.tsx`；一「镜」一内部子组件；
 - `Sequence name` 与 storyboard 镜号一一对应（QA 时可对照）；
-- beat 内动画只用 `useCurrentFrame()` + `interpolate`/`spring`（帧驱动，禁 `Date.now()`/随机数——渲染必须确定）。
+- beat 内动画优先走 `src/motion/` 运动模型（见上节铁律）；裸 `interpolate`/`spring` 是逃生舱而非默认。一律帧驱动，禁 `Date.now()`/随机数——渲染必须确定。
 
 ## theme.ts 色彩契约设计规则
 
@@ -119,37 +157,48 @@ cd video && ./node_modules/.bin/remotion render Main ../out/final.mp4          #
 
 QA 验收：逐幕抽帧目检色契约遵守、beat 窗口不越界、角标不入字幕区、无文字溢出/遮挡；高风险镜（矩阵图/全景图/金句卡）单独指定句 id 抽帧。
 
+**动效列 @动词 标注**：分镜「动效」列以反引号代码记号声明本镜主力运动模型
+（如 `` `@enter:fall` ``、`` `@stagger` ``、`` `@draw` ``——动词表 = hooks.ts 的 use*
+导出派生，勿凭记忆写）。`check_script.py --check-motion`（WARN-only）核对镜内声明
+的动词在该幕场景代码中确有调用——「分镜写了动效、代码没实现」这一实测缺陷类的机检。
+反向不报：动效列是意图摘要而非全量清单。入场瞬态另走 `qa_frames.py --beat-heads N`
+（每 beat 头部连抽 N 帧，ISSUE-170 补盲）；重制/重构回归用 `--compare A B`同帧号对拍。
+
 ## 系列身份视觉：五层 Harness 栈（2026-08-23 Harness Engineering 改造引入）
 
 「Claude Code Harness Engineering」五集共用一套**首尾统一的系列装置**。实现仍遵守
 「复制适配不共享」：母题代码落各集 `motifs.tsx`（seeded 档），**本节是五集一致性的规格 SSOT**——
 改规格先改这里，再逐集同步。
 
-> **落地状态（2026-08-23 评审）**：规格先行，**未落地**——改造版草渲（draft-review）中
-> 各集 P0/P6 均未实现本节装置（EP1 P0 为五辐条供给图，各集 P6 为文字身份卡 + 下期卡）。
-> 本节是终渲前待办的目标规格而非现状描述；落地时逐集同步并在本块更新状态，
-> 防止「SSOT 与已交付草渲事实漂移」再次发生。
+> **落地状态（2026-09-03 运动层重制）**：**EP1 已落地**——P0 开场落板+缩退常驻
+> （HarnessStackP0）、P1–P5 常驻角标（HarnessBadge）、P6 收尾放大+下期层呼吸预告
+> （HarnessStackP6），实现于 EP1 `components/harness-stack.tsx`（复制源，seeded 档）；
+> 层序/层名/发布态/下集标题自 `video/src/series-layers.json`（build_narration 从
+> series.json 派生，硬编码即漂移）。**EP2–5 待同步**（复制 harness-stack.tsx + 各幕
+> 挂 HarnessBadge + P0/P6 编排）——五集不一致状态显式化于此，终渲前逐集补齐。
 
 ### 五层栈母题（HarnessStack）
 
 - **结构**：纵向五层（自底向上：执行 → 规划 → 记忆 → 时机 → 协作），每层一条横板：
   图标 + 层名 + 一句话职责；层序与层名从 `series.json` 的 episode 顺序 + cardSub 派生（硬编码即漂移）。
 - **P0 开场用法**（每集 ≤3 句内完成）：五层自底向上快速落板（层落 = translateY + 透明度，约 6 帧一层），
-  **本集层高亮脉冲**（主色描边 + 辉光呼吸两次），其余层压暗至 55% 亮度；随后栈整体缩小退至画面左上角
-  作常驻角标（宽 ≤ 300px，本集层保持高亮）——不占字幕安全区。
+  **本集层高亮脉冲**（主色描边 + 辉光呼吸两次），其余层压暗至 55% 亮度；随后栈整体缩小淡出，与常驻条
+  交叉淡入衔接。**常驻形式 = 顶边横条**（y 12–48，本集层高亮）：EP1 评审实测纵向左上角标（300×194）
+  与既有各幕左上内容五处碰撞（各幕内容最早 y=56 起），顶边横条是唯一零碰撞常驻区——形式适配的
+  实测依据见 harness-stack.tsx 文件头，不占字幕安全区。
 - **P6 收尾用法**：栈重新放大居中；已发布层保持点亮，**下期层呼吸预告**（画面卡显示下集标题——
   派生自 series.json，口播只说「下期 + 话题描述」）；系列标语压在栈底。
 - **动画时点**一律由句边界推导（`rel(beat, '句id')`），禁写死帧数。
 
 ### 动效语法（五集统一）
 
-| 语法 | 值 | 用途 |
+| 语法 | 模型（src/motion/hooks.ts） | 用途 |
 |---|---|---|
-| `flow` | 连线上的行进光点：2–3 个 6px 圆点沿路径循环，`stroke-dashoffset` 驱动 | 数据流向（循环回灌/消息传递/判定路径） |
-| `pushIn` | beat 切换时图解组 scale 1.0→1.06（easeOut，12 帧） | 镜头语言，替代纯淡入 |
-| `glow` | 主色辉光：`box-shadow: 0 0 24px color/40%, 0 0 64px color/25%` | 高亮语义（仅概念色元素，禁滥用） |
-| `meter` | 帧驱动数值条（水位/预算/计数） | 数据动感；值 = f(frame)，禁随机 |
-| `settle` | 入场落位：spring(stiffness 120, damping 18) 或 10 帧 easeOut | 卡片/节点落位统一手感 |
+| `flow` | `useFlowDash`（行进虚线）+ `useTravel`（巡游点） | 数据流向（循环回灌/消息传递/判定路径） |
+| `pushIn` | `usePushIn(at)`（scale 1.0→1.06 decelerate，DUR.f5） | 镜头语言，替代纯淡入 |
+| `glow` | `useImpulse`（一次性强调）/ `useBreathe`（持续辉光） | 高亮语义（仅概念色元素，禁滥用） |
+| `meter` | `useCount`（帧驱动数值，禁随机） | 数据动感 |
+| `settle` | `useEnter(..., {springPreset: 'settle'})` / `useSpring('settle')` | 卡片/节点落位统一手感 |
 
 深度感：背景网格（60px 网距、8% 透明度）随场景帧缓慢漂移（每帧 0.2px，全片 ≤40px 循环）。
 
diff --git a/apps/negentropy-influence/pipeline/skills/08-render-qa.md b/apps/negentropy-influence/pipeline/skills/08-render-qa.md
index e593707c2..5a467bb27 100644
--- a/apps/negentropy-influence/pipeline/skills/08-render-qa.md
+++ b/apps/negentropy-influence/pipeline/skills/08-render-qa.md
@@ -21,6 +21,16 @@ uv run --no-project --with pillow --with numpy $R/qa_frames.py \
 
 # 主题对比度（零依赖，不需视频；新配色/改 theme.ts 后必跑）
 uv run --no-project $R/qa_frames.py --project $P --check-theme
+
+# beat 头部连抽（每 beat 首句起点连抽 N 帧）——入场瞬态的机械补盲：
+# ISSUE-170 实证「落位态干净、入场越界」会被句中点采样整段错过（此模式冻帧判定关闭）
+uv run --no-project --with pillow --with numpy $R/qa_frames.py \
+    --project $P $P/out/draft.mp4 --beat-heads 4 --check --scale 0.5
+
+# A/B 对拍（重制/重构回归）：同帧号抽两版逐帧差异，按差异像素占比降序；
+# advisory（有匹配帧时退出码 0；零匹配硬失败）——「意图变更之外的一切差异」都须归因后才能接受
+uv run --no-project --with pillow --with numpy $R/qa_frames.py \
+    --project $P --compare $P/out/baseline-draft.mp4 $P/out/draft.mp4 --scene P4
 ```
 
 ## 自动体检判据与处置
@@ -33,7 +43,7 @@ uv run --no-project $R/qa_frames.py --project $P --check-theme
 | 字幕缺失（字幕带无文字亮度像素） | WARN | 查该句 Subtitle 是否被遮挡或文本为空 |
 | 主题对比度 <4.5:1 | FAIL | 换色或加深；概念色清单见 skills/06 视觉契约 |
 
-**注意**：`--offset` 仅在草渲与终渲时间基准不一致时使用；每次重合成后**所有** beat 时间轴位移，抽帧样点必须从新 manifest 重推（工具自动做，但不要复用旧帧目录的旧结论）。
+**注意**：`--offset` 仅在草渲与终渲时间基准不一致时使用；每次重合成后**所有** beat 时间轴位移，抽帧样点必须从新 manifest 重推（工具自动做，但不要复用旧帧目录的旧结论）。**对拍基线**：重制动手前先渲一版 `baseline-draft.mp4` 存档（后续工作区没有旧产物可回取）；A/B 共用同一份音频与 manifest 时，总帧数恒等、同帧号对拍才有意义。
 
 ## 人工目检清单（自动体检之外的残余）
 
diff --git a/apps/negentropy-influence/pipeline/templates/video-skeleton/skeleton.toml b/apps/negentropy-influence/pipeline/templates/video-skeleton/skeleton.toml
index 67cf9655a..114b694f3 100644
--- a/apps/negentropy-influence/pipeline/templates/video-skeleton/skeleton.toml
+++ b/apps/negentropy-influence/pipeline/templates/video-skeleton/skeleton.toml
@@ -31,10 +31,10 @@
 #                会让新集开箱即 7 个 module-not-found（归一化恰好剥掉它们，所以
 #                留空不影响任何既有集的指纹——留着则纯粹是给新集埋坑）。
 #   structured   结构化比对：package.json 忽略 name/description，但门住
-#                dependencies/devDependencies/scripts/pnpm。有价值的不变量不是
+#                dependencies/devDependencies/scripts。有价值的不变量不是
 #                字节而是「零依赖漂移」——版本漂移会让 A 档 TS 文件行为不同。
-#                这也顺带把 README §六 刻意保留的 pnpm.onlyBuiltDependencies
-#                变成受执法的不变量。
+#                （原 pnpm.onlyBuiltDependencies 字段已被 pnpm 12 弃读，构建许可
+#                迁至 pnpm-workspace.yaml 的 allowBuilds——frozen 档执法。）
 #   seeded       scaffold 复制后完全自由，不设门。
 #
 # ## 分组语义（承重）
@@ -73,6 +73,17 @@ frozen = [
   "scripts/build_narration.py",
   "scripts/tts.py",
   "scripts/qa_frames.py",
+  # 运动层（motion）：跨集共享的是「怎么动」（机制），不是「画什么」（策略）——
+  # theme/motifs 仍 seeded 各集自由。判据见 tests/test_skeleton.py 的 motion 两条
+  # （不读 theme token / 文件面齐全）。gallery 是独立 Remotion 入口（不经 Root.tsx，
+  # 对既有 Composition 零影响）；单测经 node --test 原生跑 TS（Node ≥ 23.6）。
+  "video/src/motion/tokens.ts",
+  "video/src/motion/window.ts",
+  "video/src/motion/schedule.ts",
+  "video/src/motion/hooks.ts",
+  "video/src/motion/index.ts",
+  "video/src/motion/gallery.tsx",
+  "video/scripts/motion.test.ts",
 ]
 # 时序常数 SSOT：timing.ts 经 resolveJsonModule 同步 import，Python 侧
 # timeline.py 直读同一文件。覆写许可存在但四集从未行使过。
diff --git a/apps/negentropy-influence/pipeline/templates/video-skeleton/video/package.json.tmpl b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/package.json.tmpl
index 5730b34b2..15cea2dcd 100644
--- a/apps/negentropy-influence/pipeline/templates/video-skeleton/video/package.json.tmpl
+++ b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/package.json.tmpl
@@ -19,10 +19,5 @@
   "devDependencies": {
     "@types/react": "^19.0.0",
     "typescript": "^5.6.0"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild"
-    ]
   }
 }
diff --git a/apps/negentropy-influence/pipeline/templates/video-skeleton/video/pnpm-workspace.yaml b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/pnpm-workspace.yaml
index f2686ac7d..add822dbe 100644
--- a/apps/negentropy-influence/pipeline/templates/video-skeleton/video/pnpm-workspace.yaml
+++ b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/pnpm-workspace.yaml
@@ -1,4 +1,9 @@
-# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的唯一理由。
+# 把本工程钉成它自己的 pnpm workspace 根——这是本文件存在的首要理由。
 # pnpm 12 起仅靠 `--ignore-workspace` 不够：pnpm 仍会沿 packageManager 向上锚定到仓库根，
 # 用本工程的解析结果覆写根 pnpm-lock.yaml（overrides 全丢）且当场不报错。见 ISSUE-175。
 packages: []
+# pnpm 12 的构建脚本许可（package.json 的 pnpm.onlyBuiltDependencies 已不被读取，
+# 静默忽略会使安装以 ERR_PNPM_IGNORED_BUILDS 中断、node_modules 半残）。键名与取值
+# 与 `pnpm approve-builds esbuild --yes` 实际写入的形态逐字一致——勿改回旧键名。
+allowBuilds:
+  esbuild: true
diff --git a/apps/negentropy-influence/pipeline/templates/video-skeleton/video/scripts/motion.test.ts b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/scripts/motion.test.ts
new file mode 100644
index 000000000..5e29cab52
--- /dev/null
+++ b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/scripts/motion.test.ts
@@ -0,0 +1,141 @@
+/**
+ * 运动层纯函数单测——`node --test scripts/motion.test.ts`（Node ≥ 23.6 原生跑 TS）。
+ *
+ * 刻意放在 video/ 而非 src/：tsconfig include 只有 src（frozen，不为测试改动），
+ * 而本文件 import 需带 .ts 后缀（Node ESM 解析规则）——tsc 若收编会因
+ * allowImportingTsExtensions 未开而报错。src/ 的类型覆盖由 tsc --noEmit 全量保证，
+ * 本文件只测纯函数行为，不做类型承重。
+ *
+ * 只 import 纯模块（tokens/window/schedule——零 remotion/react 依赖）：
+ * hooks 是它们的薄包装，行为由 MotionGallery 目视 + 场景抽帧覆盖。
+ */
+import {strict as assert} from 'node:assert';
+import test from 'node:test';
+
+import {DUR, EASING_CP, EXIT_FACTOR, SAFE_TOP_Y, SPRING, clampRiseDist, dampingRatio, overshootPeak} from '../src/motion/tokens.ts';
+import {beatProgress, clamp01, progress, revealCharCount, win} from '../src/motion/window.ts';
+import {schedule} from '../src/motion/schedule.ts';
+
+// ── tokens ────────────────────────────────────────────────────────────
+
+test('时长标尺在 30fps 下相邻档可辨（≥1 帧差）', () => {
+  const v = Object.values(DUR) as number[];
+  for (let i = 1; i < v.length; i++) {
+    assert.ok(v[i] - v[i - 1] >= 1, `第 ${i} 档与前一档同帧数（伪选择）`);
+  }
+  assert.ok(v.length === 6);
+});
+
+test('ζ→过冲换算钉死：snap 轻过冲、settle 零过冲（直抄 dampingRatio 的反例护栏）', () => {
+  const zSnap = dampingRatio(SPRING.snap);
+  const zSettle = dampingRatio(SPRING.settle);
+  assert.ok(zSnap > 0.4 && zSnap < 0.9, `snap ζ=${zSnap}`);
+  // Mp = exp(-πζ/√(1-ζ²)) 是超出幅度；峰值 = 1 + Mp（ζ=0.6 → 峰值 ≈1.095）
+  assert.ok(overshootPeak(zSnap) > 1.02 && overshootPeak(zSnap) < 1.2, `snap 峰值 ${overshootPeak(zSnap)}`);
+  assert.ok(zSettle > 1, 'settle 须过阻尼');
+  assert.equal(overshootPeak(zSettle), 1);
+  // 反例：把设计系统的 ζ 当 damping 直填（0.8）→ ζ≈0.04、峰值≈1.88 暴力弹跳
+  const wrong = dampingRatio({damping: 0.8, stiffness: 100, mass: 1});
+  assert.ok(overshootPeak(wrong) > 1.8, `直抄 ζ 的峰值=${overshootPeak(wrong)}，必须被此断言抓住`);
+});
+
+test('缓动控制点合法（CSS 规则 x∈[0,1]，且 x(t) 数值单调——可作函数求值）', () => {
+  for (const cp of Object.values(EASING_CP)) {
+    const [x1, , x2] = cp;
+    assert.ok(x1 >= 0 && x1 <= 1 && x2 >= 0 && x2 <= 1, `x 越界：${cp}`);
+    // x1<x2 是充分不必要（M3 standard (0.2,0,0,1) 的 x2<x1 仍单调）——判据用导数采样
+    for (let i = 0; i <= 50; i++) {
+      const t = i / 50;
+      const dx =
+        3 * (1 - t) ** 2 * x1 + 6 * (1 - t) * t * (x2 - x1) + 3 * t * t * (1 - x2);
+      assert.ok(dx > -1e-9, `x(t) 非单调 @t=${t}：${cp}`);
+    }
+  }
+});
+
+test('出场快于入场系数与安全带口径为常量', () => {
+  assert.equal(EXIT_FACTOR, 0.4);
+  assert.equal(SAFE_TOP_Y, 920);
+});
+
+test('clampRiseDist：自下方入场行程不探进字幕安全带', () => {
+  assert.equal(clampRiseDist(120, 836), 84, 'ISSUE-170 实测几何：rest 836 → 行程封顶 84');
+  assert.equal(clampRiseDist(40, 836), 40, '未超限不动');
+  assert.equal(clampRiseDist(120, 960), 0, '落位已在安全带内 → 零行程（退化但安全）');
+});
+
+// ── window ────────────────────────────────────────────────────────────
+
+test('clamp01 / progress / win 的钳制语义', () => {
+  assert.equal(clamp01(-1), 0);
+  assert.equal(clamp01(2), 1);
+  assert.equal(progress(10, 10, 10), 0, '起点为 0');
+  assert.equal(progress(20, 10, 10), 1, '终点为 1');
+  assert.equal(progress(5, 10, 10), 0, '窗外前钳 0');
+  assert.equal(progress(99, 10, 10), 1, '窗外后钳 1');
+  assert.equal(win(0.5, [0.25, 0.75]), 0.5);
+  assert.equal(win(0.1, [0.25, 0.75]), 0);
+  assert.equal(win(0.9, [0.25, 0.75]), 1);
+  assert.equal(beatProgress(0, -30, 90), 1 / 3);
+});
+
+test('逐字揭示：cps 按实际 fps 换算并向下取整，framesPerChar 保持固定帧间隔', () => {
+  assert.equal(revealCharCount(29, 60, 12), 5);
+  assert.equal(revealCharCount(30, 60, 12), 6);
+  assert.equal(revealCharCount(30, 24, 12, 3), 10);
+  assert.equal(revealCharCount(30, 120, 12, 3), 10);
+});
+
+// ── schedule ──────────────────────────────────────────────────────────
+
+test('fit 模式：末项恰在窗口末完成、不外溢', () => {
+  const p = schedule(5, {dur: 10, fit: {total: 90}});
+  const last = p.starts[4] + p.dur;
+  assert.ok(last <= 90 + 1, `末项 ${last} 外溢`);
+  assert.ok(last >= 89, `末项 ${last} 未到窗口末`);
+});
+
+test('fit 装不下时缩子项时长，不外溢窗口（优先级：不外溢 > 最小步长 > 子项时长）', () => {
+  // total 30 时 (30-12)/7≈2.57 ≥ minStride=2 仍装得下；压到 24 才触发缩时长
+  const p = schedule(8, {dur: 12, fit: {total: 24}});
+  const last = p.starts[7] + p.dur;
+  assert.ok(last <= 24, `末项 ${last} 外溢`);
+  assert.ok(p.dur >= 3, '子项时长跌破下限');
+  assert.ok(p.dur < 12, '装不下却未缩子项时长');
+});
+
+test('fit 窗口连 1 帧子项也容不下时显式拒绝，不返回外溢计划', () => {
+  assert.throws(() => schedule(8, {dur: 12, fit: {total: 5}}), /fit\.total=5.*8/);
+});
+
+test('fit 可行极限先牺牲子项时长，仍完整落在窗口内', () => {
+  const p = schedule(8, {dur: 12, fit: {total: 8}});
+  assert.equal(p.dur, 1);
+  assert.equal(p.starts[7] + p.dur, 8);
+});
+
+test('lag 模式：Manim 语义 start[i] = i·dur·lag', () => {
+  const p = schedule(3, {dur: 10, lag: 0.5});
+  assert.deepEqual(p.starts, [0, 5, 10]);
+  assert.deepEqual(schedule(3, {dur: 10, lag: 0}).starts, [0, 0, 0], 'lag=0 须同刻齐动');
+});
+
+test('stride 模式与三选一守卫', () => {
+  assert.deepEqual(schedule(3, {dur: 5, stride: 4}).starts, [0, 4, 8]);
+  assert.throws(() => schedule(3, {dur: 5, stride: 4, lag: 1}));
+  assert.throws(() => schedule(3, {dur: 5, lag: 1, fit: {total: 40}}));
+});
+
+test('最小步长与空集', () => {
+  assert.deepEqual(schedule(0, {dur: 5, stride: 4}), {starts: [], dur: 5});
+  const p = schedule(2, {dur: 5, stride: 0}); // 非法步长 → 抬到下限
+  assert.ok(p.starts[1] - p.starts[0] >= 1);
+});
+
+test('起点取整且单调不减', () => {
+  const p = schedule(6, {dur: 7, fit: {total: 53}});
+  for (let i = 1; i < p.starts.length; i++) {
+    assert.ok(p.starts[i] >= p.starts[i - 1], '起点须单调不减');
+    assert.ok(Number.isInteger(p.starts[i]));
+  }
+});
diff --git a/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/gallery.tsx b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/gallery.tsx
new file mode 100644
index 000000000..a71737133
--- /dev/null
+++ b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/gallery.tsx
@@ -0,0 +1,265 @@
+/** MotionGallery——运动层的评审面（独立 Remotion 入口，不经 Root.tsx）。
+ *
+ * 用法（在 video/ 目录，.bin 直调防污染根 workspace）：
+ *   ./node_modules/.bin/remotion still src/motion/gallery.tsx MotionGallery \
+ *       out/motion-gallery.png --frame=30
+ *
+ * 全部模型 × 变体一屏可渲：秒级出图，供 token 校准轮逐格目视。
+ * 色板为本文件内字面量（dev 工具面，不进成片、不读 theme——保持 frozen 跨系列共享）。
+ */
+import React from 'react';
+import {AbsoluteFill, Composition, registerRoot} from 'remotion';
+import {
+  useAccelTravel,
+  useBreathe,
+  useCount,
+  useDim,
+  useDraw,
+  useEnter,
+  useFadeOut,
+  useFlowDash,
+  useImpulse,
+  usePushIn,
+  useReveal,
+  useShake,
+  useStagger,
+  useTravel,
+} from './hooks';
+
+const COLS = 5;
+const CW = 340;
+const CH = 230;
+const GAP = 18;
+
+/** dev 工具面字面量色板（与各集 theme 底座同值但刻意独立声明——不读 theme）。 */
+const C = {
+  bg: '#0E1116',
+  panel: '#171C26',
+  border: '#2A3242',
+  text: '#F2F5FA',
+  dim: '#9AA7B8',
+  core: '#D97757',
+  mech: '#64C4C0',
+  deny: '#EF6461',
+};
+
+/** 单元格壳：定位 + 角标。 */
+const Cell: React.FC<{i: number; name: string; children: React.ReactNode}> = ({i, name, children}) => (
+  <div
+    style={{
+      position: 'absolute',
+      left: 72 + (i % COLS) * (CW + GAP),
+      top: 96 + Math.floor(i / COLS) * (CH + GAP),
+      width: CW,
+      height: CH,
+      background: C.panel,
+      border: `2px solid ${C.border}`,
+      borderRadius: 12,
+    }}
+  >
+    <div
+      style={{
+        position: 'absolute',
+        inset: '28px 0 34px 0',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+      }}
+    >
+      {children}
+    </div>
+    <div style={{position: 'absolute', left: 12, bottom: 8, fontFamily: 'monospace', fontSize: 15, color: C.dim}}>
+      {name}
+    </div>
+  </div>
+);
+
+const Box: React.FC<{color?: string; w?: number; h?: number; style?: React.CSSProperties}> = ({
+  color = C.core,
+  w = 200,
+  h = 80,
+  style,
+}) => <div style={{width: w, height: h, background: C.panel, border: `2px solid ${color}`, borderRadius: 10, ...style}} />;
+
+// ── 每格一个组件：hooks 各归其位（Rules of Hooks 的最简守法形态） ────────
+
+const EnterCell: React.FC<{kind: Parameters<typeof useEnter>[0]}> = ({kind}) => {
+  const e = useEnter(kind, {});
+  return <Box style={{opacity: e.opacity, transform: e.transform}} />;
+};
+
+const StaggerCell: React.FC = () => {
+  const ps = useStagger(5, {dur: 5, fit: {total: 60}});
+  return (
+    <div style={{display: 'flex', gap: 10}}>
+      {ps.map((p, i) => (
+        <div
+          key={i}
+          style={{
+            width: 34,
+            height: 80,
+            background: C.panel,
+            border: `2px solid ${C.mech}`,
+            borderRadius: 8,
+            opacity: p,
+            transform: `translateY(${(1 - p) * 14}px)`,
+          }}
+        />
+      ))}
+    </div>
+  );
+};
+
+const DrawCell: React.FC = () => {
+  const d = useDraw(0, 24);
+  return (
+    <svg width={280} height={110}>
+      <path {...d} d="M10 90 C 90 10, 190 100, 270 20" stroke={C.core} strokeWidth={5} fill="none" strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ImpulseCell: React.FC = () => {
+  const g = useImpulse({dur: 30, peak: 1});
+  return (
+    <div
+      style={{
+        width: 90,
+        height: 90,
+        borderRadius: '50%',
+        background: C.core,
+        opacity: 0.3 + 0.7 * g,
+        boxShadow: `0 0 ${10 + 30 * g}px ${C.core}`,
+      }}
+    />
+  );
+};
+
+const BreatheCell: React.FC = () => {
+  const b = useBreathe({period: 30});
+  return (
+    <svg width={160} height={110}>
+      <circle cx={80} cy={55} r={40} fill="none" stroke={C.mech} strokeWidth={5} opacity={b} />
+    </svg>
+  );
+};
+
+const TravelCell: React.FC = () => {
+  const t = useTravel({cx: 140, cy: 55, r: 42, secPerLap: 3});
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} />
+      <circle cx={t.x} cy={t.y} r={9} fill={C.core} />
+    </svg>
+  );
+};
+
+const AccelCell: React.FC = () => {
+  const t = useAccelTravel({cx: 140, cy: 55, r: 42, durs: [28, 20, 14], at: 4});
+  const heat = `rgb(${217 + Math.round(38 * t.heat)}, ${119 - Math.round(60 * t.heat)}, ${87 - Math.round(20 * t.heat)})`;
+  return (
+    <svg width={280} height={110}>
+      <circle cx={140} cy={55} r={42} fill="none" stroke={C.border} strokeWidth={4} strokeDasharray="4 6" />
+      <circle cx={t.x} cy={t.y} r={9} fill={heat} />
+    </svg>
+  );
+};
+
+const CountCell: React.FC = () => {
+  const v = useCount({to: 255, dur: 40});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 44, color: C.text, fontVariantNumeric: 'tabular-nums'}}>
+      {Math.round(v)}
+    </div>
+  );
+};
+
+const RevealCell: React.FC = () => {
+  const s = useReveal('while (true) { think(); act(); }', {cps: 14});
+  const blink = useBreathe({period: 16, amp: 0.5, base: 0.5});
+  return (
+    <div style={{fontFamily: 'monospace', fontSize: 20, color: C.text, whiteSpace: 'nowrap'}}>
+      {s}
+      <span style={{opacity: blink}}>▍</span>
+    </div>
+  );
+};
+
+const PushInCell: React.FC = () => {
+  const t = usePushIn(0, {scale: 0.12});
+  return <Box w={160} h={90} color={C.mech} style={{transform: t}} />;
+};
+
+const DimCell: React.FC = () => {
+  const dim = useDim({at: 40, to: 0.35});
+  return (
+    <div style={{display: 'flex', gap: 12}}>
+      <Box w={64} h={80} style={{opacity: dim}} />
+      <Box w={64} h={80} color={C.core} />
+      <Box w={64} h={80} style={{opacity: dim}} />
+    </div>
+  );
+};
+
+const FlowCell: React.FC = () => {
+  const f = useFlowDash({period: 24});
+  return (
+    <svg width={280} height={60}>
+      <line x1={10} y1={30} x2={270} y2={30} stroke={C.mech} strokeWidth={5} {...f} strokeLinecap="round" />
+    </svg>
+  );
+};
+
+const ShakeCell: React.FC = () => {
+  const x = useShake({at: 10, amp: 5, decay: true, dur: 40});
+  return <Box w={150} h={80} color={C.deny} style={{transform: `translateX(${x}px)`}} />;
+};
+
+const FadeCell: React.FC = () => {
+  const op = useFadeOut(90, {frames: 36});
+  return (
+    <div style={{position: 'relative', width: 220, height: 90}}>
+      <Box w={220} h={90} color={C.core} style={{position: 'absolute', inset: 0}} />
+      <div style={{position: 'absolute', inset: 0, background: '#000', opacity: 1 - op}} />
+    </div>
+  );
+};
+
+const CELLS: Array<[string, React.ReactNode]> = [
+  ['enter:fall', <EnterCell kind="fall" />],
+  ['enter:rise', <EnterCell kind="rise" />],
+  ['enter:slideL', <EnterCell kind="slideL" />],
+  ['enter:pop', <EnterCell kind="pop" />],
+  ['enter:flyIn', <EnterCell kind="flyIn" />],
+  ['enter:fade', <EnterCell kind="fade" />],
+  ['stagger×5 fit60', <StaggerCell />],
+  ['draw 24f', <DrawCell />],
+  ['impulse 30f', <ImpulseCell />],
+  ['breathe p30', <BreatheCell />],
+  ['travel 3s/lap', <TravelCell />],
+  ['accelTravel', <AccelCell />],
+  ['count→255', <CountCell />],
+  ['reveal 14cps', <RevealCell />],
+  ['pushIn .12', <PushInCell />],
+  ['dim .35@40', <DimCell />],
+  ['flowDash p24', <FlowCell />],
+  ['shake decay', <ShakeCell />],
+  ['fadeOut 36f', <FadeCell />],
+];
+
+const MotionGallery: React.FC = () => (
+  <AbsoluteFill style={{background: C.bg}}>
+    <div style={{position: 'absolute', left: 72, top: 44, fontFamily: 'monospace', fontSize: 24, color: C.text}}>
+      MotionGallery · 30fps · 120f
+    </div>
+    {CELLS.map(([name, node], i) => (
+      <Cell key={name} i={i} name={name}>
+        {node}
+      </Cell>
+    ))}
+  </AbsoluteFill>
+);
+
+registerRoot(() => (
+  <Composition id="MotionGallery" component={MotionGallery} width={1920} height={1080} fps={30} durationInFrames={120} defaultProps={{}} />
+));
diff --git a/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/hooks.ts b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/hooks.ts
new file mode 100644
index 000000000..f87b8a129
--- /dev/null
+++ b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/hooks.ts
@@ -0,0 +1,303 @@
+/** 运动模型（hooks）——分镜「动效」列动词到帧数学的唯一映射。
+ *
+ * 设计约束（违反任何一条即失去本层存在意义）：
+ * 1. hooks 返回数值 / CSS 片段，不渲染 DOM——FadeUp 式包装组件打不进 svg/<g>/
+ *    absolute 布局，是「组件存在却零调用」的实测根因；数值可落进任意 JSX。
+ * 2. 弹簧一律吃局部帧（frame - at）：spring() 每次调用从第 0 帧重模拟，喂全局帧
+ *    会让长片末帧每个 spring 跑两万余次迭代。
+ * 3. effects（不透明度/颜色）永不吃弹簧——一律时长+缓动（tokens 的二分不变量）。
+ * 4. 不读 theme：颜色一律经参数传入（frozen 跨系列共享的前提）。
+ * 5. `at` 锚点一律来自句边界（rel(beat, '句id')），禁写死帧数。
+ */
+import {Easing, interpolate, spring, useCurrentFrame, useVideoConfig} from 'remotion';
+import {
+  DUR,
+  EASING_CP,
+  SPRING,
+  clampRiseDist,
+  type DurToken,
+  type EasingToken,
+  type SpringPreset,
+} from './tokens';
+import {progress, revealCharCount} from './window';
+import {schedule, type ScheduleOpts} from './schedule';
+
+/** 帧数解析：token 或直接帧数；缺省用 def。 */
+export const frames = (d: number | DurToken | undefined, def: number): number =>
+  d === undefined ? def : typeof d === 'number' ? d : DUR[d];
+
+/** 缓动令牌 → Remotion 缓动函数（linear 直通）。 */
+export const easeF = (t: EasingToken): ((x: number) => number) =>
+  t === 'linear'
+    ? Easing.linear
+    : Easing.bezier(
+        ...(EASING_CP[t] as [number, number, number, number]),
+      );
+
+/** 缓动后的 0..1 进度（各模型共用的原子）。 */
+const eased = (
+  frame: number,
+  at: number,
+  dur: number,
+  e: EasingToken,
+): number => interpolate(progress(frame, at, dur), [0, 1], [0, 1], {easing: easeF(e)});
+
+/** 缓动数值进度——「clamped 0→1 手写 interpolate」惯用形的统一替身：
+ *  时机值走 token，缓动默认 standard（线性原版会被这一档替换——质量提升点之一）。 */
+export function useProgress(
+  at: number,
+  dur: number | DurToken = DUR.f5,
+  easing: EasingToken = 'standard',
+): number {
+  const frame = useCurrentFrame();
+  return eased(frame, at, frames(dur, DUR.f5), easing);
+}
+
+/** 弹簧数值进度（驱动几何量/位移；effects 通道用 useProgress——tokens 二分不变量）。
+ *  局部帧 + 可选 durationInFrames 截停（防窗口外余振；缺省不设上限，与既有手写等价）。 */
+export function useSpring(
+  preset: SpringPreset,
+  o: {at?: number; dur?: number | DurToken} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const cfg: Parameters<typeof spring>[0] = {
+    frame: frame - (o.at ?? 0),
+    fps,
+    config: SPRING[preset],
+  };
+  if (o.dur !== undefined) {
+    cfg.durationInFrames = frames(o.dur, DUR.f5);
+  }
+  return spring(cfg);
+}
+
+// ── 入场（enter：落下/上浮/滑入/弹出/飞入/淡入） ────────────────────────
+
+export type EnterKind = 'fall' | 'rise' | 'slideL' | 'slideR' | 'pop' | 'flyIn' | 'fade';
+export type EnterOpts = {
+  /** 句边界锚（局部帧）。 */
+  at?: number;
+  dur?: number | DurToken;
+  easing?: EasingToken;
+  /** 空间通道用弹簧（位移类才有意义；fade/pop 无效）。 */
+  springPreset?: SpringPreset;
+  /** 位移像素（fall/rise/slide*；缺省 30）。 */
+  dist?: number;
+  /** rise 专用：落位态底边 y——行程经 clampRiseDist 钳进字幕安全带之上。 */
+  restBottom?: number;
+};
+export type EnterStyle = {opacity: number; transform: string};
+
+export function useEnter(kind: EnterKind, o: EnterOpts = {}): EnterStyle {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const at = o.at ?? 0;
+  const dur = frames(o.dur, DUR.f4);
+  let dist = o.dist ?? 30;
+  if (kind === 'rise' && o.restBottom !== undefined) {
+    dist = clampRiseDist(dist, o.restBottom);
+  }
+  // effects 通道：纯缓动、略快于空间通道（元素先「看见」再「落位」）
+  const opacity = progress(frame, at, Math.max(2, Math.round(dur * 0.8)));
+  // spatial 通道：可选弹簧（局部帧 + durationInFrames 截停，防窗口外余振）
+  const p = o.springPreset
+    ? spring({
+        frame: frame - at,
+        fps,
+        config: SPRING[o.springPreset],
+        durationInFrames: dur,
+      })
+    : eased(frame, at, dur, o.easing ?? 'standard');
+  const inv = 1 - p;
+  const t: string[] = [];
+  if (kind === 'fall') t.push(`translateY(${-inv * dist}px)`);
+  if (kind === 'rise') t.push(`translateY(${inv * dist}px)`);
+  if (kind === 'slideL') t.push(`translateX(${-inv * dist}px)`);
+  if (kind === 'slideR') t.push(`translateX(${inv * dist}px)`);
+  if (kind === 'pop') t.push(`scale(${0.9 + 0.1 * p})`);
+  if (kind === 'flyIn') t.push(`scale(${0.6 + 0.4 * p})`);
+  return {opacity, transform: t.length ? t.join(' ') : 'none'};
+}
+
+// ── 序列错峰（stagger：依次/逐行/逐条/逐格） ───────────────────────────
+
+export type StaggerOpts = ScheduleOpts & {at?: number; easing?: EasingToken};
+
+/** 返回 n 个 0..1 进度——第 i 项随编排依次入场。 */
+export function useStagger(n: number, o: StaggerOpts = {}): number[] {
+  const frame = useCurrentFrame();
+  const {at = 0, easing = 'standard'} = o;
+  const plan = schedule(n, o);
+  return plan.starts.map((s) => eased(frame, at + s, plan.dur, easing));
+}
+
+// ── 描线（draw：红线三由构造保证——只产 pathLength 归一化三元组） ────────
+
+export type DrawProps = {pathLength: 1; strokeDasharray: 1; strokeDashoffset: number};
+
+export function useDraw(at: number, dur: number | DurToken = DUR.f5): DrawProps {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(dur, DUR.f5), 'decelerate');
+  return {pathLength: 1, strokeDasharray: 1, strokeDashoffset: 1 - p};
+}
+
+// ── 脉冲 / 呼吸（glow 语法：impulse=一次性强调，breathe=持续辉光） ───────
+
+/** 一次性冲击：sin(πp) 包络，起于 0 归于 0，峰值 peak。 */
+export function useImpulse(o: {at?: number; dur?: number | DurToken; peak?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const p = progress(frame, o.at ?? 0, frames(o.dur, DUR.f5));
+  return Math.sin(Math.PI * p) * (o.peak ?? 1);
+}
+
+/** 持续呼吸（原 0.55+0.45·sin(frame/K) 散写的收敛；period 帧一周期——注意与
+ *  原除数 K 的换算 period = 2πK，如 sin(frame/26) → period 163）。offset 为相位
+ *  平移（错峰辉光的 per-index 形态）。 */
+export function useBreathe(
+  o: {period?: number; amp?: number; base?: number; offset?: number} = {},
+): number {
+  const frame = useCurrentFrame();
+  const {amp = 0.45, base = 0.55, period = 26, offset = 0} = o;
+  return base + amp * Math.sin((2 * Math.PI * (frame - offset)) / period);
+}
+
+// ── 巡游（travel：环形为主；absorb 原 useRingDot 与加速绕行累加器克隆） ──
+
+export type TravelPos = {x: number; y: number; angle: number};
+
+/** 匀速环形巡游（angle 单位度，-90 = 12 点方向起）。 */
+export function useTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  secPerLap?: number;
+  offset?: number;
+}): TravelPos {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const lap = (frame / (fps * (o.secPerLap ?? 2.5)) + (o.offset ?? 0)) % 1;
+  const a = -90 + lap * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), angle: a};
+}
+
+/** 加速绕行：逐圈时长 durs[]（如 [40,30,22,16]），跑完全部圈后冻结在终点。
+ *  heat 0..1 随圈数推进（「失控感」的配色偏移系数）。 */
+export function useAccelTravel(o: {
+  cx: number;
+  cy: number;
+  r: number;
+  durs: number[];
+  at?: number;
+  heatPerLap?: number;
+}): {x: number; y: number; heat: number} {
+  const frame = useCurrentFrame();
+  let t = Math.max(0, frame - (o.at ?? 0));
+  let lap = 0;
+  while (lap < o.durs.length && t >= o.durs[lap]) {
+    t -= o.durs[lap];
+    lap += 1;
+  }
+  const within = lap >= o.durs.length ? 1 : t / o.durs[lap];
+  const heat = Math.min(1, lap / (o.heatPerLap ?? o.durs.length));
+  const a = -90 + within * 360;
+  const rad = (a * Math.PI) / 180;
+  return {x: o.cx + o.r * Math.cos(rad), y: o.cy + o.r * Math.sin(rad), heat};
+}
+
+// ── 计数 / 水位（meter 语法；显示层自行 Math.round / toFixed） ──────────
+
+export function useCount(o: {
+  from?: number;
+  to: number;
+  at?: number;
+  dur?: number | DurToken;
+  ease?: EasingToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {from = 0, to, at = 0} = o;
+  const p = eased(frame, at, frames(o.dur, DUR.f6), o.ease ?? 'standard');
+  return from + (to - from) * p;
+}
+
+// ── 打字机 / 逐字流出（type；Terminal 之外的泛化） ──────────────────────
+
+export function useReveal(
+  text: string,
+  o: {at?: number; cps?: number; framesPerChar?: number} = {},
+): string {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const elapsed = Math.max(0, frame - (o.at ?? 0));
+  const n = revealCharCount(elapsed, fps, o.cps ?? 12, o.framesPerChar);
+  return text.slice(0, Math.min(text.length, n));
+}
+
+// ── 镜头推近（pushIn 语法：beat 切换的镜头语言，替代纯淡入） ────────────
+
+export function usePushIn(at: number, o: {scale?: number; dur?: number | DurToken} = {}): string {
+  const frame = useCurrentFrame();
+  const p = eased(frame, at, frames(o.dur, DUR.f5), 'decelerate');
+  return `scale(${1 + (o.scale ?? 0.06) * p})`;
+}
+
+// ── 压暗 / 提亮（emphasis 反向：让主体从群像中浮出） ─────────────────────
+
+/** 返回目标透明度系数（1 = 原；to 0.4 即压暗到 40%）。 */
+export function useDim(o: {at: number; to?: number; dur?: number | DurToken}): number {
+  const frame = useCurrentFrame();
+  const p = eased(frame, o.at, frames(o.dur, DUR.f4), 'standard');
+  return 1 + ((o.to ?? 0.4) - 1) * p;
+}
+
+// ── 流光（flow 语法：连线上的行进虚线） ─────────────────────────────────
+
+/** 返回可直接展开到 <line>/<path> 的描边属性（像素 dasharray——与 draw 的
+ *  pathLength 归一化描线是两个正交特性，勿混用于同一元素：红线三）。 */
+export function useFlowDash(o: {
+  dash?: number;
+  gap?: number;
+  /** 帧速率：每 period 帧行进一个 dash+gap 周期。 */
+  period?: number;
+}): {strokeDasharray: string; strokeDashoffset: number} {
+  const frame = useCurrentFrame();
+  const {dash = 10, gap = 14, period = 40} = o;
+  return {
+    strokeDasharray: `${dash} ${gap}`,
+    strokeDashoffset: -(frame * (dash + gap)) / period,
+  };
+}
+
+// ── 抖动（错误/故障语义；收敛 P2/P3 两处克隆） ──────────────────────────
+
+/** 返回 translateX 像素值。active 缺省 true；decay=true 时按 dur 衰减归零。 */
+export function useShake(o: {
+  at: number;
+  active?: boolean;
+  amp?: number;
+  /** 相位分母（原手写 /1.6、/2.2 的口径）。 */
+  freq?: number;
+  decay?: boolean;
+  dur?: number | DurToken;
+}): number {
+  const frame = useCurrentFrame();
+  const {amp = 3, freq = 1.6} = o;
+  const t = frame - o.at;
+  if (o.active === false || t < 0) {
+    return 0;
+  }
+  if (o.decay) {
+    const env = 1 - progress(frame, o.at, frames(o.dur, DUR.f5));
+    return amp * env * Math.sin(t / freq);
+  }
+  return amp * Math.sin(t / freq);
+}
+
+// ── 片尾渐黑（红线四：从 beat 总时长推导，勿用末句时长） ────────────────
+
+export function useFadeOut(durationInFrames: number, o: {frames?: number} = {}): number {
+  const frame = useCurrentFrame();
+  const f = o.frames ?? 36; // 1.2s
+  return 1 - progress(frame, durationInFrames - f, f);
+}
diff --git a/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/index.ts b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/index.ts
new file mode 100644
index 000000000..97fd22a5c
--- /dev/null
+++ b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/index.ts
@@ -0,0 +1,5 @@
+/** 运动层门面——场景代码统一 `import {...} from '../motion'`。 */
+export * from './tokens';
+export * from './window';
+export * from './schedule';
+export * from './hooks';
diff --git a/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/schedule.ts b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/schedule.ts
new file mode 100644
index 000000000..5703e3315
--- /dev/null
+++ b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/schedule.ts
@@ -0,0 +1,65 @@
+/** 错峰编排（stagger）纯函数——收敛手写 `frame - i*N`（跨 8 集约 356 处、
+ *  步长 K∈{2,3,4,5,6,8,10} 任意取值、无节奏标尺）。
+ *
+ * 三种模式（互斥，参数即文档）：
+ * - stride：固定步长（与旧手写行为一致——迁移期的保守选项）；
+ * - lag：Manim LaggedStart 语义 start[i] = i·dur·lagRatio（0 = 同刻齐动，1 = 首尾相接）；
+ * - fit：n 个子项恰好装进窗口 total（末项恰在窗口末完成——「随句推进」的首选）。
+ *
+ * 钳制优先级（motion.test.ts 钉死，自左向右）：不外溢窗口 > 最小步长 > 子项时长。
+ * 窗口属于 beat 时间轴，外溢会踩进下一 beat；装不下时先缩子项时长，连 1 帧
+ * 子项都无法错开时显式抛错，不返回违反 fit 契约的计划。
+ */
+export type ScheduleOpts = {
+  /** 子项时长（帧；缺省 DUR.f3=5——「快速子项」档）。 */
+  dur?: number;
+  /** 模式一：固定步长。 */
+  stride?: number;
+  /** 模式二：lag 比率（Manim lag_ratio）。 */
+  lag?: number;
+  /** 模式三：拟装入的窗口总长（帧）。 */
+  fit?: {total: number};
+  /** 相邻起点期望下限，默认 2 帧；fit 紧窗时可按优先级退至 1 帧。 */
+  minStride?: number;
+  /** 子项时长期望下限，默认 3 帧；fit 为守住窗口可退至 1 帧。 */
+  minDur?: number;
+};
+export type Schedule = {starts: number[]; dur: number};
+
+export function schedule(n: number, o: ScheduleOpts): Schedule {
+  const minStride = o.minStride ?? 2;
+  const minDur = o.minDur ?? 3;
+  const modes = [o.stride !== undefined, o.lag !== undefined, o.fit !== undefined].filter(
+    Boolean,
+  ).length;
+  if (modes > 1) {
+    throw new Error('schedule: stride / lag / fit 三选一');
+  }
+  let dur = Math.max(minDur, o.dur ?? 5);
+  if (n <= 0) {
+    return {starts: [], dur};
+  }
+  let stride: number;
+  if (o.fit) {
+    const total = Math.max(1, o.fit.total);
+    if (n > 1 && total < n) {
+      throw new Error(
+        `schedule: fit.total=${total} 无法容纳 ${n} 个至少 1 帧且起点间隔至少 1 帧的子项`,
+      );
+    }
+    dur = Math.min(dur, total);
+    stride = n === 1 ? 0 : (total - dur) / (n - 1);
+    const targetStride = Math.max(1, minStride);
+    if (n > 1 && stride < targetStride) {
+      // 先缩时长争取期望步长；仍不足时牺牲步长，但至少保留 1 帧先后。
+      dur = Math.max(1, Math.min(dur, total - targetStride * (n - 1)));
+      stride = (total - dur) / (n - 1);
+    }
+  } else if (o.lag !== undefined) {
+    stride = dur * o.lag;
+  } else {
+    stride = o.stride ?? minStride;
+  }
+  stride = Math.max(n === 1 || o.lag === 0 ? 0 : 1, stride);
+  return {starts: Array.from({length: n}, (_, i) => Math.round(i * stride)), dur};
+}
diff --git a/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/tokens.ts b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/tokens.ts
new file mode 100644
index 000000000..457448260
--- /dev/null
+++ b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/tokens.ts
@@ -0,0 +1,87 @@
+/** 运动令牌——时长标尺 / 缓动曲线 / 弹簧手感 的单一事实源。
+ *
+ * 只放纯数据与纯函数：不 import remotion、不读 theme（颜色一律经参数注入）——
+ * 这是本层能以 frozen 档跨两个系列共享的前提（两系列 theme token 名已分叉：
+ * CC 用 core/mech/deny、SE 用 danger），判据同 test_chrome_motifs_only_read_base_theme_tokens。
+ *
+ * 取值依据（勿凭感觉改；改前先在本集校准轮逐幕目视复测，依据写回此处注释）：
+ * - 时长六档取 IBM Carbon DTCG（70/110/150/240/400/700ms）@30fps 四舍五入。
+ *   弃 Material 十六档：30fps 量化下其 15 个相邻对里 6 对落进同一帧数（伪选择）。
+ * - 缓动控制点取 Material 3 标准三件；曲线本体在 hooks.ts 经 Remotion Easing.bezier 求值。
+ * - 弹簧预设锚定本仓实测手感：settle=200 即既有 9/10 调用点的惯用值（延续成片观感），
+ *   snap=12 来自 P4「插头咬合」的过冲；ζ 与过冲峰值的关系由 motion.test.ts 用
+ *   Mp = exp(-πζ/√(1-ζ²)) 钉死。
+ * - effects 不变量：不透明度/颜色永不过冲——effects 类动画一律时长+缓动，
+ *   弹簧只用于空间位移（M3 spatial/effects 二分的落地）。
+ */
+
+/** 时长标尺（帧 @30fps）。叙事节拍（4–8s）不用此表——那是 window/schedule 的职责。 */
+export const DUR = {
+  /** 70ms：微反馈（辉光起点、光标） */
+  f1: 2,
+  /** 110ms：快速子项（列表错峰的单项时长） */
+  f2: 3,
+  /** 150ms：标准入场 */
+  f3: 5,
+  /** 200ms：强调入场 */
+  f4: 7,
+  /** 400ms：大位移 / 镜头推近 / 描线 */
+  f5: 12,
+  /** 700ms：幕级大动作（少用） */
+  f6: 21,
+} as const;
+export type DurToken = keyof typeof DUR;
+
+/** 缓动令牌。 */
+export type EasingToken = 'standard' | 'decelerate' | 'accelerate' | 'linear';
+
+/** 贝塞尔控制点（x1,y1,x2,y2）；linear 无控制点。 */
+export const EASING_CP: Record<
+  Exclude<EasingToken, 'linear'>,
+  readonly [number, number, number, number]
+> = {
+  // M3 standard：入场默认
+  standard: [0.2, 0, 0, 1],
+  // M3 decelerate：强减速（大位移入场、镜头推近）
+  decelerate: [0.05, 0.7, 0.1, 1],
+  // M3 accelerate：出场加速
+  accelerate: [0.3, 0, 0.8, 0.15],
+};
+
+/** 弹簧预设（直传 Remotion spring config；ζ = c/(2√(k·m))）。 */
+export type SpringPreset = 'settle' | 'settleSoft' | 'snap';
+export const SPRING: Record<SpringPreset, {damping: number; stiffness: number; mass: number}> = {
+  // ζ≈10：无过冲平滑滑入——本仓主流手感（既有场景 9/10 处 damping 200）
+  settle: {damping: 200, stiffness: 100, mass: 1},
+  // ζ≈8.5：更绵一点（P0/P1 既有 180/170 档的收敛）
+  settleSoft: {damping: 170, stiffness: 100, mass: 1},
+  // ζ≈0.6：轻微过冲（咬合/弹入——原 P4 damping 12）
+  snap: {damping: 12, stiffness: 100, mass: 1},
+};
+
+/** 阻尼比 ζ。设计系统文档普遍给 ζ（无量纲），Remotion 取阻尼系数 c——直抄会得
+ *  ζ≈0.02 的暴力弹跳且能通过渲染体检，这是迁移期最高风险项（单测钉死）。 */
+export const dampingRatio = (s: {
+  damping: number;
+  stiffness: number;
+  mass: number;
+}): number => s.damping / (2 * Math.sqrt(s.stiffness * s.mass));
+
+/** 欠阻尼弹簧的峰值位置（1 = 恰好到终点不过冲；ζ ≥ 1 恒 1）。
+ *  Mp = exp(-πζ/√(1-ζ²)) 是超出终点的幅度，峰值 = 1 + Mp。 */
+export const overshootPeak = (zeta: number): number =>
+  zeta >= 1 ? 1 : 1 + Math.exp((-Math.PI * zeta) / Math.sqrt(1 - zeta * zeta));
+
+/** 出场快于入场的系数（MDC 实测 400ms 入 / 150ms 出 ≈ 0.375，取 0.4 禁手填）。 */
+export const EXIT_FACTOR = 0.4;
+
+/** 字幕安全带上沿：1080 - qa_frames.SUBTITLE_BAND_PX(160)，与体检口径同源。 */
+export const SAFE_TOP_Y = 920;
+
+/** 自下方入场的行程安全钳制：落位态底边 restBottom 之上才是可用的进场空间。
+ *  ISSUE-170 的手工逐卡反算收敛于此——该缺陷类从「评审抽帧抓」变「构造不可能」。 */
+export const clampRiseDist = (
+  dist: number,
+  restBottom: number,
+  safeTop: number = SAFE_TOP_Y,
+): number => Math.max(0, Math.min(dist, safeTop - restBottom));
diff --git a/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/window.ts b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/window.ts
new file mode 100644
index 000000000..69bd59c7a
--- /dev/null
+++ b/apps/negentropy-influence/pipeline/templates/video-skeleton/video/src/motion/window.ts
@@ -0,0 +1,43 @@
+/** 运动窗口纯函数——「父级持有绝对时间，子动画只是父进度上的窗口」。
+ *
+ * 这是 audio-first 时序与可复用运动模型兼容的核心机制：beat 的绝对帧来自
+ * beatWindow()（数据源是 TTS 实测 manifest），子动画不写死帧数、只声明自己在
+ * beat 进度上的 [start, end] 窗口 ⇒ 旁白实测时长变化时全部窗口自动重定时，
+ * 「写死帧数与口播脱钩」缺陷类（skills/08 实录）由构造消灭。
+ *
+ * 语义借 MDC TransitionUtils.lerp(startFraction, endFraction)：窗外钳制端点。
+ * 本模块零依赖（不 import remotion / theme）——frozen 跨系列共享与 node 单测的前提。
+ */
+
+/** 钳制到 [0,1]——一切进度的唯一出口，防负值/超 1 渗进 transform。 */
+export const clamp01 = (x: number): number => (x < 0 ? 0 : x > 1 ? 1 : x);
+
+/** 子动画窗口：父进度 p(0..1) 在 [s,e] 片段上的局部进度。 */
+export const win = (p: number, w: readonly [number, number]): number =>
+  clamp01((p - w[0]) / (w[1] - w[0]));
+
+/** beat 进度：局部帧 → 该 beat 的 0..1 进度。 */
+export const beatProgress = (
+  frame: number,
+  from: number,
+  durationInFrames: number,
+): number => clamp01((frame - from) / Math.max(1, durationInFrames));
+
+/** 帧域进度：[at, at+dur] 上的 0..1（dur ≤ 0 视作 1，防除零）。 */
+export const progress = (frame: number, at: number, dur: number): number =>
+  clamp01((frame - at) / Math.max(1, dur));
+
+/** 已过帧数 → 可见字符数；cps 随实际 fps 换算，显式帧间隔不受 fps 影响。 */
+export const revealCharCount = (
+  elapsedFrames: number,
+  fps: number,
+  cps: number,
+  framesPerChar?: number,
+): number => {
+  const elapsed = Math.max(0, elapsedFrames);
+  const count =
+    framesPerChar === undefined
+      ? Math.floor((elapsed / fps) * cps)
+      : Math.floor(elapsed / Math.max(1, framesPerChar));
+  return Math.max(0, count);
+};
diff --git a/apps/negentropy-influence/pipeline/tests/test_build_narration.py b/apps/negentropy-influence/pipeline/tests/test_build_narration.py
index 00540169e..f8f2df54e 100644
--- a/apps/negentropy-influence/pipeline/tests/test_build_narration.py
+++ b/apps/negentropy-influence/pipeline/tests/test_build_narration.py
@@ -68,3 +68,49 @@ def test_sentence_before_any_scene_heading(tmp_path):
     r = run_build(root)
     assert r.returncode != 0
     assert "## Pn" in (r.stderr + r.stdout)  # 报真正原因而非「与所在幕  不一致」
+
+
+def test_series_layer_published_requires_ready_and_online_marker(tmp_path):
+    influence = tmp_path / "influence"
+    root = influence / "episodes" / "episode-one"
+    (root / "script").mkdir(parents=True)
+    (root / "script" / "narration.md").write_text(
+        "## P0\n- [p0-01] 测试。\n", encoding="utf-8"
+    )
+    (influence / "series.json").write_text(
+        json.dumps(
+            {
+                "seriesList": [
+                    {
+                        "id": "series-one",
+                        "episodes": [
+                            {
+                                "path": "episodes/episode-one",
+                                "cardSub": "第一层 · 循环",
+                                "title": "未上线",
+                                "status": "ready",
+                                "voice": "配音已完成",
+                            },
+                            {
+                                "path": "episodes/episode-two",
+                                "cardSub": "第二层 · 循环",
+                                "title": "已上线",
+                                "status": "ready",
+                                "voice": "已上线 · 定稿",
+                            },
+                        ],
+                    }
+                ]
+            },
+            ensure_ascii=False,
+        ),
+        encoding="utf-8",
+    )
+
+    r = run_build(root)
+
+    assert r.returncode == 0, r.stderr
+    layers = json.loads(
+        (root / "video" / "src" / "series-layers.json").read_text(encoding="utf-8")
+    )["layers"]
+    assert [layer["published"] for layer in layers] == [False, True]
diff --git a/apps/negentropy-influence/pipeline/tests/test_check_script.py b/apps/negentropy-influence/pipeline/tests/test_check_script.py
index f9c17302a..a27bd4250 100644
--- a/apps/negentropy-influence/pipeline/tests/test_check_script.py
+++ b/apps/negentropy-influence/pipeline/tests/test_check_script.py
@@ -306,3 +306,72 @@ def test_pron_candidates_silent_on_clean_text(project):
     rc, out = run_check(project, "--pron-candidates")
     assert rc == 0, out
     assert "候选命中 0 处" in out
+
+
+# ---------------- --check-motion：动效列 @动词 ↔ 场景代码互比 ----------------
+
+
+BOARD_MOTION = """# 分镜
+## P0
+| 镜 | 句区间 | 画面 | 动效 |
+|---|---|---|---|
+| 0-A | p0-01..02 | x | `@enter:fall` 自上落下 `@draw` 描线 |
+## P1
+| 镜 | 句区间 | 画面 | 动效 |
+|---|---|---|---|
+| 1-A | p1-01..02 | x | `@stagger` 依次点亮 |
+"""
+
+
+def write_motion_hooks(root: Path) -> None:
+    m = root / "video" / "src" / "motion"
+    m.mkdir(parents=True, exist_ok=True)
+    (m / "hooks.ts").write_text(
+        "export function useEnter() {}\nexport function useStagger() {}\n",
+        encoding="utf-8",
+    )
+
+
+def write_scene(root: Path, name: str, src: str) -> None:
+    d = root / "video" / "src" / "scenes"
+    d.mkdir(parents=True, exist_ok=True)
+    (d / name).write_text(src, encoding="utf-8")
+
+
+def test_check_motion_warns_on_unimplemented_verb(project):
+    """镜内声明 @动词 而该幕场景未调用 → WARN（FadeUp 散文失约的机械化）。"""
+    write_board(project, BOARD_MOTION)
+    write_config(project, CFG_OK)
+    write_narration(project, [BENIGN, BENIGN, BENIGN, BENIGN])
+    write_motion_hooks(project)
+    write_scene(
+        project,
+        "P0Hook.tsx",
+        "import {useEnter} from '../motion';\nconst e = useEnter('fall');\n",
+    )
+    write_scene(project, "P1Loop.tsx", "export const P1Loop = () => null;\n")
+    rc, out = run_check(project, "--check-motion")
+    assert rc == 0, out  # WARN-only 不改退出码
+    warned = [line for line in out.splitlines() if "未调用" in line]
+    assert any("1-A" in line and "@stagger" in line for line in warned), out
+    assert not any("0-A" in line for line in warned), out  # @enter 已实现不告警
+
+
+def test_check_motion_unknown_verb_and_missing_layer(project):
+    """@teleport 不在词表 → WARN；运动层未铺设（无 hooks.ts）→ 门静默不适用。"""
+    board = BOARD_MOTION.replace("@stagger", "@teleport")
+    write_board(project, board)
+    write_config(project, CFG_OK)
+    write_narration(project, [BENIGN, BENIGN, BENIGN, BENIGN])
+    write_motion_hooks(project)
+    write_scene(project, "P0Hook.tsx", "import {useEnter} from '../motion';\n")
+    write_scene(project, "P1Loop.tsx", "export const P1Loop = () => null;\n")
+    rc, out = run_check(project, "--check-motion")
+    assert "@teleport" in out and "词表" in out
+
+    # 无运动层的集（已冻结旧集形态）：不因缺 hooks.ts 而炸或误报
+    import shutil
+
+    shutil.rmtree(project / "video" / "src" / "motion")
+    rc, out = run_check(project, "--check-motion")
+    assert rc == 0 and "未调用" not in out, out
diff --git a/apps/negentropy-influence/pipeline/tests/test_docs_paths.py b/apps/negentropy-influence/pipeline/tests/test_docs_paths.py
index d9f8eb050..9dd97f100 100644
--- a/apps/negentropy-influence/pipeline/tests/test_docs_paths.py
+++ b/apps/negentropy-influence/pipeline/tests/test_docs_paths.py
@@ -245,3 +245,9 @@ def test_episode_and_template_readmes_carry_no_location_literal():
         "分集/模板 README 不得出现位置字面量（用 $I 派生，见 pipeline/README.md）：\n  "
         + "\n  ".join(offenders)
     )
+
+
+def test_direct_compare_command_anchors_both_videos_to_project():
+    skill = (SKILLS / "08-render-qa.md").read_text(encoding="utf-8")
+    assert "--compare $P/out/baseline-draft.mp4 $P/out/draft.mp4" in skill
+    assert "--compare out/baseline-draft.mp4 out/draft.mp4" not in skill
diff --git a/apps/negentropy-influence/pipeline/tests/test_qa_checks.py b/apps/negentropy-influence/pipeline/tests/test_qa_checks.py
index f0f161147..ef747573d 100644
--- a/apps/negentropy-influence/pipeline/tests/test_qa_checks.py
+++ b/apps/negentropy-influence/pipeline/tests/test_qa_checks.py
@@ -6,10 +6,19 @@
 from pathlib import Path
 
 import numpy as np
+import pytest
 from PIL import Image
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
-from qa_frames import check_frames, check_theme, tail_row_has_fade, wcag_ratio  # noqa: E402
+import qa_frames  # noqa: E402
+from qa_frames import (  # noqa: E402
+    beat_head_samples,
+    check_frames,
+    check_theme,
+    frame_diff,
+    tail_row_has_fade,
+    wcag_ratio,
+)
 
 
 def make_png(path: Path, mode: str, scale: float = 1.0) -> None:
@@ -218,3 +227,125 @@ def test_multi_scene_sampling_is_per_scene(tmp_path):
     assert [i for i in ids if i.startswith("p0-")], "P0 必须有帧被抽到"
     assert [i for i in ids if i.startswith("p6-")], "P6 必须有帧被抽到"
     assert len(ids) == 5
+
+
+# ── beat 头部采样 + A/B 帧差（纯函数） ────────────────────────────────────
+
+
+def test_beat_head_samples_covers_every_beat_head():
+    """每 beat 首句起点连抽 N 帧，帧号 = start*fps + i（与句中点采样互补的盲区面）。"""
+
+    beats = [
+        ("0-A", "p0-01", "p0-02", "p0-01..02"),
+        ("0-B", "p0-03", "p0-04", "p0-03..04"),
+        ("1-A", "p1-01", "p1-03", "p1-01..03"),
+    ]
+    tl = {
+        "p0-01": (0.6, 3.0),
+        "p0-02": (3.6, 3.0),
+        "p0-03": (6.6, 3.0),
+        "p0-04": (9.6, 3.0),
+        "p1-01": (12.6, 4.0),
+    }
+    got = beat_head_samples(beats, tl, fps=30, n=3)
+    names = [n for n, _ in got]
+    assert names == [
+        "0-A-h0",
+        "0-A-h1",
+        "0-A-h2",
+        "0-B-h0",
+        "0-B-h1",
+        "0-B-h2",
+        "1-A-h0",
+        "1-A-h1",
+        "1-A-h2",
+    ]
+    # 第一帧恰在 beat 起点（0.6s），其后按 1/fps 递增
+    assert got[0][1] == 0.6
+    assert abs(got[1][1] - (0.6 + 1 / 30)) < 1e-9
+    assert abs(got[6][1] - 12.6) < 1e-9
+
+
+def test_beat_head_samples_scene_filter_and_stale_beats():
+    beats = [("0-A", "p0-01", "p0-02", ""), ("4-A", "p4-01", "p4-02", "")]
+    tl = {"p0-01": (0.6, 3.0), "p4-01": (99.0, 3.0)}
+    only4 = beat_head_samples(beats, tl, fps=30, n=1, scene_filter=["P4"])
+    assert [n for n, _ in only4] == ["4-A-h0"]
+    # 区间首句不在 manifest（分镜陈旧）→ 该 beat 整体跳过，不静默错位
+    stale = beat_head_samples([("2-A", "p2-99", "p2-99", "")], tl, fps=30, n=2)
+    assert stale == []
+
+
+def test_frame_diff_quantifies_and_localizes(tmp_path):
+    same = tmp_path / "same.png"
+    make_png(same, "subtitle")  # make_png 返回 None，路径自持
+    d = frame_diff(same, same)
+    assert d["frac"] == 0.0 and d["bbox"] is None
+
+    # 右下角一块 40×40 的差异：frac ≈ 1600/总像素，bbox 指向差异区
+    img = Image.open(same).convert("RGB")
+    arr = np.array(img)
+    arr[-40:, -40:] = [255, 255, 255]
+    other = tmp_path / "other.png"
+    Image.fromarray(arr).save(other)
+    d = frame_diff(same, other)
+    assert 0 < d["frac"] < 0.05
+    x0, y0, x1, y1 = d["bbox"]
+    assert x1 - x0 < 45 and y1 - y0 < 45  # bbox 紧贴差异块而非全图
+
+
+def test_compare_keeps_first_positional_id(project, monkeypatch):
+    extracted: list[str] = []
+
+    def fake_extract(_ffmpeg, _video, _cwd, _ts, dst):
+        extracted.append(dst.name)
+
+    monkeypatch.setattr(qa_frames, "extract_frame", fake_extract)
+    monkeypatch.setattr(
+        qa_frames,
+        "frame_diff",
+        lambda _a, _b: {"mean": 0.0, "frac": 0.0, "bbox": None},
+    )
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        [
+            "qa_frames.py",
+            "--project",
+            str(project),
+            "--compare",
+            "baseline.mp4",
+            "draft.mp4",
+            "p0-01",
+            "p0-02",
+        ],
+    )
+
+    qa_frames.main()
+
+    assert extracted == [
+        "p0-01.a.png",
+        "p0-01.b.png",
+        "p0-02.a.png",
+        "p0-02.b.png",
+    ]
+
+
+@pytest.mark.parametrize(
+    "mode",
+    [
+        ["draft.mp4", "--beat-heads", "1", "--scene", "P99"],
+        ["--compare", "baseline.mp4", "draft.mp4", "--scene", "P99"],
+    ],
+)
+def test_qa_modes_fail_when_selection_is_empty(project, monkeypatch, mode):
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        ["qa_frames.py", "--project", str(project), *mode],
+    )
+
+    with pytest.raises(SystemExit) as exc:
+        qa_frames.main()
+
+    assert exc.value.code != 0
diff --git a/apps/negentropy-influence/pipeline/tests/test_skeleton.py b/apps/negentropy-influence/pipeline/tests/test_skeleton.py
index 391dac54a..5a996c375 100644
--- a/apps/negentropy-influence/pipeline/tests/test_skeleton.py
+++ b/apps/negentropy-influence/pipeline/tests/test_skeleton.py
@@ -550,3 +550,71 @@ def test_chrome_motifs_only_read_base_theme_tokens():
         f"模板 motifs.tsx 读了 seed 未定义的 theme.{missing} —— 概念色须经 "
         "accent prop 注入，否则 scaffold 出的新集开箱即 TS2339"
     )
+
+
+# ── 运动层（motion）───────────────────────────────────────────────────────
+
+#: frozen 运动层的全部文件（skeleton.toml frozen 清单的 motion 子集）
+MOTION_FILES = (
+    "video/src/motion/tokens.ts",
+    "video/src/motion/window.ts",
+    "video/src/motion/schedule.ts",
+    "video/src/motion/hooks.ts",
+    "video/src/motion/index.ts",
+    "video/src/motion/gallery.tsx",
+    "video/scripts/motion.test.ts",
+)
+
+
+def test_motion_layer_is_frozen_and_complete():
+    """运动层文件面齐全且全部归 frozen 档——「共享的是运动机制」这一边界的机器化。
+
+    反向判据（缺文件不受门）由 test_every_template_file_is_classified 承担；
+    此处钉住「在 frozen 而非 seeded」：错放 seeded 会重蹈 motifs.tsx 裂成 5 份的覆辙。
+    """
+    skel = skeleton()
+    frozen = set(skel["classes"].get("frozen", []))
+    missing = [f for f in MOTION_FILES if f not in frozen]
+    assert not missing, f"运动层文件未归 frozen：{missing}"
+    for rel in MOTION_FILES:
+        assert (TEMPLATE / rel).is_file(), f"模板缺 {rel}"
+
+
+def test_motion_layer_reads_no_theme_tokens():
+    """frozen 运动层不得读 theme——两系列 theme token 名已分叉（core/mech/deny vs
+    danger），读 concept 色会当场破坏跨系列可冻结性。颜色只许经参数注入。
+
+    判据同 test_chrome_motifs_only_read_base_theme_tokens 的口径：先剥注释，
+    再查 `theme.` 引用与 theme import——注释里的散文会假阳/假阴。
+    """
+    import re
+
+    for rel in MOTION_FILES:
+        src = (TEMPLATE / rel).read_text(encoding="utf-8")
+        stripped = re.sub(r"/\*.*?\*/", "", src, flags=re.DOTALL)
+        stripped = re.sub(r"^\s*//.*$", "", stripped, flags=re.MULTILINE)
+        assert not re.search(r"\bfrom\s+'(?:\.\./)+design/theme'", stripped), (
+            f"{rel} import 了 theme——运动层颜色只许经参数注入"
+        )
+        assert "theme." not in stripped, f"{rel} 读 theme.*——concept 色会破坏跨系列冻结"
+
+
+def test_motion_test_imports_only_pure_modules():
+    """motion.test.ts 只许 import 纯模块（tokens/window/schedule）与 node 内建——
+    import hooks（remotion/react）会让 node --test 在无渲染环境里炸。"""
+    src = (TEMPLATE / "video/scripts/motion.test.ts").read_text(encoding="utf-8")
+    for m in re.finditer(r"from\s+'(\.\./src/motion/[a-z]+)\.ts'", src):
+        assert m.group(1).endswith(("tokens", "window", "schedule")), (
+            f"motion.test.ts import 了非纯模块：{m.group(1)}"
+        )
+
+
+def test_motion_test_lives_outside_tsc_include():
+    """单测文件须在 video/ 而非 video/src/：其 import 带 .ts 后缀（Node ESM 解析
+    规则），落进 tsconfig include 会因 allowImportingTsExtensions 未开而报 TS5097。"""
+    tsconfig = json.loads(
+        (TEMPLATE / "video/tsconfig.json").read_text(encoding="utf-8")
+    )
+    include = tsconfig.get("include", [])
+    assert "src" in include and "video/scripts/motion.test.ts" not in include
+    assert not (TEMPLATE / "video/src/motion/motion.test.ts").exists()
diff --git a/apps/negentropy-influence/pipeline/tests/test_stages.py b/apps/negentropy-influence/pipeline/tests/test_stages.py
index 986906430..48946ce26 100644
--- a/apps/negentropy-influence/pipeline/tests/test_stages.py
+++ b/apps/negentropy-influence/pipeline/tests/test_stages.py
@@ -17,6 +17,7 @@
 from __future__ import annotations
 
 import re
+import subprocess
 import sys
 import tomllib
 from pathlib import Path
@@ -164,6 +165,54 @@ def test_fanout_slice_skips_global_option_values():
     assert set(GLOBAL_OPTS_WITH_VALUE) == {"--series", "--project"}
 
 
+def test_check_forwards_motion_flag(monkeypatch, tmp_path):
+    import pipeline
+
+    commands: list[list[str]] = []
+    monkeypatch.setattr(
+        pipeline, "run", lambda cmd, cwd=None: commands.append(cmd) or 0
+    )
+
+    assert pipeline.cmd_check(tmp_path, {}, motion=True) == 0
+    assert "--check-motion" in commands[0]
+
+
+def test_tts_forwards_no_store_flag(monkeypatch, tmp_path):
+    import pipeline
+
+    commands: list[list[str]] = []
+    monkeypatch.setattr(
+        pipeline, "run", lambda cmd, cwd=None: commands.append(cmd) or 0
+    )
+
+    assert (
+        pipeline.cmd_tts(
+            tmp_path,
+            {"tts": {"engine": "edge"}},
+            plan=False,
+            force=False,
+            steady=None,
+            style=None,
+            skip_pre_tts=True,
+            no_store=True,
+        )
+        == 0
+    )
+    assert "--no-store" in commands[0]
+
+
+def test_pipeline_cli_registers_forwarded_flags():
+    for subcommand, flag in (("check", "--check-motion"), ("tts", "--no-store")):
+        result = subprocess.run(
+            [sys.executable, str(PIPELINE_PY), subcommand, "--help"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        assert result.returncode == 0, result.stderr
+        assert flag in result.stdout
+
+
 def test_fanout_complement_is_nonempty_and_keeps_destructive_out():
     """反向：**未列入白名单**的子命令必须非空，且 tts/render/qa/all/clean-samples
     恰在其中——这是白名单（而非黑名单）的意义：未来新增子命令默认不可扇出，
diff --git a/apps/negentropy-influence/pipeline/tests/test_tts_store.py b/apps/negentropy-influence/pipeline/tests/test_tts_store.py
new file mode 100644
index 000000000..158fe26f5
--- /dev/null
+++ b/apps/negentropy-influence/pipeline/tests/test_tts_store.py
@@ -0,0 +1,207 @@
+"""音频版本库（tts.py 内容寻址持久库）的纯函数契约。
+
+背景：集内 audio/ 是 gitignored 本地产物，换 worktree 即丢——版本库按
+（集 slug, 句 id, digest）三元组持久化合成成果，使「改稿只重配变更句」
+跨工作区成立。此处钉死四条不变量：回收等价缓存命中、digest 失配必 miss、
+历史版本并存不覆盖、禁用时全程直通。
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
+import tts  # noqa: E402
+from tts import (
+    digest_indextts,
+    store_deposit,
+    store_entry,
+    store_has,
+    store_restore,
+    store_root,
+)
+
+
+def _mk(root: Path, name: str, size: int = 64) -> Path:
+    """占位音频：store 只搬运字节不解析，内容无语义。"""
+    p = root / name
+    p.write_bytes(bytes(range(size % 251)))
+    return p
+
+
+def test_roundtrip_deposit_then_restore(tmp_path):
+    audio, store = tmp_path / "audio", tmp_path / "store"
+    audio.mkdir()
+    src = _mk(tmp_path, "p0-01.mp3")
+    store_deposit(src, "p0-01", "d" * 40, store, "ep-video")
+    assert store_has(store, "ep-video", "p0-01", "d" * 40)
+    # 集内目录为空（换 worktree 后缓存丢失的形态）→ 回收命中并落位 mp3 + .sha
+    assert store_restore("p0-01", "d" * 40, audio, store, "ep-video")
+    assert (audio / "p0-01.mp3").read_bytes() == src.read_bytes()
+    assert (audio / "p0-01.sha").read_text() == "d" * 40
+
+
+def test_digest_mismatch_is_miss(tmp_path):
+    audio, store = tmp_path / "audio", tmp_path / "store"
+    audio.mkdir()
+    src = _mk(tmp_path, "p0-02.mp3")
+    store_deposit(src, "p0-02", "a" * 40, store, "ep-video")
+    assert not store_has(store, "ep-video", "p0-02", "b" * 40)
+    assert not store_restore("p0-02", "b" * 40, audio, store, "ep-video")
+    assert not (audio / "p0-02.mp3").exists()
+
+
+def test_history_versions_coexist(tmp_path):
+    store = tmp_path / "store"
+    v1, v2 = _mk(tmp_path, "v1.mp3", 10), _mk(tmp_path, "v2.mp3", 200)
+    store_deposit(v1, "p1-07", "1" * 40, store, "ep")
+    store_deposit(v2, "p1-07", "2" * 40, store, "ep")
+    # 不同 digest 不同文件名 ⇒ 历史版本并存，改稿不丢旧版（可回退）
+    assert store_entry(store, "ep", "p1-07", "1" * 40).is_file()
+    assert store_entry(store, "ep", "p1-07", "2" * 40).is_file()
+
+
+def test_same_digest_deposit_refreshes(tmp_path):
+    store = tmp_path / "store"
+    old, new = _mk(tmp_path, "old.mp3", 10), _mk(tmp_path, "new.mp3", 230)
+    d = "e" * 40
+    store_deposit(old, "p3-01", d, store, "ep")
+    store_deposit(
+        new, "p3-01", d, store, "ep"
+    )  # 同 digest 重跑（--force）→ 刷新为新音频
+    assert store_entry(store, "ep", "p3-01", d).read_bytes() == new.read_bytes()
+
+
+def test_disabled_store_is_transparent(tmp_path):
+    assert store_root(disabled=True) is None
+    src = _mk(tmp_path, "x.mp3")
+    store_deposit(src, "x", "c" * 40, None, "ep")  # no-op 不炸、不建目录
+    assert not (tmp_path / "store").exists()
+    assert not store_restore("x", "c" * 40, tmp_path, None, "ep")
+
+
+def test_env_override(monkeypatch, tmp_path):
+    monkeypatch.setenv("NE_TTS_STORE", str(tmp_path / "custom"))
+    assert store_root(disabled=False) == tmp_path / "custom"
+
+
+def test_empty_env_disables_store(monkeypatch):
+    monkeypatch.setenv("NE_TTS_STORE", "")
+    assert store_root(disabled=False) is None
+
+
+def test_store_read_error_degrades_to_miss(monkeypatch, tmp_path):
+    store = tmp_path / "store"
+    src = _mk(tmp_path, "p2-01.mp3")
+    digest = "f" * 40
+    store_deposit(src, "p2-01", digest, store, "ep")
+    original = Path.read_text
+
+    def broken_read(path, *args, **kwargs):
+        if path.suffix == ".sha" and store in path.parents:
+            raise OSError("store unavailable")
+        return original(path, *args, **kwargs)
+
+    monkeypatch.setattr(Path, "read_text", broken_read)
+    assert not store_has(store, "ep", "p2-01", digest)
+
+
+def test_store_restore_error_degrades_to_miss(monkeypatch, tmp_path):
+    audio, store = tmp_path / "audio", tmp_path / "store"
+    audio.mkdir()
+    src = _mk(tmp_path, "p2-02.mp3")
+    digest = "a" * 40
+    store_deposit(src, "p2-02", digest, store, "ep")
+    monkeypatch.setattr(
+        tts.shutil,
+        "copyfile",
+        lambda _src, _dst: (_ for _ in ()).throw(OSError("read failed")),
+    )
+    assert not store_restore("p2-02", digest, audio, store, "ep")
+
+
+def test_deposit_failure_does_not_replace_published_entry(monkeypatch, tmp_path):
+    store = tmp_path / "store"
+    old = _mk(tmp_path, "old-atomic.mp3", 20)
+    new = _mk(tmp_path, "new-atomic.mp3", 200)
+    digest = "b" * 40
+    store_deposit(old, "p3-02", digest, store, "ep")
+    dst = store_entry(store, "ep", "p3-02", digest)
+    before = dst.read_bytes()
+
+    def broken_copy(_src, target):
+        Path(target).write_bytes(b"partial")
+        raise OSError("disk full")
+
+    monkeypatch.setattr(tts.shutil, "copyfile", broken_copy)
+    store_deposit(new, "p3-02", digest, store, "ep")
+
+    assert dst.read_bytes() == before
+    assert dst.with_suffix(".sha").read_text() == digest
+
+
+def test_deposit_publishes_with_same_directory_replace(monkeypatch, tmp_path):
+    store = tmp_path / "store"
+    src = _mk(tmp_path, "atomic.mp3", 80)
+    real_replace = tts.os.replace
+    replacements: list[tuple[Path, Path]] = []
+
+    def record_replace(source, target):
+        source, target = Path(source), Path(target)
+        replacements.append((source, target))
+        assert source.parent == target.parent
+        real_replace(source, target)
+
+    monkeypatch.setattr(tts.os, "replace", record_replace)
+    store_deposit(src, "p3-03", "c" * 40, store, "ep")
+
+    assert len(replacements) == 2
+
+
+def test_local_cache_hit_backfills_empty_store(monkeypatch, tmp_path):
+    audio, store = tmp_path / "audio", tmp_path / "store"
+    audio.mkdir()
+    item = {"id": "p4-01", "scene": "P4", "text": "本地缓存。"}
+    digest = digest_indextts(
+        "r" * 12,
+        "neutral",
+        None,
+        1.0,
+        1.0,
+        "ZH",
+        "indextts",
+        item["text"],
+    )
+    _mk(audio, "p4-01.mp3")
+    (audio / "p4-01.sha").write_text(digest, encoding="utf-8")
+    monkeypatch.setattr(tts, "mp3_duration", lambda _path: 1.25)
+
+    def unexpected_synthesis(*_args, **_kwargs):
+        raise AssertionError("本地缓存命中时不应调用服务端")
+
+    monkeypatch.setattr(tts, "http_synthesize", unexpected_synthesis)
+
+    result = asyncio.run(
+        tts.synth_indextts(
+            asyncio.Semaphore(1),
+            item,
+            False,
+            "",
+            "r" * 12,
+            "neutral",
+            None,
+            1.0,
+            1.0,
+            "ZH",
+            "indextts",
+            "http://unused",
+            audio,
+            store=store,
+            slug="ep",
+        )
+    )
+
+    assert result["durationSec"] == 1.25
+    assert store_has(store, "ep", "p4-01", digest)
diff --git a/apps/negentropy-influence/series.json b/apps/negentropy-influence/series.json
index ecd6405da..470c194cb 100644
--- a/apps/negentropy-influence/series.json
+++ b/apps/negentropy-influence/series.json
@@ -102,7 +102,7 @@
             "accessed": "2026-08-21"
           },
           "status": "draft-review",
-          "statusNote": "Harness Engineering 改造草渲待审：13:58 = 25151 帧 @30fps（167 句）；七幕抽帧 FAIL 0 · WARN 0；高风险帧逐帧目检通过；终渲未启动",
+          "statusNote": "运动层重制版草渲待审（2026-09-03）：13:58.80 = 25164 帧 @30fps（167 句，配音全量重合成——TTS 复跑漂移 -478 帧仍在预算窗）；七幕 + beat 头部 + 尾幕 FAIL 0 · WARN 0；A/B 对拍 167 帧（基线=重制前代码同 manifest 渲染）：仅 2 帧 >5% 均为 HarnessStack 新装置（P0 开场/P6 收尾），其余 ≤1.5% 归因于顶边常驻条/SceneTag 移位/令牌化缓动；终渲 final.mp4 43.6MB 已出、captions.srt/vtt 齐",
           "voice": "sunny-steady + me-bright.wav"
         },
         {
diff --git a/docs/.agents/issue.md b/docs/.agents/issue.md
index 59bd27794..e9fa632f4 100644
--- a/docs/.agents/issue.md
+++ b/docs/.agents/issue.md
@@ -3829,11 +3829,12 @@ R7 后浏览器对照 Section 2.1 区域发现两类正交缺陷：
      命令行 `--ignore-workspace`、根 workspace glob 不匹配），v12 仍从第四个维度
      （`packageManager` 的目录树向上查找）穿透进来。判断隔离是否成立，要问的是
      "**还有哪些机制会沿目录树向上走**"，而不是"我声明了几次隔离"。
-  5. `package.json#pnpm` 字段自 v11 起失效（[ISSUE-076](#issue-076-pnpm-v11-升级后-pnpm-install-报-err_pnpm_ignored_builds--packagejsonpnpmoverrides-静默失效2026-05-08)）
-     的状况在 v12 **未恶化**，仍是 WARN；[ISSUE-166](#issue-166-err_pnpm_ignored_builds-在-esbuild-上是无害噪声不要为消音改动跨集冻结文件2026-08-21)
-     "不为消音改动跨集冻结文件"的裁决继续有效——本次新增 `pnpm-workspace.yaml` 是出于
-     **数据安全的独立必要性**，故**刻意不**顺手把失效的 `onlyBuiltDependencies` 迁进去：
-     那会让已发布集的 esbuild postinstall 从"被拦"变成"执行"，是与本次无关的行为变更。
+  5. `package.json#pnpm` 字段自 v11 起失效（[ISSUE-076](#issue-076-pnpm-v11-升级后-pnpm-install-报-err_pnpm_ignored_builds--packagejsonpnpmoverrides-静默失效2026-05-08)）。
+     **2026-09-03 后续复验修正了本条的初始裁决**：pnpm 12.2.1 在这些独立 Remotion 工程中会因
+     未许可 `esbuild` 以 `ERR_PNPM_IGNORED_BUILDS` 中断安装并留下半残 `node_modules`，不再只是
+     [ISSUE-166](#issue-166-err_pnpm_ignored_builds-在-esbuild-上是无害噪声不要为消音改动跨集冻结文件2026-08-21)
+     所记录的无害提示。故 8 集与骨架已统一删除失效的 `onlyBuiltDependencies`，并在各自
+     `pnpm-workspace.yaml` 写入 `allowBuilds.esbuild = true`；安装说明必须引用该唯一有效位置。
 - **同类问题影响**：与 [ISSUE-076](#issue-076-pnpm-v11-升级后-pnpm-install-报-err_pnpm_ignored_builds--packagejsonpnpmoverrides-静默失效2026-05-08)
   （v10→v11）构成升级序列。凡"子目录里跑包管理器"的场景都需重新体检。
   [`travel-agent-ui`](../../apps/cognizes/src/cognizes/examples/e2e_travel_agent/frontend/travel-agent-ui)
@@ -3848,3 +3849,14 @@ R7 后浏览器对照 Section 2.1 区域发现两类正交缺陷：
   - 故危险路径是"**发现裸 install 没装到子目录 → 照 8 集的习惯补 `--ignore-workspace`**"。
     修复照搬本次方案（补一份 `packages: []` 的 `pnpm-workspace.yaml`）即可，因不属 pnpm 升级
     的必要变更而未纳入本次改动；触碰该示例前先补文件，勿先跑安装。
+
+## ISSUE-176 组件存在却零调用：FadeUp 三度分镜承诺未进代码，~50 处布尔硬门瞬现无人拦（2026-09-03）
+
+- **表因**：重制《执行层：一个循环，就是全部》前的动效审计发现：frozen `cards.tsx` 的 `FadeUp`/`Pill` 场景调用数为 **0**，而分镜 3 处明写「`FadeUp`」（1-B 五步点亮、4-A 需求浮现、6-A 标签）——工程师每次手写了一个参数不同的内联版本。同幕另有约 50 处 `frame >= X ? <el/> : null` 布尔硬门（元素零过渡瞬现，可感知的质量缺陷），全片 30 处 clamped 进度变量时长取值 12 种任意值、11 处错峰步长任意、10 处 spring damping 不一致。
+- **根因**：三个结构性缺口叠加——① 复用组件是 **div 包装器**，打不进 svg `<g>`/absolute 布局，工程师宁可内联；② 分镜「动效」列是自由散文，`check_script.py` 只解析镜号与句区间，转译环节零机检；③ 无运动令牌标尺，时长/步长/阻尼每次现场发明。
+- **处理方式**：引入 frozen 运动层 `video/src/motion/`（「共享怎么动、不共享画什么」：Carbon 六档时长令牌 + M3 缓动 + 本仓实测弹簧手感 + win() 窗口 + Manim lag_ratio 编排 + 12 个运动模型 **hooks**——返回数值/CSS 片段而非 DOM）；分镜动效列 `@动词` 标注 + `check_script --check-motion`（WARN-only，词表自 hooks.ts 派生）；布尔硬门改 `useProgress` 淡入。以 EP1 全片重制验证（A/B 同帧号对拍归因每一处差异）。
+- **后续防范**：
+  1. 可复用动效原语的形态必须是 **hook/纯函数**，不是包装组件——包装器对 svg 布局的排他性在代码评审里不可见，在「没人用」里可见。
+  2. 分镜承诺的动效动词须可机检：散文「FadeUp」不进任何门；`@动词` 标注让「写了没实现」变成 WARN。
+  3. 时序常数（时长/步长/阻尼/安全带）收敛令牌后，「看起来差不多的手写值」失去了存在的理由——新代码裸 interpolate 属逃生舱，须有注释说明为何豁免。
+- **同类问题影响**：全部 8 集约 356 处 `frame - i*N` 错峰、82 处 dasharray 描线、71 处计数散写同病；EP2–5 的 retrofit 与 HarnessStack 同步是后续独立批次（skills/06 落地状态块显式登记五集不一致）。
diff --git a/docs/.agents/knowledge-map.md b/docs/.agents/knowledge-map.md
index 056a45da3..4b03ae821 100644
--- a/docs/.agents/knowledge-map.md
+++ b/docs/.agents/knowledge-map.md
@@ -70,7 +70,7 @@
 - [自进化 Agents Team 调研](../research/self-evolution/130-self-evolving-agents-team.md) — 自进化智能体理论（DGM/ADAS/AlphaEvolve/AgentSquare）+ 进化算子（GEPA/ACE/DSPy）+ 评测回路（Agent-as-a-Judge/OTel/Langfuse）+ 工具生态自进化（MCP Registry/Agent Skills/LLM 自造工具）+ 记忆/知识系统自进化（MemGPT/Mem0/A-Mem 自编辑记忆、ReasoningBank/Memp 经验沉淀、MemEvolve/MemSkill 记忆元进化、Zep/HippoRAG 2 图谱记忆、SSGM/MINJA 记忆治理）+ 护栏治理（OWASP Agentic Top 10/金丝雀/Goodhart 防护），映射至四层自进化架构（技术方案见 [自进化 Agents Team 方案](../concepts/design/self-evolving-agents.md)）
 - [经验时代的自驱迭代进化智能体调研](../research/self-evolution/140-experience-era-self-improvement.md) — 精读 88 页综述提炼 Harness 经验基础设施框架，对照 negentropy Routine 闭环诊断出两处根本断点（Judge 无历史锚点 ±20 振荡 / `decay_override` 死配置致经验记忆 7-8 天全灭 + 反馈链断），落地双支柱改进：证据锚定纵向评估（trajectory + progress_evidence + 量化振荡 opt-in）与经验记忆闭环补强（衰减修复 E / 检索反馈闭环 B / 写入去重准入 A / 失败教训结构化与注入 C-D）
 - [Skill 进化闭环 × 自我改进评测](../research/self-evolution/141-skills-evolution-and-si-measurement.md) — 综述 §3（Skills 三阶段 Evolution 缺口）/ §7（Meta-Evolving 三体制）/ §8（SI 六目标 + SIP-Bench + 反事实归因）映射到 negentropy：PR [#1038](https://github.com/ThreeFish-AI/negentropy/pull/1038) 落地 eval 四表 + held-out 双相门（decide_skill_shadow/canary）+ 反事实 Skill Influence Pattern + TargetHandler 抽象 + SkillTemplateHandler 闭环（GEPA 变异 prompt_template + active_version 发布），补 140 号未覆盖的 Skills/Meta/SI 度量框架
-- [科普视频制作 Pipeline（公共基建，apps/negentropy-influence）](../../apps/negentropy-influence/README.md) — 子项目已从仓库根 media/ 迁入 apps/（分层：pipeline/ 机制 vs episodes/ 内容，路径锚点=根哨兵 `.influence-root`，对目录深度免疫）；全仓可复用的论文→视频九阶段流水线：`pipeline.py` 单入口（status/doctor/build/check/tts/captions/render/qa/all/clean-samples/stages，另有 `--series` 白名单扇出——仅 status/doctor/build/check 可扇出，子命令 flag 逐字转发）+ 每集 `pipeline.toml` 声明式配置（[schema/默认值层](../../apps/negentropy-influence/pipeline/scripts/config.py)：机制常数进代码、toml 只写偏离，缺失会让时长门**点名跳过**而非静默）+ `timing.json` 时序 SSOT（timing.ts 与 Python 共读，双语言镜像漂移结构性消灭）+ [stages.toml](../../apps/negentropy-influence/pipeline/stages.toml) 九阶段唯一声明（序号↔文件号错位 ⑥↔07/⑦↔06 显式化并由 test_stages 执法）；技能规格 skills/01–09，真 Skill 挂载于 [.agent/skills/science-video-pipeline](../../.agent/skills/science-video-pipeline/SKILL.md)（纯路由壳，其死链已入 check_series 受检面）；测试 `pipeline/tests/`（全量 5 秒内跑完，digest 黄金哈希守缓存零失效）；骨架三件套 [templates/video-skeleton](../../apps/negentropy-influence/pipeline/templates/video-skeleton/skeleton.toml)（scaffold 实例化 + verify_skeleton 按系列分组 md5 漂移门，「复制源头」从「任一既有集」收敛为命名模板）；工具：check_script（分镜覆盖性/时长预算双口径 + `--pre-tts` 合成前置门 + `--pron-candidates` 多音字复听清单）、check_series（系列一致性**六规则**执法 [series.json](../../apps/negentropy-influence/series.json)：口播反串线/多标题顺序/序号绑定/清单完整性含反向登记与撞色/死链/可渲染性）、captions（srt/vtt）、qa_frames --check（黑帧/字幕带侵入/冻帧/WCAG 对比度自动体检）+ `--stills-plan`（分幕复检抽帧计划）、paper_extract（论文取证五子命令）、source_ledger（B 型信源固定提交+双指纹清单，`sync`/`audit` 按系列地图批量建账并离线执法）、refs（样本指纹清单）、tts_progress（长跑热漂移旁路监视）；Stage ① 分两型——A 型论文（paper_extract + paper-notes.md）、B 型文档/代码/课程站点（source_ledger + source-notes.md + 证据三级），见 [skills/01](../../apps/negentropy-influence/pipeline/skills/01-source-extraction.md)。
+- [科普视频制作 Pipeline（公共基建，apps/negentropy-influence）](../../apps/negentropy-influence/README.md) — 子项目已从仓库根 media/ 迁入 apps/（分层：pipeline/ 机制 vs episodes/ 内容，路径锚点=根哨兵 `.influence-root`，对目录深度免疫）；全仓可复用的论文→视频九阶段流水线：`pipeline.py` 单入口（status/doctor/build/check/tts/captions/render/qa/all/clean-samples/stages，另有 `--series` 白名单扇出——仅 status/doctor/build/check 可扇出，子命令 flag 逐字转发）+ 每集 `pipeline.toml` 声明式配置（[schema/默认值层](../../apps/negentropy-influence/pipeline/scripts/config.py)：机制常数进代码、toml 只写偏离，缺失会让时长门**点名跳过**而非静默）+ `timing.json` 时序 SSOT（timing.ts 与 Python 共读，双语言镜像漂移结构性消灭）+ [stages.toml](../../apps/negentropy-influence/pipeline/stages.toml) 九阶段唯一声明（序号↔文件号错位 ⑥↔07/⑦↔06 显式化并由 test_stages 执法）；技能规格 skills/01–09，真 Skill 挂载于 [.agent/skills/science-video-pipeline](../../.agent/skills/science-video-pipeline/SKILL.md)（纯路由壳，其死链已入 check_series 受检面）；测试 `pipeline/tests/`（全量 5 秒内跑完，digest 黄金哈希守缓存零失效）；骨架三件套 [templates/video-skeleton](../../apps/negentropy-influence/pipeline/templates/video-skeleton/skeleton.toml)（scaffold 实例化 + verify_skeleton 按系列分组 md5 漂移门，「复制源头」从「任一既有集」收敛为命名模板）；运动层 `video/src/motion/`（frozen，2026-09 重制 EP1 时引入——「共享怎么动、不共享画什么」：令牌/窗口/编排/12 运动模型 hooks + MotionGallery 评审面，铁律与规格见 [skills/06 运动层](../../apps/negentropy-influence/pipeline/skills/06-remotion-implementation.md)；QA 新面：`qa_frames --beat-heads` 入场瞬态补盲 + `--compare` A/B 对拍、`check_script --check-motion` 分镜 @动词 机检）；工具：check_script（分镜覆盖性/时长预算双口径 + `--pre-tts` 合成前置门 + `--pron-candidates` 多音字复听清单）、check_series（系列一致性**六规则**执法 [series.json](../../apps/negentropy-influence/series.json)：口播反串线/多标题顺序/序号绑定/清单完整性含反向登记与撞色/死链/可渲染性）、captions（srt/vtt）、qa_frames --check（黑帧/字幕带侵入/冻帧/WCAG 对比度自动体检）+ `--stills-plan`（分幕复检抽帧计划）、paper_extract（论文取证五子命令）、source_ledger（B 型信源固定提交+双指纹清单，`sync`/`audit` 按系列地图批量建账并离线执法）、refs（样本指纹清单）、tts_progress（长跑热漂移旁路监视）；Stage ① 分两型——A 型论文（paper_extract + paper-notes.md）、B 型文档/代码/课程站点（source_ledger + source-notes.md + 证据三级），见 [skills/01](../../apps/negentropy-influence/pipeline/skills/01-source-extraction.md)。
 - [科普视频作品总览（两个系列 8 集）](../../apps/negentropy-influence/series.md) — 机读 SSOT [series.json](../../apps/negentropy-influence/series.json) 顶层为 `seriesList[]`；**自进化系列**（论文型）《上线之后，AI 才开始上学》（金/青/紫，v3 已交付，成片 14:01）→《AI 如何自己变强？》（蓝/橙）→《会写代码的 AI，开始给自己写代码》（绿/洋红）；**Claude Code Harness Engineering**（文档/代码型，5 集 Harness Engineering 改造中，原「通俗全解」版合计 66.9 分钟）《执行层：一个循环，就是全部》（陶土橙/石青/警示红，14:14.73）→《规划层：模型的视野是安排出来的》（鸢紫，13:14.00）→《记忆层：会丢的和不能丢的》（苔绿，13:14.47）→《时机层：谁来按下开始》（霜蓝，13:08.90）→《协作层：从一个到一群》（赭金，13:03.27）；信源 Learn Claude Code s01–s20 双钉（首集钉仓库 main `f9e8b28` 17 章整合版，其余四集钉站点同源修订 `67a9126c` 20 章版，MIT，归属登记见 [source-map](../../apps/negentropy-influence/source-map/claude-code-explained.md)）。多系列执法语义：反串线规则跨系列全局，顺序类规则按系列内判定；口播永不携带集数序号，顺序变更 TTS 代价恒为零。
 - [系列信源地图（source-map，多集系列的章节归属 SSOT）](../../apps/negentropy-influence/source-map/claude-code-explained.md) — 站点↔仓库**修订分叉**的系列级唯一登记处（ISSUE-165 根因再上探：站点整站是课程旧修订，20 章 vs main 17 章整合版，故双钉——ep1 钉 main、后续集钉站点同源修订 67a9126c）；机器版 [claude-code-explained.toml](../../apps/negentropy-influence/source-map/claude-code-explained.toml) 供 `source_ledger.py sync/audit` 派生台账条目名（{slug}-readme/-code/-site，与 ep1 交付台账字节兼容）并离线执法三断言（条目齐/无跨集混入/pinned_ref=地图值）；各集 source-notes 只链接不重述。
 - [IndexTTS 声音克隆手册](../../apps/negentropy-influence/pipeline/VOICE-CLONING.md) — 双引擎 TTS 的克隆侧单一参考：部署（~/tools/index-tts 服务）/参考样本（prospect+prepare+refs 指纹门）/风格预设（sunny 明快阳光推荐位、sunny-steady 成片档 beams=3）/试听关卡（tts_sample + 领航片段）/缓存摘要与幂等/许可合规。