vidspotai-shared 1.0.67 → 1.0.69-dev.0

package/lib/services/agent/costPreflight.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateSceneCredits = estimateSceneCredits;
+exports.estimatePlanOverheadCredits = estimatePlanOverheadCredits;
+exports.estimateProjectCost = estimateProjectCost;
+exports.estimatePlanCost = estimatePlanCost;
+/**
+ * Cost preflight — sums credits over a Project JSON's clips by their
+ * provenance.creditsSpent. For clips not yet generated, falls back to a
+ * conservative tier estimate so the user sees an upper bound BEFORE
+ * committing spend.
+ *
+ * Used by:
+ *  - the `estimate_cost` agent tool (offered to the planner so it can
+ *    stay within tierBudget),
+ *  - the /v1/agent/cost preview endpoint (storyboard preview before render).
+ */
+const TIER_FALLBACK_PER_SECOND = {
+    T0: 0.5,
+    T1: 2,
+    T2: 6,
+    T3: 14,
+};
+/**
+ * TTS cost per voiceover character, in credits (1 credit = $0.10). ElevenLabs
+ * Multilingual v2 lists ~$0.30 per 1K chars at the Creator tier; 0.003
+ * credits/char tracks that within rounding. Folded into `estimateSceneCredits`
+ * so the plan-side charge and the worker's per-scene `creditsActual` stamp
+ * stay symmetric (the same fn is used on both sides — the LLM-emitted
+ * `scene.voiceoverLine` doesn't change between plan and execute, so
+ * reconciliation just works).
+ */
+const TTS_PER_CHAR_CREDITS = 0.003;
+/**
+ * Plan-overhead credit constants (1 credit = $0.10). Each value is a flat,
+ * rounded-up approximation of the corresponding API cost — we don't meter
+ * these per-call because the variance is tiny and the metering plumbing
+ * would dwarf the saving.
+ *
+ * Tuning notes:
+ *  - PLANNER_BASE: Claude Sonnet 4.6 structured call ~$0.05–0.08.
+ *  - PLANNER_THINKING: +4K extended-thinking budget on T3 ~$0.05–0.10.
+ *  - WEB_SEARCH: bounded by `maxUses: 5` × $10/1K = $0.05 max.
+ *  - BIBLE_BUILD: BibleBuilder LLM call + Gemini image-vision pass ~$0.04.
+ *  - CRITIC: finalize-stage Critic call (Claude + thumbnail vision) ~$0.05–0.10.
+ */
+const PLANNER_BASE_CREDITS = 1;
+const PLANNER_THINKING_CREDITS = 1;
+const WEB_SEARCH_CREDITS = 1;
+const BIBLE_BUILD_CREDITS = 1;
+const CRITIC_CREDITS = 1;
+/**
+ * Per-scene credit estimate that matches `estimatePlanCost` exactly. Use
+ * this anywhere the worker needs to stamp `creditsActual` for a completed
+ * scene so the actual-side reconciliation stays symmetric with the
+ * plan-side charge. Without this helper, the worker would read
+ * `scene.estimatedCredits` directly — but the LLM frequently emits 0 (or
+ * omits the field) for T0 scenes, while `estimatePlanCost` substitutes
+ * the per-second tier curve for those, producing the classic
+ * "charged 19 cr / actual 0.42 cr → refund 18 cr" asymmetry on faceless
+ * personas where most scenes are T0.
+ *
+ * Also folds in TTS cost based on `voiceoverLine.length` — this was an
+ * un-billed leak before: ElevenLabs/OpenAI/MiniMax TTS are real $/char and
+ * the per-scene rollup never charged for them. Symmetric because the
+ * voiceover string is fixed at plan time.
+ */
+function estimateSceneCredits(scene) {
+    const base = scene.estimatedCredits !== undefined && scene.estimatedCredits > 0
+        ? scene.estimatedCredits
+        : (scene.durationMs / 1000) * TIER_FALLBACK_PER_SECOND[scene.tier];
+    const tts = (scene.voiceoverLine?.length ?? 0) * TTS_PER_CHAR_CREDITS;
+    return base + tts;
+}
+/**
+ * Plan-level overhead credits — the LLM/vision calls that happen around the
+ * scene generations themselves: the planner call, bible build (only on
+ * fresh builds, not cache hits), Anthropic web_search grounding (only when
+ * the planner actually invoked it), and the finalize-stage critic. These
+ * are flat per-plan rather than per-scene; the worker treats them as fully
+ * spent (no refund delta), so we don't have to track per-call actuals.
+ *
+ * Pass `bibleBuilt: false` for cache hits to skip the bible charge. Pass
+ * `usedWebResearch: false` when the planner ran the gateway path (no
+ * Anthropic web_search). `usedThinking` mirrors T3 premium briefs.
+ */
+function estimatePlanOverheadCredits(opts) {
+    return (PLANNER_BASE_CREDITS +
+        (opts.usedThinking ? PLANNER_THINKING_CREDITS : 0) +
+        (opts.usedWebResearch ? WEB_SEARCH_CREDITS : 0) +
+        (opts.bibleBuilt ? BIBLE_BUILD_CREDITS : 0) +
+        CRITIC_CREDITS);
+}
+const clipDurationMs = (c) => Math.max(0, c.display.to - c.display.from);
+function estimateProjectCost(project) {
+    const byTier = { T0: 0, T1: 0, T2: 0, T3: 0 };
+    const perClip = [];
+    for (const clip of project.clips) {
+        const tier = clip.provenance?.tier;
+        let credits = clip.provenance?.creditsSpent;
+        let estimated = false;
+        if (credits === undefined) {
+            if (tier) {
+                credits =
+                    (clipDurationMs(clip) / 1000) * TIER_FALLBACK_PER_SECOND[tier];
+                estimated = true;
+            }
+            else {
+                credits = 0;
+            }
+        }
+        if (tier)
+            byTier[tier] += credits;
+        perClip.push({ clipId: clip.id, tier, credits, estimated });
+    }
+    const totalCredits = perClip.reduce((s, x) => s + x.credits, 0);
+    return { totalCredits, byTier, perClip };
+}
+/**
+ * Plan-side estimate (pre-execution). The planner already writes
+ * `estimatedCredits` per scene + a `totalEstimatedCredits` rollup, so this
+ * mostly trusts those values and re-aggregates by tier for the UI chip.
+ * Falls back to the same per-second tier curve as `estimateProjectCost`
+ * when a scene omits its own estimate.
+ */
+function estimatePlanCost(plan) {
+    const byTier = { T0: 0, T1: 0, T2: 0, T3: 0 };
+    const perClip = [];
+    for (const scene of plan.scenes) {
+        const tier = scene.tier;
+        const credits = estimateSceneCredits(scene);
+        const estimated = scene.estimatedCredits === undefined || scene.estimatedCredits === 0;
+        byTier[tier] += credits;
+        perClip.push({
+            clipId: `scene-${scene.sceneIndex}`,
+            tier,
+            credits,
+            estimated,
+        });
+    }
+    const totalCredits = perClip.reduce((s, x) => s + x.credits, 0);
+    return { totalCredits, byTier, perClip };
+}

