@lightcone-ai/daemon 0.23.4 → 0.23.5

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

@@ -257,13 +257,39 @@ server.tool(
       }).optional().describe('Optional presentation hints (style only). duration/per_card_duration are computed.'),
       operations: z.array(z.object({
         atom: z.enum(['scroll_to', 'hold', 'cursor_focus']),
-        duration_ms: z.union([z.number(), z.literal('fill')]).describe('Atom duration. "fill" allowed only on the LAST hold to auto-fill remaining audio time.'),
+        duration_ms: z.union([z.number(), z.literal('fill')]).describe('Atom duration in ms. "fill" allowed only on the LAST hold to auto-fill remaining audio time.'),
         y: z.number().optional(),
         x: z.number().optional(),
         curve: z.enum(['easeInOutQuad', 'linear', 'easeOutQuad']).optional(),
         mode: z.enum(['auto', 'touch', 'programmatic']).optional(),
         jitter_px: z.number().optional(),
-      })).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.'),
+      })).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. '
+        + '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'
+        + '  [\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'
+        + '  ]\n\n'
+        + 'BAD example (will be REJECTED by reading_flow_violation):\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'
+        + '  ]',
+      ),
     })).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.'),
   },
   async ({ segments }) => {

package/package.json

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

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

@@ -94,6 +94,81 @@ 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.
+//
+// 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;
+
+function validateReadingFlow(operations, segmentIndex) {
+  // Opening hook segment may legitimately be a fully static hero shot
+  // with no scroll (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) {
+    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)".`,
+    );
+    err.code = 'READING_FLOW_VIOLATION';
+    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.
 function processOperations(operations, audioDurationMs, segmentIndex) {
   if (!Array.isArray(operations) || operations.length === 0) {
@@ -165,6 +240,7 @@ function processOperations(operations, audioDurationMs, segmentIndex) {
     }
     sum += n;
   }
+  validateReadingFlow(expanded, segmentIndex);
   return { operations: expanded, durationSumMs: Math.round(sum) };
 }