vidspotai-shared 1.0.82 → 1.0.84

package/lib/services/agent/editExisting/highlightPicker.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTranscriptLines = buildTranscriptLines;
+exports.pickHighlightsCore = pickHighlightsCore;
+const zod_1 = require("zod");
+const logger_1 = require("../../../utils/logger");
+const modelRouter_1 = require("../modelRouter");
+const editExisting_schema_1 = require("./editExisting.schema");
+const editAssembler_1 = require("./editAssembler");
+/**
+ * The raw LLM output. Intentionally looser than HighlightSegmentSchema (no
+ * refine / strict) — we do our own bounds-checking + clamping afterwards so a
+ * slightly-off model answer is repaired rather than rejected outright.
+ */
+const LlmSelectionSchema = zod_1.z.object({
+    segments: zod_1.z
+        .array(zod_1.z.object({
+        startMs: zod_1.z.number(),
+        endMs: zod_1.z.number(),
+        reason: zod_1.z.string(),
+        label: zod_1.z.string().optional(),
+    }))
+        .min(1),
+    summary: zod_1.z.string().optional(),
+});
+const GOAL_GUIDANCE = {
+    highlights: "Keep only the genuinely strongest, most engaging moments. Prefer complete thoughts over fragments; drop filler, tangents, and dead air.",
+    "podcast-clips": "Select self-contained, quotable segments that would each stand alone as a social clip. Each segment should open and close on a complete thought (no mid-sentence cuts).",
+    "vlog-reedit": "Preserve the narrative flow start-to-end, but tighten it: cut filler words, long pauses, retakes, and rambling. The result should still feel like a coherent through-line, not disconnected clips.",
+    "interview-highlights": "Select the strongest question→answer exchanges. Keep enough of the question for context, then the meat of the answer. Use the speaker labels to avoid cutting mid-exchange.",
+};
+function fmtTs(ms) {
+    const totalSec = Math.floor(ms / 1000);
+    const m = Math.floor(totalSec / 60);
+    const s = totalSec % 60;
+    const frac = Math.floor(ms % 1000);
+    return `${m}:${String(s).padStart(2, "0")}.${String(frac).padStart(3, "0")}`;
+}
+/**
+ * Render the transcript as timestamped lines the model can quote start/end
+ * from. Prefers utterances (speaker-aware, naturally chunked); falls back to
+ * grouping words into ~sentence lines by punctuation so the model still gets
+ * tight, pickable boundaries with real timestamps.
+ */
+function buildTranscriptLines(transcript) {
+    if (transcript.utterances && transcript.utterances.length > 0) {
+        return transcript.utterances
+            .map((u) => `[${fmtTs(u.start)} → ${fmtTs(u.end)}] (${u.speaker}) ${u.text.trim()}`)
+            .join("\n");
+    }
+    const words = transcript.words ?? [];
+    if (words.length === 0) {
+        // No timing at all — give the model the text + total duration and let it
+        // approximate. Rare (ASR always returns words on success).
+        return `[0:00.000 → ${fmtTs(transcript.audioDurationMs)}] ${transcript.fullText}`;
+    }
+    // Group words into lines, breaking on sentence-final punctuation OR every
+    // ~25 words so no single line is unboundedly long.
+    const lines = [];
+    let bucket = [];
+    const flush = () => {
+        if (bucket.length === 0)
+            return;
+        const start = bucket[0].start;
+        const end = bucket[bucket.length - 1].end;
+        const text = bucket.map((w) => w.text).join(" ").replace(/\s+([.,!?;:])/g, "$1");
+        lines.push(`[${fmtTs(start)} → ${fmtTs(end)}] ${text}`);
+        bucket = [];
+    };
+    for (const w of words) {
+        bucket.push(w);
+        if (/[.!?]$/.test(w.text) || bucket.length >= 25)
+            flush();
+    }
+    flush();
+    return lines.join("\n");
+}
+function buildMessages(request, transcript, feedback) {
+    const diarized = (0, editExisting_schema_1.editGoalUsesDiarization)(request.editGoal);
+    const targetLine = request.targetDurationSec
+        ? `Aim for a total kept duration close to ${Math.round(request.targetDurationSec)}s (within ~15%). Do not pad with weak material to hit it; under-shooting is fine if there isn't enough strong content.`
+        : "There is no fixed target length — keep everything that is genuinely strong and cut the rest.";
+    const maxClipsLine = request.maxClips
+        ? `Return at most ${request.maxClips} segments.`
+        : "Return as many segments as the content justifies (typically 3–15).";
+    const system = [
+        "You are an expert video editor. You are given a timestamped transcript of a",
+        "source video and must choose which spans to KEEP for a re-edit. Output only",
+        "spans that exist in the transcript, using millisecond start/end times taken",
+        "from the bracketed timestamps.",
+        "",
+        "Rules:",
+        "- startMs/endMs are milliseconds from the start of the video.",
+        "- Segments must NOT overlap and should be in chronological order.",
+        "- Cut on natural boundaries (sentence/thought starts and ends), never mid-word.",
+        `- Every segment must lie within [0, ${transcript.audioDurationMs}] ms.`,
+        diarized
+            ? "- Speaker labels are provided; keep complete exchanges and don't cut between a question and its answer."
+            : "",
+        "- Give a concise `reason` for each kept segment.",
+    ]
+        .filter(Boolean)
+        .join("\n");
+    const user = [
+        `EDIT GOAL: ${request.editGoal}`,
+        GOAL_GUIDANCE[request.editGoal],
+        "",
+        targetLine,
+        maxClipsLine,
+        request.instructions ? `\nADDITIONAL INSTRUCTIONS: ${request.instructions}` : "",
+        feedback ? `\nYOUR PREVIOUS ANSWER HAD PROBLEMS — FIX THESE:\n${feedback}` : "",
+        "",
+        `TRANSCRIPT (total ${fmtTs(transcript.audioDurationMs)}):`,
+        buildTranscriptLines(transcript),
+    ]
+        .filter(Boolean)
+        .join("\n");
+    return [
+        { role: "system", content: system },
+        { role: "user", content: user },
+    ];
+}
+/**
+ * Validate + repair a raw LLM selection against the transcript bounds and the
+ * request constraints. Returns the cleaned segments and any human-readable
+ * problems (used as retry feedback). Clamping/ordering/overlap-removal happens
+ * in clampSegments; here we additionally enforce maxClips and surface when the
+ * model returned nothing usable.
+ */
+function validateSelection(raw, request, audioDurationMs) {
+    const problems = [];
+    const mapped = raw.segments.map((s) => ({
+        startMs: s.startMs,
+        endMs: s.endMs,
+        reason: (s.reason ?? "").slice(0, 500),
+        ...(s.label ? { label: s.label.slice(0, 120) } : {}),
+    }));
+    const outOfBounds = mapped.filter((s) => s.startMs < 0 || s.endMs > audioDurationMs + 250 || s.endMs <= s.startMs);
+    if (outOfBounds.length > 0) {
+        problems.push(`${outOfBounds.length} segment(s) were out of bounds or had endMs ≤ startMs (video is ${audioDurationMs}ms). Keep every segment inside [0, ${audioDurationMs}] with endMs > startMs.`);
+    }
+    // clampSegments drops invalid spans, clamps to bounds, sorts, removes overlaps.
+    let cleaned = (0, editAssembler_1.clampSegments)(mapped, audioDurationMs);
+    if (request.maxClips && cleaned.length > request.maxClips) {
+        problems.push(`You returned ${cleaned.length} segments but the cap is ${request.maxClips}; keeping the first ${request.maxClips}.`);
+        cleaned = cleaned.slice(0, request.maxClips);
+    }
+    return { segments: cleaned, problems };
+}
+/**
+ * Pick highlight segments from a transcript. Retries up to `maxRetries` times,
+ * feeding the model its previous problems. Throws only if every attempt yields
+ * zero usable segments.
+ */
+async function pickHighlightsCore(llm, args) {
+    const router = new modelRouter_1.ModelRouter();
+    const maxRetries = args.maxRetries ?? 2;
+    const { request, transcript } = args;
+    let feedback;
+    let lastProblems = [];
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        const res = await llm.structured({
+            model: router.pickFor("planner"),
+            fallbackModel: router.fallbackFor("planner"),
+            schema: LlmSelectionSchema,
+            schemaName: "HighlightSelection",
+            messages: buildMessages(request, transcript, feedback),
+            temperature: 0.3,
+            maxTokens: 8000,
+        });
+        const { segments, problems } = validateSelection(res.data, request, transcript.audioDurationMs);
+        lastProblems = problems;
+        if (segments.length > 0 && problems.length === 0) {
+            logger_1.logger.info("editExisting.picker: selection accepted", {
+                attempt,
+                segments: segments.length,
+                keptMs: (0, editAssembler_1.totalSegmentMs)(segments),
+                audioDurationMs: transcript.audioDurationMs,
+            });
+            return { segments, ...(res.data.summary ? { summary: res.data.summary } : {}) };
+        }
+        // Usable-but-imperfect (e.g. trimmed to maxClips) on the final attempt:
+        // accept rather than throw — a slightly-clamped cut beats failing the job.
+        if (segments.length > 0 && attempt === maxRetries) {
+            logger_1.logger.warn("editExisting.picker: accepting clamped selection on last attempt", {
+                segments: segments.length,
+                problems,
+            });
+            return { segments, ...(res.data.summary ? { summary: res.data.summary } : {}) };
+        }
+        feedback = problems.join("\n") || "Your previous answer returned no usable segments. Select at least one strong span with valid timestamps.";
+        logger_1.logger.warn("editExisting.picker: retrying", {
+            attempt,
+            problems,
+            durationMs: transcript.audioDurationMs,
+        });
+    }
+    throw new Error(`editExisting.picker: no usable highlight segments after ${maxRetries + 1} attempts (${lastProblems.join("; ")})`);
+}