package/lib/services/agent/critic.d.ts

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import { AgentPersona } from "../../schemas/agentPersona.schema";
+import { Project } from "../../schemas/project.schema";
+import { VideoBrief } from "../../schemas/brief.schema";
+import { VideoPlan } from "../../schemas/videoPlan.schema";
+import { LlmCaller } from "./llmCaller";
+import { ModelRouter } from "./modelRouter";
+/**
+ * Critic — runs after assets land and BEFORE render. Catches off-brief assets
+ * so the agent can self-heal (regenerate / replace with stock) without burning
+ * a full render cycle.
+ *
+ * Rubric (V1):
+ *   - continuity   : do consecutive scenes match in style / lighting?
+ *   - voSync       : does on-screen text align with the VO line?
+ *   - brandSafety  : are any blocked claims present?
+ *   - consistency  : same product / face across scenes (vision check)
+ *   - costVsTier   : did total spend stay within the tier budget?
+ *
+ * Each rubric item returns pass/warn/fail with a one-line rationale. The
+ * agent self-heals up to one pass on the worst-scoring item.
+ */
+export declare const CriticSeveritySchema: z.ZodEnum<{
+    fail: "fail";
+    warn: "warn";
+    pass: "pass";
+}>;
+export type CriticSeverity = z.infer<typeof CriticSeveritySchema>;
+export declare const CriticFindingSchema: z.ZodObject<{
+    rubric: z.ZodEnum<{
+        brandSafety: "brandSafety";
+        costVsTier: "costVsTier";
+        continuity: "continuity";
+        voSync: "voSync";
+        consistency: "consistency";
+    }>;
+    severity: z.ZodEnum<{
+        fail: "fail";
+        warn: "warn";
+        pass: "pass";
+    }>;
+    clipId: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    suggestedAction: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            trim: "trim";
+            regenerate: "regenerate";
+            replace_with_stock: "replace_with_stock";
+            swap_voice: "swap_voice";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CriticFinding = z.infer<typeof CriticFindingSchema>;
+export declare const CriticReportSchema: z.ZodObject<{
+    overall: z.ZodEnum<{
+        fail: "fail";
+        warn: "warn";
+        pass: "pass";
+    }>;
+    findings: z.ZodArray<z.ZodObject<{
+        rubric: z.ZodEnum<{
+            brandSafety: "brandSafety";
+            costVsTier: "costVsTier";
+            continuity: "continuity";
+            voSync: "voSync";
+            consistency: "consistency";
+        }>;
+        severity: z.ZodEnum<{
+            fail: "fail";
+            warn: "warn";
+            pass: "pass";
+        }>;
+        clipId: z.ZodOptional<z.ZodString>;
+        message: z.ZodString;
+        suggestedAction: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                trim: "trim";
+                regenerate: "regenerate";
+                replace_with_stock: "replace_with_stock";
+                swap_voice: "swap_voice";
+            }>;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CriticReport = z.infer<typeof CriticReportSchema>;
+export interface CriticOptions {
+    llm: LlmCaller;
+    router?: ModelRouter;
+}
+export declare class Critic {
+    private readonly opts;
+    private readonly router;
+    constructor(opts: CriticOptions);
+    review(project: Project, brief: VideoBrief, opts?: {
+        persona?: AgentPersona;
+        plan?: VideoPlan;
+    }): Promise<CriticReport>;
+    private formatEmphasis;
+    private formatTierMix;
+}
+//# sourceMappingURL=critic.d.ts.map

package/lib/services/agent/critic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"critic.d.ts","sourceRoot":"","sources":["../../../src/services/agent/critic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,oBAAoB;;;;EAAmC,CAAC;AACrE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;iBAmB9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,SAAS,CAAC;IACf,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,qBAAa,MAAM;IAGL,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAER,IAAI,EAAE,aAAa;IAI1C,MAAM,CACV,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,UAAU,EACjB,IAAI,GAAE;QAAE,OAAO,CAAC,EAAE,YAAY,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,CAAA;KAAO,GACtD,OAAO,CAAC,YAAY,CAAC;IAwExB,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,aAAa;CAKtB"}

package/lib/services/agent/critic.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Critic = exports.CriticReportSchema = exports.CriticFindingSchema = exports.CriticSeveritySchema = void 0;
+const zod_1 = require("zod");
+const modelRouter_1 = require("./modelRouter");
+const personas_1 = require("./personas");
+/**
+ * Critic — runs after assets land and BEFORE render. Catches off-brief assets
+ * so the agent can self-heal (regenerate / replace with stock) without burning
+ * a full render cycle.
+ *
+ * Rubric (V1):
+ *   - continuity   : do consecutive scenes match in style / lighting?
+ *   - voSync       : does on-screen text align with the VO line?
+ *   - brandSafety  : are any blocked claims present?
+ *   - consistency  : same product / face across scenes (vision check)
+ *   - costVsTier   : did total spend stay within the tier budget?
+ *
+ * Each rubric item returns pass/warn/fail with a one-line rationale. The
+ * agent self-heals up to one pass on the worst-scoring item.
+ */
+exports.CriticSeveritySchema = zod_1.z.enum(["pass", "warn", "fail"]);
+exports.CriticFindingSchema = zod_1.z.object({
+    rubric: zod_1.z.enum([
+        "continuity",
+        "voSync",
+        "brandSafety",
+        "consistency",
+        "costVsTier",
+    ]),
+    severity: exports.CriticSeveritySchema,
+    /** Which clip / scene the finding refers to, if any. */
+    clipId: zod_1.z.string().optional(),
+    message: zod_1.z.string(),
+    /** Optional self-heal hint the executor can act on. */
+    suggestedAction: zod_1.z
+        .object({
+        kind: zod_1.z.enum(["regenerate", "replace_with_stock", "trim", "swap_voice"]),
+        detail: zod_1.z.string().optional(),
+    })
+        .optional(),
+});
+exports.CriticReportSchema = zod_1.z.object({
+    overall: exports.CriticSeveritySchema,
+    findings: zod_1.z.array(exports.CriticFindingSchema),
+});
+class Critic {
+    constructor(opts) {
+        this.opts = opts;
+        this.router = opts.router ?? new modelRouter_1.ModelRouter();
+    }
+    async review(project, brief, opts = {}) {
+        const model = this.router.pickFor("critic");
+        // Vision-mode QA: feed clip thumbnails into the critic for continuity check.
+        // Cap at 6 (was 12). Per-scene critic (perSceneCritic.ts) already grades
+        // every clip individually before stitch; the stitched critic here only
+        // needs enough visual context to judge cross-clip continuity. 6 clips
+        // cover that for typical 4–8 scene ad plans and roughly halves the
+        // base64 fetch + upload time + Gemini Flash vision tokens, which was
+        // the dominant cost driving the soft-fail timeout.
+        const thumbnails = project.clips
+            .map((c) => (c.type === "video" || c.type === "image" ? c.src : null))
+            .filter((u) => Boolean(u))
+            .slice(0, 6); // bound vision token spend
+        const personaEmphasis = opts.persona
+            ? this.formatEmphasis(opts.persona)
+            : "";
+        const tierMix = opts.plan
+            ? this.formatTierMix(opts.plan)
+            : "(plan not provided — judge continuity defensively across all scenes)";
+        const result = await this.opts.llm.structured({
+            model,
+            fallbackModel: this.router.fallbackFor("critic"),
+            schema: exports.CriticReportSchema,
+            schemaName: "CriticReport",
+            temperature: 0.2,
+            messages: [
+                {
+                    role: "system",
+                    content: [
+                        "You are a quality critic for AI-generated short-form videos.",
+                        "Score the project against the rubric.",
+                        "",
+                        "Continuity rule (tier-aware):",
+                        "- T0/T1 scenes use stock or single AI stills + motion. Do NOT flag",
+                        "  continuity unless lighting / colour palette / subject identity",
+                        "  shifts so hard it breaks comprehension. Mood drift is acceptable.",
+                        "- T2/T3 scenes are AI-generated motion the user paid a premium for.",
+                        "  Flag continuity for any visible character / product identity drift,",
+                        "  lighting jumps, or style mismatches with adjacent scenes.",
+                        "",
+                        "Brand-safety rules (strict):",
+                        "- Any phrase in brief.claims.block → fail immediately.",
+                        "- Any unsubstantiated quantitative claim (\"3x faster\", \"99% of users\",",
+                        "  \"clinically proven\", numeric efficacy without a cited source) → warn",
+                        "  with suggestedAction.kind=\"regenerate\" + a corrective rewrite.",
+                        "- Medical / financial / legal claims default to fail unless brief",
+                        "  explicitly allows them.",
+                        "",
+                        "Per-scene tier reference (use to apply the continuity rule):",
+                        tierMix,
+                        personaEmphasis,
+                    ]
+                        .filter(Boolean)
+                        .join("\n"),
+                },
+                {
+                    role: "user",
+                    content: [
+                        `Brief:\n${JSON.stringify(brief, null, 2)}`,
+                        `\nProject:\n${JSON.stringify(project, null, 2)}`,
+                    ].join("\n"),
+                    imageUrls: thumbnails,
+                },
+            ],
+        });
+        return result.data;
+    }
+    formatEmphasis(persona) {
+        const emphasis = personas_1.PERSONA_PACKS[persona].criticEmphasis;
+        const entries = Object.entries(emphasis);
+        if (!entries.length)
+            return "";
+        const lines = entries
+            .map(([axis, weight]) => `  - ${axis}: extra weight ${weight}`)
+            .join("\n");
+        return [
+            "",
+            `Persona "${persona}" — apply extra scrutiny to:`,
+            lines,
+        ].join("\n");
+    }
+    formatTierMix(plan) {
+        return plan.scenes
+            .map((s) => `  scene ${s.sceneIndex}: tier=${s.tier} (${s.strategy})`)
+            .join("\n");
+    }
+}
+exports.Critic = Critic;

package/lib/services/agent/editClassifier.d.ts

@@ -0,0 +1,262 @@
+/**
+ * AG-41 — edit-request classifier + types.
+ *
+ * Goal: when a user (or automated critic) asks for a change to an already-
+ * generated video, we should *not* default to "regenerate the whole plan from
+ * scratch". Most edits map to a much narrower (and cheaper) operation:
+ *
+ *   modify-text         → re-mux only        ($0, ~30s)
+ *   modify-music        → re-mux only        ($0, ~30s)
+ *   reorder-scenes      → re-mux only        ($0, ~30s)
+ *   modify-vo           → re-TTS + re-mux    ($0.01 / scene + ~30s)
+ *   modify-scene-visual → re-gen N scenes + re-stitch  ($$ per scene, longest)
+ *   modify-scene-duration → usually re-gen + re-stitch
+ *   regenerate-all      → fall through to the full planner (last resort)
+ *
+ * The classifier takes the original plan + the user instruction (or a list of
+ * critic findings that triggered an auto-edit) and returns a structured
+ * EditRequest. The router (`editRouter.ts`) then dispatches to handlers.
+ *
+ * This module owns only the *types* and *classifier rules*. Handlers live
+ * elsewhere because they pull in ffmpeg / executor / TTS surfaces.
+ */
+import { z } from "zod";
+export declare const EditRequestTypeSchema: z.ZodEnum<{
+    "modify-text": "modify-text";
+    "modify-vo": "modify-vo";
+    "modify-music": "modify-music";
+    "modify-scene-visual": "modify-scene-visual";
+    "modify-scene-duration": "modify-scene-duration";
+    "reorder-scenes": "reorder-scenes";
+    "regenerate-all": "regenerate-all";
+}>;
+export type EditRequestType = z.infer<typeof EditRequestTypeSchema>;
+export declare const EditScopeSchema: z.ZodObject<{
+    sceneIndices: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    appliesToAllScenes: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type EditScope = z.infer<typeof EditScopeSchema>;
+export declare const TextEditSchema: z.ZodObject<{
+    overlaysByScene: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        role: z.ZodEnum<{
+            body: "body";
+            watermark: "watermark";
+            cta: "cta";
+            headline: "headline";
+            subheadline: "subheadline";
+            disclaimer: "disclaimer";
+            label: "label";
+        }>;
+        position: z.ZodOptional<z.ZodEnum<{
+            center: "center";
+            top: "top";
+            "top-left": "top-left";
+            "top-right": "top-right";
+            "top-banner": "top-banner";
+            "left-rail": "left-rail";
+            "lower-third": "lower-third";
+            bottom: "bottom";
+            "bottom-left": "bottom-left";
+            "bottom-right": "bottom-right";
+            "caption-strip": "caption-strip";
+        }>>;
+        emphasis: z.ZodOptional<z.ZodEnum<{
+            primary: "primary";
+            secondary: "secondary";
+        }>>;
+        font: z.ZodOptional<z.ZodString>;
+        fontSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodNumber]>>;
+        sizePct: z.ZodOptional<z.ZodNumber>;
+        weight: z.ZodOptional<z.ZodEnum<{
+            bold: "bold";
+            regular: "regular";
+            black: "black";
+            medium: "medium";
+        }>>;
+        color: z.ZodOptional<z.ZodString>;
+        bgColor: z.ZodOptional<z.ZodString>;
+        bgStyle: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            shadow: "shadow";
+            pill: "pill";
+            bar: "bar";
+            outline: "outline";
+        }>>;
+        animation: z.ZodOptional<z.ZodEnum<{
+            type: "type";
+            pop: "pop";
+            none: "none";
+            fade: "fade";
+            "slide-up": "slide-up";
+            "word-pop": "word-pop";
+            "highlight-current": "highlight-current";
+        }>>;
+        startMs: z.ZodOptional<z.ZodNumber>;
+        endMs: z.ZodOptional<z.ZodNumber>;
+        persistAcrossScenes: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const VoEditSchema: z.ZodObject<{
+    linesByScene: z.ZodRecord<z.ZodString, z.ZodString>;
+    voiceStyleByScene: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const MusicEditSchema: z.ZodObject<{
+    url: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    moodTag: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const SceneVisualEditSchema: z.ZodObject<{
+    promptByScene: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    modelByScene: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const SceneDurationEditSchema: z.ZodObject<{
+    durationMsByScene: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ReorderEditSchema: z.ZodObject<{
+    newOrder: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const EditRequestSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        "modify-text": "modify-text";
+        "modify-vo": "modify-vo";
+        "modify-music": "modify-music";
+        "modify-scene-visual": "modify-scene-visual";
+        "modify-scene-duration": "modify-scene-duration";
+        "reorder-scenes": "reorder-scenes";
+        "regenerate-all": "regenerate-all";
+    }>;
+    scope: z.ZodObject<{
+        sceneIndices: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        appliesToAllScenes: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    reason: z.ZodString;
+    textEdit: z.ZodOptional<z.ZodObject<{
+        overlaysByScene: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            role: z.ZodEnum<{
+                body: "body";
+                watermark: "watermark";
+                cta: "cta";
+                headline: "headline";
+                subheadline: "subheadline";
+                disclaimer: "disclaimer";
+                label: "label";
+            }>;
+            position: z.ZodOptional<z.ZodEnum<{
+                center: "center";
+                top: "top";
+                "top-left": "top-left";
+                "top-right": "top-right";
+                "top-banner": "top-banner";
+                "left-rail": "left-rail";
+                "lower-third": "lower-third";
+                bottom: "bottom";
+                "bottom-left": "bottom-left";
+                "bottom-right": "bottom-right";
+                "caption-strip": "caption-strip";
+            }>>;
+            emphasis: z.ZodOptional<z.ZodEnum<{
+                primary: "primary";
+                secondary: "secondary";
+            }>>;
+            font: z.ZodOptional<z.ZodString>;
+            fontSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodNumber]>>;
+            sizePct: z.ZodOptional<z.ZodNumber>;
+            weight: z.ZodOptional<z.ZodEnum<{
+                bold: "bold";
+                regular: "regular";
+                black: "black";
+                medium: "medium";
+            }>>;
+            color: z.ZodOptional<z.ZodString>;
+            bgColor: z.ZodOptional<z.ZodString>;
+            bgStyle: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                shadow: "shadow";
+                pill: "pill";
+                bar: "bar";
+                outline: "outline";
+            }>>;
+            animation: z.ZodOptional<z.ZodEnum<{
+                type: "type";
+                pop: "pop";
+                none: "none";
+                fade: "fade";
+                "slide-up": "slide-up";
+                "word-pop": "word-pop";
+                "highlight-current": "highlight-current";
+            }>>;
+            startMs: z.ZodOptional<z.ZodNumber>;
+            endMs: z.ZodOptional<z.ZodNumber>;
+            persistAcrossScenes: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    voEdit: z.ZodOptional<z.ZodObject<{
+        linesByScene: z.ZodRecord<z.ZodString, z.ZodString>;
+        voiceStyleByScene: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    musicEdit: z.ZodOptional<z.ZodObject<{
+        url: z.ZodOptional<z.ZodString>;
+        query: z.ZodOptional<z.ZodString>;
+        moodTag: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    sceneVisualEdit: z.ZodOptional<z.ZodObject<{
+        promptByScene: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        modelByScene: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    sceneDurationEdit: z.ZodOptional<z.ZodObject<{
+        durationMsByScene: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>>;
+    reorderEdit: z.ZodOptional<z.ZodObject<{
+        newOrder: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    estimatedCostCredits: z.ZodDefault<z.ZodNumber>;
+    reuses: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        overlays: "overlays";
+        stitch: "stitch";
+        "scene-visuals": "scene-visuals";
+        voiceovers: "voiceovers";
+        "music-track": "music-track";
+    }>>>;
+}, z.core.$strip>;
+export type EditRequest = z.infer<typeof EditRequestSchema>;
+/**
+ * Heuristic classifier: feed in a list of per-scene critic findings (severity
+ * "fail" only) and we generate an EditRequest that targets the offending
+ * scenes. Used by `repairTrace.ts` to auto-suggest a `modify-scene-visual`
+ * when actionPlausibility fails — no LLM call needed, since the critic
+ * already structured the problem.
+ *
+ * The LLM-driven classifier (for free-text user instructions like "make the
+ * voiceover calmer on scene 3") lives in `classifyUserEditInstruction` below.
+ */
+export declare function classifyCriticFindingsToEdit(args: {
+    perSceneFailures: Array<{
+        sceneIndex: number;
+        dimension: string;
+        message: string;
+    }>;
+    /** Indices that have textual issues (brand spelled wrong, etc.) — re-mux is enough. */
+    textFixSceneIndices?: number[];
+    /**
+     * When the user has explicitly named a target scope (e.g. "fix the cap issue
+     * in scene 4"), restrict any visual re-gen to those indices only. Critic
+     * findings outside this scope are downgraded — they may still surface as a
+     * report, but they don't trigger billable re-gens without user consent.
+     */
+    userIntentScope?: number[];
+}): EditRequest | null;
+/**
+ * LLM-classifier prompt builder. The caller wires this through any LLMCaller
+ * with structured-output support (Gateway / OpenAI / Gemini).
+ *
+ * NOTE: we don't ship a default LLM caller here so the module stays
+ * dependency-light — same pattern as planner / bibleBuilder. Tests can mock.
+ */
+export declare function buildEditClassifierPrompt(args: {
+    userInstruction: string;
+    planSummary: string;
+    completedSceneIndices: number[];
+}): string;
+//# sourceMappingURL=editClassifier.d.ts.map

package/lib/services/agent/editClassifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editClassifier.d.ts","sourceRoot":"","sources":["../../../src/services/agent/editClassifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,qBAAqB;;;;;;;;EAQhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,eAAe;;;iBAS1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGzB,CAAC;AAEH,eAAO,MAAM,YAAY;;;iBAKvB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;iBAK1B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;iBAKhC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;iBAGlC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;iBAG5B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8B5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE;IACjD,gBAAgB,EAAE,KAAK,CAAC;QACtB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;IACH,uFAAuF;IACvF,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B,GAAG,WAAW,GAAG,IAAI,CAwCrB;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,qBAAqB,EAAE,MAAM,EAAE,CAAC;CACjC,GAAG,MAAM,CAuBT"}