@lightcone-ai/daemon 0.23.5 → 0.23.6

package/mcp-servers/official/media-tools/index.js

@@ -266,28 +266,31 @@ server.tool(
       })).optional().describe(
         'For visual_kind=video URL recording sections: ordered atom sequence. Sum of duration_ms '
         + 'must equal audio_duration_ms (±200ms); use "fill" on the last hold to auto-balance.\n\n'
-        + 'READING-FLOW MODE (REQUIRED — enforced by lint): operations must simulate a person '
-        + 'sliding a finger through the page while narrating, pausing at key spots to explain. '
+        + 'TRANSITION + EXPLAIN MODE (REQUIRED — enforced by lint): the recording should feel '
+        + 'like a person opening a page and walking the viewer through it block by block. '
         + 'Concretely:\n'
-        + '  • Each non-opening segment MUST contain at least one scroll_to with duration_ms >= 1500.\n'
-        + '  • Any hold with duration_ms > 2000 MUST be immediately preceded by a scroll_to with duration_ms >= 1500.\n'
-        + '  • Avoid the "jump + freeze" anti-pattern: scroll_to(duration_ms < 1000) followed by hold(duration_ms > 2000). '
-        + 'It makes the recording feel like a screenshot slideshow, not a page being read.\n\n'
-        + 'GOOD example for a 9.5s segment narrating "宁波银行金融科技部主推 FinTech 暑期专项":\n'
+        + '  • scroll_to is a TRANSITION between content blocks — short (~500-800ms is fine), '
+        + 'smooth (atomScrollTo programmatic mode handles smoothness automatically; speed does NOT need to be slow).\n'
+        + '  • hold is where the NARRATION happens — long holds (2-5s) are the norm, not the exception. '
+        + 'This is when the agent says the actual sentences about this block.\n'
+        + "  • Every non-opening segment MUST start with a scroll_to (the transition into this segment's "
+        + 'content block). Segments starting with hold are REJECTED — they cause jump cuts.\n'
+        + '  • The shape is: "scroll to new block → pause and explain → scroll to next block → pause and explain".\n\n'
+        + 'GOOD example for a 5s segment narrating "宁波银行金融科技部 FinTech 暑期专项":\n'
         + '  [\n'
-        + '    { atom: "scroll_to", y: 280,  duration_ms: 2500 },   // slow slide while saying "宁波银行金融科技部，正式开放 FinTech 暑期专项"\n'
-        + '    { atom: "hold",                duration_ms: 1200 },   // brief pause on title to let viewer read\n'
-        + '    { atom: "scroll_to", y: 980,  duration_ms: 3200 },   // continue sliding while narrating job content\n'
-        + '    { atom: "hold",                duration_ms: 1400 },   // pause on key bullet list\n'
-        + '    { atom: "scroll_to", y: 1450, duration_ms: 1500 },   // final slide to closing block\n'
-        + '    { atom: "hold",                duration_ms: "fill" }, // remaining audio time (~700ms expected)\n'
+        + '    { atom: "scroll_to", y: 280, duration_ms: 700 },     // 0.7s smooth transition to title\n'
+        + '    { atom: "hold",               duration_ms: "fill" }, // ~4.3s: agent narrates this block\n'
         + '  ]\n\n'
-        + 'BAD example (will be REJECTED by reading_flow_violation):\n'
+        + 'GOOD example for a 9s segment with two content blocks inside:\n'
         + '  [\n'
-        + '    { atom: "scroll_to", y: 1000, duration_ms: 600 },    // jump cut\n'
-        + '    { atom: "hold",                duration_ms: 5000 },   // 5s freeze ← rejected\n'
-        + '    { atom: "scroll_to", y: 2500, duration_ms: 800 },    // jump cut\n'
-        + '    { atom: "hold",                duration_ms: "fill" }, // ← rejected\n'
+        + '    { atom: "scroll_to", y: 980, duration_ms: 700 },     // transition to first block\n'
+        + '    { atom: "hold",              duration_ms: 4000 },    // narrate this block (~"金融产品应用开发岗 …")\n'
+        + '    { atom: "scroll_to", y: 1450, duration_ms: 600 },    // short transition to next block\n'
+        + '    { atom: "hold",               duration_ms: "fill" }, // narrate next block (~3.7s)\n'
+        + '  ]\n\n'
+        + 'BAD example (REJECTED by transition_required):\n'
+        + '  [\n'
+        + '    { atom: "hold", duration_ms: 5000 },     // segment starts with hold ← rejected\n'
         + '  ]',
       ),
     })).describe('Segments to plan. audio_path is required for each. V5 fields (action, target_y, target_y_content_label, focus_region, transition_ms, dwell_ms, phase.beats[]) are rejected.'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.23.5",
+  "version": "0.23.6",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/_vendor/video/recorder/atoms.js

@@ -53,7 +53,7 @@ export async function atomScrollTo(page, _ctx, {
   target_y,
   duration_ms,
   curve = 'easeInOutQuad',
-  jitter_px = 2,
+  jitter_px = 0,  // 不要微动 — 用户反复明确要求
   from_y = null,
   mode = 'auto',
 } = {}) {
@@ -70,17 +70,21 @@ export async function atomScrollTo(page, _ctx, {
   const durationMs = Number(duration_ms);
   const distance = Math.abs(targetY - fromY);
 
-  // Auto-mode heuristic: touch works for short distances (single segment, no
-  // inter-segment fling interference) OR slow velocities (each segment has
-  // time to settle before the next starts). Fast long-distance scrolls fall
-  // back to programmatic, where the easing loop drives root.scrollTo
-  // deterministically.
-  // Thresholds chosen empirically against the v4 failure mode (~1100px in
-  // ~1000ms → ~1100 px/s, fling-interrupt-fling, page never reached target).
-  const velocity = durationMs > 0 ? (distance / durationMs) * 1000 : 0; // px/s
+  // Auto-mode: default to programmatic (RAF-driven smooth scroll). The touch
+  // path uses humanizedScroll which splits any scroll > 260px into multiple
+  // CDP swipes, each with ±18-26px random horizontal nudge and fling-cancel-
+  // fling boundaries — that looks like "颤抖着分多次拨", not a clean slide.
+  // User feedback is unambiguous: scroll must be a smooth transition between
+  // content blocks, not a teleport (instant snap) and not a wobble (multi-
+  // segment touch with horizontal drift). Programmatic with RAF achieves
+  // both — every frame moves, vertical only, no inter-segment pauses.
+  // Touch mode remains available via explicit `mode: 'touch'` for callers
+  // that specifically want gesture physics.
+  const velocity = durationMs > 0 ? (distance / durationMs) * 1000 : 0; // px/s (kept for diagnostics)
+  void velocity;
   const resolvedMode = mode === 'programmatic' || mode === 'touch'
     ? mode
-    : (distance < 240 || velocity < 500 ? 'touch' : 'programmatic');
+    : 'programmatic';
 
   if (resolvedMode === 'touch') {
     await humanizedScroll(page, {
@@ -96,68 +100,75 @@ export async function atomScrollTo(page, _ctx, {
       targetY,
       durationMs,
       curve,
-      jitterPx: Math.max(0, Number(jitter_px) || 0),
     });
   }
   return { anchorY: Math.round(targetY) };
 }
 
-// Programmatic scroll: hands the animation off to the browser's native
-// scroll engine via `scroll-behavior: smooth`. That way the easing runs on
-// the compositor thread at the display refresh rate, independent of how
-// busy the page's JS is. The JS-driven setTimeout approach we tried first
-// gets badly throttled on JS-heavy article pages (60Hz timers can stretch
-// to 150-200ms), turning a 1s transition into 5-8s.
+// Programmatic scroll: JS-driven RAF loop that incrementally updates the
+// scroll position frame-by-frame over `durationMs`. This produces an actual
+// smooth scroll the viewer sees in the recording — the previous version
+// did a hard instant snap and then a static wait, which looked like a
+// teleport ("跳一下然后定格"), not like a person sliding a page.
 //
-// The wait is Node-side, so even if the in-page scrollend never fires we
-// still cap the section at durationMs and move on. We deliberately do NOT
-// wait for scrollend — empirically faster than dispatching the event on
-// page-heavy mobile sites.
+// Why not native `scroll-behavior: smooth` or `scrollTo({behavior:'smooth'})`?
+// In Playwright + a headless mobile context, native smooth-scroll often
+// gets capped to a fixed short duration (~300-500ms) regardless of distance,
+// or is throttled by the page's own scroll logic. We need a duration we
+// control end-to-end.
+//
+// Frame loop runs inside page.evaluate so it stays in lockstep with the
+// page's render thread — important when recordVideo is capturing 30fps.
 async function programmaticScroll(page, {
   fromY,
   targetY,
   durationMs,
+  curve = 'easeInOutQuad',
 } = {}) {
-  // Try every plausible scroll target — mobile article pages sometimes have
-  // a fixed-position outer body and scroll happens on an inner container.
-  // We dispatch to all candidates and let whichever one is actually the
-  // scroller win. Returns the diagnostics so we can debug when the page
-  // refuses to scroll.
-  const diag = await page.evaluate((input) => {
-    const candidates = [];
-    if (document.scrollingElement) candidates.push(document.scrollingElement);
-    if (document.documentElement) candidates.push(document.documentElement);
-    if (document.body) candidates.push(document.body);
-    candidates.push(window);
-
-    const before = candidates.map((c) => {
-      if (c === window) return { tag: 'window', y: window.scrollY };
-      return { tag: c.tagName, y: c.scrollTop };
-    });
-
-    // Hard snap to target on every candidate (instant, no animation).
-    for (const c of candidates) {
-      try {
-        if (c === window) window.scrollTo(0, input.targetY);
-        else { c.scrollTop = input.targetY; }
-      } catch { /* ignore */ }
+  await page.evaluate(async (input) => {
+    function pickScroller() {
+      if (document.scrollingElement) return document.scrollingElement;
+      if (document.documentElement) return document.documentElement;
+      return document.body;
     }
+    function easeInOutQuad(t) { return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2; }
+    function easeOutQuad(t) { return 1 - (1 - t) * (1 - t); }
+    function linear(t) { return t; }
+    const ease = input.curve === 'linear' ? linear
+      : input.curve === 'easeOutQuad' ? easeOutQuad
+      : easeInOutQuad;
 
-    const after = candidates.map((c) => {
-      if (c === window) return { tag: 'window', y: window.scrollY };
-      return { tag: c.tagName, y: c.scrollTop };
-    });
+    const scroller = pickScroller();
+    const startY = (scroller === document.scrollingElement || scroller === document.documentElement)
+      ? scroller.scrollTop : window.scrollY;
+    const delta = input.targetY - startY;
+    const start = performance.now();
 
-    return {
-      requested_target: input.targetY,
-      before, after,
-      maxScroll: document.documentElement?.scrollHeight,
-      innerHeight: window.innerHeight,
-    };
-  }, { fromY, targetY });
-  void diag;
-  // Brief dwell to let the page settle the snap before next atom starts.
-  await page.waitForTimeout(Math.max(80, Math.round(durationMs * 0.3)));
+    return new Promise((resolve) => {
+      function tick(now) {
+        const elapsed = now - start;
+        const t = Math.min(1, elapsed / input.durationMs);
+        const y = startY + delta * ease(t);
+        try {
+          if (scroller === window) window.scrollTo(0, y);
+          else { scroller.scrollTop = y; }
+        } catch { /* ignore */ }
+        if (t < 1) {
+          requestAnimationFrame(tick);
+        } else {
+          // Final snap to exact target (in case of sub-pixel drift).
+          try {
+            if (scroller === window) window.scrollTo(0, input.targetY);
+            else { scroller.scrollTop = input.targetY; }
+          } catch { /* ignore */ }
+          resolve();
+        }
+      }
+      requestAnimationFrame(tick);
+    });
+  }, { fromY, targetY, durationMs, curve });
+  // Tiny settle so the next atom sees the scroll committed.
+  await page.waitForTimeout(50);
 }
 
 // ── atomHold ─────────────────────────────────────────────────────────────────

package/src/tools/plan-video-segments.js

@@ -94,79 +94,52 @@ function assertNoV5Fields(seg, index) {
   }
 }
 
-// Reading-flow lint — reject the "jump + long hold" anti-pattern that makes
-// recordings feel like a slideshow of screenshots instead of a person
-// scrolling through a page and pausing at key spots to explain. This is what
-// the user repeatedly asked for ("从上往下滑动着介绍，到重点处停一下"). The
-// V6 atom toolkit is fully capable of producing reading-flow output; the
-// problem is that agents default to short-scroll + long-hold without an
-// explicit constraint, so we enforce it here.
+// Transition-mode lint — enforce the "explain block → smooth transition → explain block"
+// pattern the user described:
+//   "先说一句话, 然后再往下滑, 介绍内容 1, 再往下滑, 停住介绍内容 2"
 //
-// Rules:
-//   - Each segment (except the opening hook, segment 0) MUST contain at least
-//     one scroll_to with duration_ms >= 1500ms — the "slow scroll while
-//     narrating" beat.
-//   - Any hold with duration_ms > 2000ms MUST be immediately preceded by a
-//     scroll_to with duration_ms >= 1500ms — long holds are only legal as
-//     "I just slowly scrolled to a key spot, now I'm pausing on it".
-const READING_FLOW_SLOW_SCROLL_MIN_MS = 1500;
-const READING_FLOW_LONG_HOLD_THRESHOLD_MS = 2000;
+// Key insight: scroll_to is a TRANSITION between content blocks, not a
+// narration vehicle. It can be short (~500-800ms) — speed doesn't matter,
+// only smoothness. Long narration happens during hold, not during scroll.
+//
+// Rule (single rule): every non-opening segment MUST start with a scroll_to.
+// This guarantees a visible transition from the previous segment's anchor
+// to the new content block. Without this, an agent can string back-to-back
+// hold-only segments and the viewer just sees jump cuts in audio with no
+// page movement.
+//
+// What's NOT enforced anymore:
+//   - scroll_to duration_ms is not bounded — short transitions (500ms) and
+//     longer ones (2s+) are both fine. Smoothness comes from atomScrollTo's
+//     RAF-based programmatic implementation, not from duration.
+//   - hold duration_ms is not bounded — long holds (3-5s) are the normal
+//     case (this is where the agent narrates the current block).
 
 function validateReadingFlow(operations, segmentIndex) {
-  // Opening hook segment may legitimately be a fully static hero shot
-  // with no scroll (e.g. "校招，实习岗位更新，速投" over a poster).
+  // Opening hook segment is exempt — first segment may legitimately be
+  // a fully static hero shot (e.g. "校招，实习岗位更新，速投" over a poster).
   if (segmentIndex === 0) return;
 
   const ops = Array.isArray(operations) ? operations : [];
   if (ops.length === 0) return;
 
-  const hasSlowScroll = ops.some(
-    op => op?.atom === 'scroll_to' && Number(op.duration_ms) >= READING_FLOW_SLOW_SCROLL_MIN_MS,
-  );
-  if (!hasSlowScroll) {
+  // The first op of a non-opening segment must be a scroll_to (the
+  // transition into this block's content). All-hold segments produce
+  // back-to-back jump cuts with no visible page movement, which the user
+  // has explicitly rejected.
+  const first = ops[0];
+  if (first?.atom !== 'scroll_to') {
     const err = new Error(
-      `reading_flow_violation: segments[${segmentIndex}] has no slow scroll. `
-      + `Reading-flow mode requires at least one scroll_to with duration_ms >= ${READING_FLOW_SLOW_SCROLL_MIN_MS}ms `
-      + 'per non-opening segment — this simulates a finger sliding through the page '
-      + 'while narration plays, instead of jumping cut-style to a position. '
-      + 'Fix: replace any "short scroll_to(duration_ms<1000) + long hold(>2000)" pair '
-      + `with one "slow scroll_to(duration_ms=2000~3500)" + "short hold(duration_ms=800~1500)".`,
+      `transition_required: segments[${segmentIndex}] must start with a scroll_to atom — `
+      + 'this is the smooth transition from the previous block to this one. '
+      + `Got first atom "${first?.atom ?? 'none'}". All-hold segments produce jump cuts. `
+      + 'Fix: prepend a scroll_to(target_y=<new block top>, duration_ms=500~1000) before '
+      + 'the hold. The scroll can be short (~600ms is fine); what matters is that the '
+      + "page visibly slides — atomScrollTo's programmatic mode handles smoothness.",
     );
-    err.code = 'READING_FLOW_VIOLATION';
+    err.code = 'TRANSITION_REQUIRED';
     throw err;
   }
-
-  for (let i = 1; i < ops.length; i += 1) {
-    const op = ops[i];
-    if (op?.atom !== 'hold') continue;
-    const holdMs = Number(op.duration_ms);
-    if (!Number.isFinite(holdMs) || holdMs <= READING_FLOW_LONG_HOLD_THRESHOLD_MS) continue;
-
-    const prev = ops[i - 1];
-    if (prev?.atom !== 'scroll_to') {
-      const err = new Error(
-        `reading_flow_violation: segments[${segmentIndex}].operations[${i}] is a long hold `
-        + `(${holdMs}ms) but its preceding atom is "${prev?.atom ?? 'none'}", not scroll_to. `
-        + 'Long holds (>2000ms) must immediately follow a scroll_to — '
-        + 'the natural reading pattern is "slow scroll to a key spot → pause to explain".',
-      );
-      err.code = 'READING_FLOW_VIOLATION';
-      throw err;
-    }
-    const prevScrollMs = Number(prev.duration_ms);
-    if (!Number.isFinite(prevScrollMs) || prevScrollMs < READING_FLOW_SLOW_SCROLL_MIN_MS) {
-      const err = new Error(
-        `reading_flow_violation: segments[${segmentIndex}].operations[${i}] is a long hold `
-        + `(${holdMs}ms) following a fast scroll_to (${prevScrollMs}ms). This is the "跳页+长停" `
-        + 'anti-pattern — viewers see a hard cut to a new position then a frozen frame. '
-        + `Fix: extend the preceding scroll_to to duration_ms >= ${READING_FLOW_SLOW_SCROLL_MIN_MS}ms `
-        + '(narrate WHILE you scroll), and shorten this hold to duration_ms <= 1500ms '
-        + '(brief pause to stress the key point, then move on).',
-      );
-      err.code = 'READING_FLOW_VIOLATION';
-      throw err;
-    }
-  }
 }
 
 // Process operations[]: expand "fill" on the last hold, validate atom shape.