package/lib/services/agent/editExisting/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./editExisting.schema";
+export * from "./editAssembler";
+export * from "./highlightPicker";
+//# sourceMappingURL=index.d.ts.map

package/lib/services/agent/editExisting/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/editExisting/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC"}

package/lib/services/agent/editExisting/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./editExisting.schema"), exports);
+__exportStar(require("./editAssembler"), exports);
+__exportStar(require("./highlightPicker"), exports);

package/lib/services/agent/eval/seedBriefs.d.ts

@@ -1,8 +1,9 @@
 import { EvalBrief } from "./types";
 /**
- * Eval set — 50 hand-curated briefs covering the 5 launch personas plus
- * adjacent niches that should route to the closest persona (e.g. recipe →
- * faceless-yt, real-estate → product-demo).
+ * Eval set — 50 short-form briefs covering the 5 launch personas plus adjacent
+ * niches that should route to the closest persona (e.g. recipe → faceless-yt,
+ * real-estate → product-demo), then 10 long-form briefs (Stream L, L-7)
+ * exercising the M1/L1/L2 length-tier planner branches. 60 total.
  *
  * Use these to:
  *   1. Catch routing regressions (router persona !== expected niche).

package/lib/services/agent/eval/seedBriefs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seedBriefs.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/eval/seedBriefs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,EA4pCvC,CAAC"}
+{"version":3,"file":"seedBriefs.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/eval/seedBriefs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,EAu7CvC,CAAC"}

package/lib/services/agent/eval/seedBriefs.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SEED_EVAL_BRIEFS = void 0;
 /**
- * Eval set — 50 hand-curated briefs covering the 5 launch personas plus
- * adjacent niches that should route to the closest persona (e.g. recipe →
- * faceless-yt, real-estate → product-demo).
+ * Eval set — 50 short-form briefs covering the 5 launch personas plus adjacent
+ * niches that should route to the closest persona (e.g. recipe → faceless-yt,
+ * real-estate → product-demo), then 10 long-form briefs (Stream L, L-7)
+ * exercising the M1/L1/L2 length-tier planner branches. 60 total.
  *
  * Use these to:
  *   1. Catch routing regressions (router persona !== expected niche).
@@ -1185,4 +1186,283 @@ exports.SEED_EVAL_BRIEFS = [
             confidence: { goal: 0.9 },
         },
     },
+    // ───────────────────── long-form (Stream L, L-7) ─────────────────────
+    // 10 briefs that exercise the length-tier planner branches (L-2) and the
+    // script-first authoring pipeline (L-3). All route to `faceless-yt` (the
+    // long-form persona) so the router check stays clean and the signal here is
+    // the PLANNER path, not routing — routing is already covered by the 50 above.
+    //
+    // Tier coverage: M1 (60s–3min, medium branch — single planner call,
+    // chapters SHOULD) ×4, L1 (3–10min, script-first — chapters MUST, 3–8s scene
+    // band, cheaper body tiers) ×4, L2 (10–60min, script-first + L-6 cost cap) ×2.
+    //
+    // L2 briefs deliberately sit at the 10-min floor and carry a `maxSpendUSD`
+    // cap: a 10-min script explodes into ~100+ scenes, so each L2 run is the most
+    // expensive in the set (script + outline + one match_broll per chapter, then
+    // a critic/judge pass over a large Project). Don't push these durations up
+    // without a reason.
+    //
+    // L3 (edit-existing) is intentionally absent: it is NOT planner-driven — it
+    // needs the /v1/agent/edit-existing pipeline (L-5), which doesn't exist yet.
+    // Per the file header rule ("add briefs alongside the change that needs
+    // them"), L3 eval briefs land WITH L-5, not here — running them through
+    // Planner.plan() today would produce a meaningless scene-first plan.
+    // ── M1 (60s–3min explainers / how-tos) ──
+    {
+        id: "seed-longform-m1-history",
+        niche: "faceless-yt",
+        goodOutputNotes: [
+            "M1 (~2min). Mixed pacing — a hooky 8s open, then steady explanatory beats.",
+            "16:9, mostly T0 stock/stills + Ken-Burns; this is a faceless explainer, not a generation showcase.",
+            "Chapters SHOULD be present and, if present, must partition every scene exactly (contiguous CH_<n> sceneIndices).",
+            "Coherent single through-line across the whole runtime — no per-scene topic drift.",
+        ].join(" "),
+        brief: {
+            goal: "Explain how the printing press reshaped Europe in two minutes",
+            audience: "Curious general audience",
+            niche: "faceless-yt",
+            tone: "informational",
+            durationSec: 120,
+            aspect: "16:9",
+            lengthTier: "M1",
+            hookStyle: "bold-claim",
+            pacing: "medium",
+            tierBudget: "T0",
+            rawPrompt: "2-minute faceless explainer on how the printing press reshaped Europe",
+            claims: { allow: [], block: [] },
+            references: [],
+            confidence: { goal: 0.9, audience: 0.8 },
+        },
+    },
+    {
+        id: "seed-longform-m1-howto",
+        niche: "faceless-yt",
+        goodOutputNotes: [
+            "M1 (~90s) how-to. Sequenced steps; each step gets its own scene + on-screen label.",
+            "16:9, T0/T1. Mixed pacing — slower on the technical steps, brisk transitions between.",
+            "Chapters SHOULD map to the steps; if present they must cover all scenes with no gaps/overlaps.",
+        ].join(" "),
+        brief: {
+            goal: "Teach how to brew pour-over coffee in 90 seconds",
+            audience: "Home coffee beginners",
+            niche: "faceless-yt",
+            tone: "casual",
+            durationSec: 90,
+            aspect: "16:9",
+            lengthTier: "M1",
+            hookStyle: "question",
+            pacing: "medium",
+            tierBudget: "T0",
+            rawPrompt: "90-second faceless how-to on brewing pour-over coffee, step by step",
+            claims: { allow: [], block: [] },
+            references: [],
+            confidence: { goal: 0.95 },
+        },
+    },
+    {
+        id: "seed-longform-m1-science",
+        niche: "faceless-yt",
+        goodOutputNotes: [
+            "M1 (~2.5min) science explainer. Diagram-led stills, calm informative pace.",
+            "16:9, mostly T0. Avoid declarative claims that aren't well-established; hedge appropriately.",
+            "One coherent argument built across the runtime; chapters SHOULD reflect the sub-points.",
+        ].join(" "),
+        brief: {
+            goal: "Explain why we still don't have a cure for the common cold",
+            audience: "Science-curious adults",
+            niche: "faceless-yt",
+            tone: "informational",
+            durationSec: 150,
+            aspect: "16:9",
+            lengthTier: "M1",
+            hookStyle: "question",
+            pacing: "medium",
+            tierBudget: "T0",
+            rawPrompt: "2.5-minute faceless explainer on why there's no cure for the common cold",
+            claims: { allow: [], block: ["cures", "guaranteed prevention"] },
+            references: [],
+            confidence: { goal: 0.9 },
+        },
+    },
+    {
+        id: "seed-longform-m1-tech",
+        niche: "faceless-yt",
+        goodOutputNotes: [
+            "M1 (3min) tech explainer. Plain-English, diagram stills + Ken-Burns.",
+            "16:9, T0/T1. No hype/anthropomorphic claims.",
+            "Chapters SHOULD partition the scenes; a clear intro → mechanism → implications arc.",
+        ].join(" "),
+        brief: {
+            goal: "Explain how end-to-end encryption keeps messages private",
+            audience: "Non-technical privacy-curious adults",
+            niche: "faceless-yt",
+            tone: "informational",
+            durationSec: 180,
+            aspect: "16:9",
+            lengthTier: "M1",
+            hookStyle: "question",
+            pacing: "medium",
+            tierBudget: "T1",
+            rawPrompt: "3-minute faceless explainer on how end-to-end encryption works",
+            claims: { allow: [], block: ["unhackable", "100% secure"] },
+            references: [],
+            confidence: { goal: 0.9 },
+        },
+    },
+    // ── L1 (3–10min YouTube essays, script-first) ──
+    {
+        id: "seed-longform-l1-essay-finance",
+        niche: "faceless-yt",
+        goodOutputNotes: [
+            "L1 (~4min) video essay. MUST have a coherent full-script through-line — the narration reads as one continuous argument, not stitched fragments.",
+            "Chapters are REQUIRED and must partition every scene exactly (contiguous CH_<n> sceneIndices, ascending, no gaps/overlaps).",
+            "Per-scene B-roll in the 3–8s band; voiceoverLines are verbatim slices of the script.",
+            "16:9. Cost discipline: only the intro/hero scene at the budget tier, body scenes at the cheaper default — not every scene at T1+.",
+        ].join(" "),
+        brief: {
+            goal: "Make the case that compounding is the most underrated force in personal finance",
+            audience: "Beginner-to-intermediate retail investors",
+            niche: "faceless-yt",
+            tone: "informational",
+            durationSec: 240,
+            aspect: "16:9",
+            lengthTier: "L1",
+            hookStyle: "bold-claim",
+            pacing: "medium",
+            tierBudget: "T1",
+            rawPrompt: "4-minute faceless YouTube video essay arguing compounding is the most underrated force in personal finance",
+            claims: { allow: [], block: ["guaranteed returns", "financial advice"] },
+            references: [],
+            confidence: { goal: 0.95, audience: 0.8 },
+        },
+    },
+    {
+        id: "seed-longform-l1-essay-history",
+        niche: "faceless-yt",
+        goodOutputNotes: [
+            "L1 (~5min) historical essay. Single narrative arc with a setup → turning point → consequence structure carried by the script.",
+            "Chapters REQUIRED, exact scene partition. 3–8s scenes, period-appropriate stills + map/Ken-Burns motion.",
+            "16:9, cinematic-but-informative. Body scenes default to the cheaper tier; intro may use the budget tier.",
+        ].join(" "),
+        brief: {
+            goal: "Tell the full story of how the Library of Alexandria was lost",
+            audience: "History enthusiasts, general public",
+            niche: "faceless-yt",
+            tone: "cinematic",
+            durationSec: 300,
+            aspect: "16:9",
+            lengthTier: "L1",
+            hookStyle: "story",
+            pacing: "medium",
+            tierBudget: "T1",
+            rawPrompt: "5-minute faceless YouTube essay on how the Library of Alexandria was lost",
+            claims: { allow: [], block: [] },
+            references: [],
+            confidence: { goal: 0.95 },
+        },
+    },
+    {
+        id: "seed-longform-l1-essay-tech",
+        niche: "faceless-yt",
+        goodOutputNotes: [
+            "L1 (~7min) explainer essay. The script should build understanding progressively; later chapters reference earlier ideas.",
+            "Chapters REQUIRED + exact partition. 3–8s diagram-led scenes. Captions burned in.",
+            "16:9, T0/T1 only — a 7-min video at high tiers blows the budget; expect mostly cheap body scenes.",
+        ].join(" "),
+        brief: {
+            goal: "Explain how the internet actually routes a request from your phone to a server and back",
+            audience: "Curious non-engineers",
+            niche: "faceless-yt",
+            tone: "informational",
+            durationSec: 420,
+            aspect: "16:9",
+            lengthTier: "L1",
+            hookStyle: "question",
+            pacing: "medium",
+            tierBudget: "T1",
+            maxSpendUSD: 4,
+            rawPrompt: "7-minute faceless YouTube explainer essay on how the internet routes a request end to end",
+            claims: { allow: [], block: [] },
+            references: [],
+            confidence: { goal: 0.9 },
+        },
+    },
+    {
+        id: "seed-longform-l1-essay-science",
+        niche: "faceless-yt",
+        goodOutputNotes: [
+            "L1 (~8min) science essay near the L1 ceiling. Coherent argument; chapters REQUIRED and partition all scenes.",
+            "3–8s scenes, diagram/stock-led. 16:9. With a tight maxSpendUSD the planner must lean on cheap tiers (mostly T0) and may downgrade — the plan must still respect the cap.",
+        ].join(" "),
+        brief: {
+            goal: "Explain why time appears to slow down near a black hole",
+            audience: "Science-curious teens and adults",
+            niche: "faceless-yt",
+            tone: "cinematic",
+            durationSec: 480,
+            aspect: "16:9",
+            lengthTier: "L1",
+            hookStyle: "bold-claim",
+            pacing: "medium",
+            tierBudget: "T1",
+            maxSpendUSD: 3,
+            rawPrompt: "8-minute faceless YouTube science essay on why time slows down near a black hole",
+            claims: { allow: [], block: [] },
+            references: [],
+            confidence: { goal: 0.9 },
+        },
+    },
+    // ── L2 (10–60min full uploads, script-first + L-6 cost guardrails) ──
+    // Held at the 10-min floor with a hard cap — these are the most expensive
+    // briefs in the set (see section header).
+    {
+        id: "seed-longform-l2-deepdive-history",
+        niche: "faceless-yt",
+        goodOutputNotes: [
+            "L2 (~10min) deep-dive at the L2 floor. Script-first: one long coherent narration, chapters REQUIRED and partitioning ~100+ scenes exactly.",
+            "3–8s scenes. 16:9. L-6 cost guardrail is the key check: with maxSpendUSD set, the planner must keep the plan under the cap — overwhelmingly T0 body scenes, downgrading if needed; the final plan must NOT exceed the cap.",
+        ].join(" "),
+        brief: {
+            goal: "A 10-minute deep dive into how the Roman Empire actually fell",
+            audience: "History documentary viewers",
+            niche: "faceless-yt",
+            tone: "cinematic",
+            durationSec: 600,
+            aspect: "16:9",
+            lengthTier: "L2",
+            hookStyle: "story",
+            pacing: "medium",
+            tierBudget: "T1",
+            maxSpendUSD: 6,
+            rawPrompt: "10-minute faceless YouTube deep dive on how the Roman Empire fell",
+            claims: { allow: [], block: [] },
+            references: [],
+            confidence: { goal: 0.95 },
+        },
+    },
+    {
+        id: "seed-longform-l2-deepdive-tech",
+        niche: "faceless-yt",
+        goodOutputNotes: [
+            "L2 (~10min) explainer deep-dive. Progressive script; chapters REQUIRED, exact partition of all scenes.",
+            "3–8s diagram-led scenes, captions burned in. 16:9. Cost cap is the headline check — a tight maxSpendUSD should force a near-all-T0 plan; the plan must stay within budget (downgrade rather than overspend).",
+        ].join(" "),
+        brief: {
+            goal: "A 10-minute deep dive into how modern GPS pinpoints your location",
+            audience: "Curious non-engineers",
+            niche: "faceless-yt",
+            tone: "informational",
+            durationSec: 600,
+            aspect: "16:9",
+            lengthTier: "L2",
+            hookStyle: "question",
+            pacing: "medium",
+            tierBudget: "T1",
+            maxSpendUSD: 5,
+            rawPrompt: "10-minute faceless YouTube deep dive on how GPS works",
+            claims: { allow: [], block: [] },
+            references: [],
+            confidence: { goal: 0.9 },
+        },
+    },
 ];

package/lib/services/agent/eval/types.d.ts

@@ -75,6 +75,14 @@ export declare const EvalBriefSchema: z.ZodObject<{
             "4:5": "4:5";
             "16:9": "16:9";
         }>>;
+        lengthTier: z.ZodOptional<z.ZodEnum<{
+            S1: "S1";
+            S2: "S2";
+            M1: "M1";
+            L1: "L1";
+            L2: "L2";
+            L3: "L3";
+        }>>;
         voice: z.ZodOptional<z.ZodObject<{
             gender: z.ZodOptional<z.ZodEnum<{
                 male: "male";
@@ -134,12 +142,14 @@ export declare const EvalBriefSchema: z.ZodObject<{
                 transcriptExcerpt: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
         }, z.core.$strip>>>;
+        preferredModelKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
         tierBudget: z.ZodDefault<z.ZodEnum<{
             T0: "T0";
             T1: "T1";
             T2: "T2";
             T3: "T3";
         }>>;
+        maxSpendUSD: z.ZodOptional<z.ZodNumber>;
         videoStrategy: z.ZodOptional<z.ZodEnum<{
             auto: "auto";
             direct: "direct";

package/lib/services/agent/eval/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/eval/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;GAUG;AAEH,4CAA4C;AAC5C,eAAO,MAAM,gBAAgB;;;;;;;iBAQ3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAY9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;iBAQ1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/eval/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;GAUG;AAEH,4CAA4C;AAC5C,eAAO,MAAM,gBAAgB;;;;;;;iBAQ3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAY9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;iBAQ1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/lib/services/agent/executor/core.d.ts

@@ -0,0 +1,70 @@
+import { VideoPlan } from "../../../schemas/videoPlan.schema";
+import { ToolContext } from "../toolRegistry";
+import { ExecutorOptions, SceneOutcome } from "./types";
+/**
+ * Executor — turns an approved VideoPlan into per-scene asset results.
+ *
+ * Plan-then-execute split (not free-form ReAct): the executor does NOT pick
+ * tools. The plan dictates which tool runs per scene; the executor only does
+ * the dispatch + per-scene parallelism + idempotency-key generation.
+ *
+ * Returns a SceneOutcome per scene, leaving composition (compose_scene),
+ * critique (Critic.review), and render to the orchestrator above. The
+ * per-scene VISUAL strategy switch lives in ./visual (runVisual); the voice
+ * resolution helpers in ./voice; the public types in ./types.
+ */
+export declare class Executor {
+    private readonly concurrency;
+    private readonly runTool;
+    private readonly onSceneComplete?;
+    private readonly taskCache?;
+    private readonly onTaskMint?;
+    private readonly frozenVisualScenes?;
+    private readonly frozenVoiceoverScenes?;
+    /**
+     * AG-11b: per-run registry of each scene's generated identity still image,
+     * keyed by sceneIndex. One deferred per scene, created in run() before the
+     * worker pool starts. A scene that produces an identity image (image-* and
+     * the i2v first frame) resolves its own entry as soon as the image lands; a
+     * dependent scene (scene.characterAnchorSceneIndex set) awaits its anchor's
+     * entry and threads the URL in as an inputImage for image-to-image identity
+     * transfer. Every entry is settled (→ undefined if no image) when the scene
+     * completes, so a dependent never hangs on a stock/t2v/avatar/failed anchor.
+     *
+     * Deadlock-free: anchors point to EARLIER scenes (first appearance) and the
+     * queue is pulled in sceneIndex order, so a dependent's anchor is always
+     * already in-flight or done by the time the dependent is picked up.
+     */
+    private identityImages?;
+    constructor(opts?: ExecutorOptions);
+    /**
+     * AG-11b: publish a scene's generated identity image so dependent scenes can
+     * anchor off it. Idempotent — first call wins (the still image is produced
+     * once per scene). No-op when the registry isn't initialised (e.g. runVisual
+     * driven outside run(), such as single-scene regen).
+     */
+    private publishIdentityImage;
+    /**
+     * AG-11b: resolve the generated identity image of this scene's character
+     * anchor, or undefined when there's no anchor / no registry / the anchor
+     * produced no usable still (stock, pure t2v, avatar, or a failed scene).
+     * Self-references are ignored.
+     */
+    private resolveAnchorIdentityImage;
+    /**
+     * Stage 7 slice 1 helper. Returns cached pending-task output if the
+     * upstream input hash matches and entry is within TTL; null otherwise.
+     * Logs the hit so trace shows where $$ was saved.
+     */
+    private checkTaskCache;
+    /**
+     * Best-effort mint. Swallows callback errors — a Firestore blip must not
+     * fail the scene (the tool already succeeded and produced a real taskId).
+     */
+    private mintTaskCache;
+    /** Bundle the bound helpers runVisual needs (see VisualDeps). */
+    private visualDeps;
+    run(plan: VideoPlan, ctx: ToolContext): Promise<SceneOutcome[]>;
+    private runScene;
+}
+//# sourceMappingURL=core.d.ts.map

package/lib/services/agent/executor/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/executor/core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAE5E,OAAO,EAA6B,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAczE,OAAO,EAAE,eAAe,EAAa,YAAY,EAAE,MAAM,SAAS,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAY;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAqC;IACtE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAoB;IAC/C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAgC;IAC5D,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAsB;IAC1D,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAsB;IAE7D;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,cAAc,CAAC,CAGrB;gBAEU,IAAI,GAAE,eAAoB;IAUtC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;;;;OAKG;YACW,0BAA0B;IAiBxC;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAmBtB;;;OAGG;YACW,aAAa;IAe3B,iEAAiE;IACjE,OAAO,CAAC,UAAU;IAcZ,GAAG,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YAiDvD,QAAQ;CA+GvB"}