vidspotai-shared 1.0.68 → 1.0.69-dev.0

package/lib/services/agent/editClassifier.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditRequestSchema = exports.ReorderEditSchema = exports.SceneDurationEditSchema = exports.SceneVisualEditSchema = exports.MusicEditSchema = exports.VoEditSchema = exports.TextEditSchema = exports.EditScopeSchema = exports.EditRequestTypeSchema = void 0;
+exports.classifyCriticFindingsToEdit = classifyCriticFindingsToEdit;
+exports.buildEditClassifierPrompt = buildEditClassifierPrompt;
+const zod_1 = require("zod");
+const videoPlan_schema_1 = require("../../schemas/videoPlan.schema");
+exports.EditRequestTypeSchema = zod_1.z.enum([
+    "modify-text",
+    "modify-vo",
+    "modify-music",
+    "modify-scene-visual",
+    "modify-scene-duration",
+    "reorder-scenes",
+    "regenerate-all",
+]);
+exports.EditScopeSchema = zod_1.z.object({
+    /** Affected scene indices. If empty + type is global-ish, applies to whole plan. */
+    sceneIndices: zod_1.z.array(zod_1.z.number().int().nonnegative()).default([]),
+    /**
+     * "all" sentinel: the change applies across every scene (e.g. swapping the
+     * music track, regenerating with a new style). Cheaper than a regenerate-all
+     * because we still skip the planner — just rerun specific steps for every scene.
+     */
+    appliesToAllScenes: zod_1.z.boolean().default(false),
+});
+exports.TextEditSchema = zod_1.z.object({
+    /** New overlays for the affected scenes, keyed by sceneIndex. */
+    overlaysByScene: zod_1.z.record(zod_1.z.string(), zod_1.z.array(videoPlan_schema_1.TextOverlaySchema)),
+});
+exports.VoEditSchema = zod_1.z.object({
+    /** Per-scene replacement voiceover lines. */
+    linesByScene: zod_1.z.record(zod_1.z.string(), zod_1.z.string()),
+    /** Optional new voiceStyle for these scenes (per-scene override). */
+    voiceStyleByScene: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+});
+exports.MusicEditSchema = zod_1.z.object({
+    /** Either an explicit URL OR a search query for the music selector. */
+    url: zod_1.z.string().url().optional(),
+    query: zod_1.z.string().optional(),
+    moodTag: zod_1.z.string().optional(),
+});
+exports.SceneVisualEditSchema = zod_1.z.object({
+    /** New visual prompt to feed the generator. If absent, re-uses the original. */
+    promptByScene: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+    /** Optional new preferred model per scene (e.g. swap to runway for one scene). */
+    modelByScene: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+});
+exports.SceneDurationEditSchema = zod_1.z.object({
+    /** New durationMs per scene. Renderer / VO will adapt. */
+    durationMsByScene: zod_1.z.record(zod_1.z.string(), zod_1.z.number().int().positive()),
+});
+exports.ReorderEditSchema = zod_1.z.object({
+    /** New order — array of original sceneIndices in the desired playback sequence. */
+    newOrder: zod_1.z.array(zod_1.z.number().int().nonnegative()).min(2),
+});
+exports.EditRequestSchema = zod_1.z.object({
+    type: exports.EditRequestTypeSchema,
+    scope: exports.EditScopeSchema,
+    reason: zod_1.z.string().min(4).describe("Why this edit is being made; surfaced to user for confirmation."),
+    textEdit: exports.TextEditSchema.optional(),
+    voEdit: exports.VoEditSchema.optional(),
+    musicEdit: exports.MusicEditSchema.optional(),
+    sceneVisualEdit: exports.SceneVisualEditSchema.optional(),
+    sceneDurationEdit: exports.SceneDurationEditSchema.optional(),
+    reorderEdit: exports.ReorderEditSchema.optional(),
+    /**
+     * Cost estimate. Drives the confirmation gate — if user pinned a budget, we
+     * surface this before billing fires.
+     */
+    estimatedCostCredits: zod_1.z.number().nonnegative().default(0),
+    /**
+     * Operations that get reused (kept as-is) from the prior run. The router uses
+     * this purely for telemetry — "we saved X% by not regenerating scene Y".
+     */
+    reuses: zod_1.z
+        .array(zod_1.z.enum([
+        "scene-visuals",
+        "voiceovers",
+        "music-track",
+        "stitch",
+        "overlays",
+    ]))
+        .default([]),
+});
+/**
+ * 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.
+ */
+function classifyCriticFindingsToEdit(args) {
+    const scopeFilter = args.userIntentScope?.length
+        ? (sceneIndex) => args.userIntentScope.includes(sceneIndex)
+        : () => true;
+    const visualFails = args.perSceneFailures.filter((f) => [
+        "actionPlausibility",
+        "promptAdherence",
+        "compositionQuality",
+        "motionQuality",
+        "characterDrift",
+    ].includes(f.dimension) && scopeFilter(f.sceneIndex));
+    if (visualFails.length === 0 && (args.textFixSceneIndices?.length ?? 0) === 0) {
+        return null;
+    }
+    // Prefer the narrower edit: if only text issues, return modify-text;
+    // otherwise modify-scene-visual on the visual-fail indices.
+    if (visualFails.length === 0) {
+        return {
+            type: "modify-text",
+            scope: { sceneIndices: args.textFixSceneIndices, appliesToAllScenes: false },
+            reason: "Critic flagged text overlays needing repair.",
+            reuses: ["scene-visuals", "voiceovers", "music-track"],
+            estimatedCostCredits: 0,
+        };
+    }
+    const affected = Array.from(new Set(visualFails.map((f) => f.sceneIndex)));
+    return {
+        type: "modify-scene-visual",
+        scope: { sceneIndices: affected, appliesToAllScenes: false },
+        reason: `Per-scene critic flagged ${visualFails.length} fail finding(s) across ${affected.length} scene(s): ${visualFails
+            .slice(0, 3)
+            .map((f) => `scene ${f.sceneIndex}/${f.dimension}`)
+            .join(", ")}.`,
+        reuses: ["voiceovers", "music-track", "overlays"],
+        // Rough estimate: I2V scene is ~3 credits on T2 tier. Caller refines.
+        estimatedCostCredits: affected.length * 4,
+    };
+}
+/**
+ * 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.
+ */
+function buildEditClassifierPrompt(args) {
+    return [
+        "You classify user edit requests against an already-generated video into a structured EditRequest.",
+        "Pick the NARROWEST applicable edit type — regenerate-all is a last resort.",
+        "Cost matters: every full scene re-gen costs the user credits. Prefer modify-text > modify-music > modify-vo > modify-scene-visual > regenerate-all.",
+        "",
+        "Plan summary (the current state of the video):",
+        args.planSummary,
+        "",
+        `Completed scenes (already rendered, you can reuse): ${args.completedSceneIndices.join(", ") || "(none)"}`,
+        "",
+        "User instruction:",
+        `"""${args.userInstruction}"""`,
+        "",
+        "Output a JSON EditRequest. Set `reason` so the user sees WHY this is the chosen edit (and can override). Set `reuses` to honestly list what stays the same — that's the cost-saving accountability line.",
+        "Examples of correct narrowing:",
+        "  - 'change the CTA wording' → modify-text on the last scene, reuse everything else",
+        "  - 'use calmer voiceover for scene 2' → modify-vo on scene 2, reuse visuals + music + other VOs",
+        "  - 'the bottle has the cap still on while she drinks' → modify-scene-visual on the offending scene only",
+        "  - 'use jazz music instead' → modify-music, reuse all scenes",
+        "  - 'reverse the order of the middle scenes' → reorder-scenes, reuse everything",
+        "  - 'redo the whole thing in a more cinematic style' → regenerate-all (style change touches every scene)",
+    ].join("\n");
+}

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

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./recorder";
+export * from "./judge";
+export * from "./seedBriefs";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/eval/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC"}

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

@@ -0,0 +1,20 @@
+"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("./types"), exports);
+__exportStar(require("./recorder"), exports);
+__exportStar(require("./judge"), exports);
+__exportStar(require("./seedBriefs"), exports);

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

@@ -0,0 +1,14 @@
+import { AgentPersona } from "../../../schemas/agentPersona.schema";
+import { Project } from "../../../schemas/project.schema";
+import { LlmCaller } from "../llmCaller";
+import { ModelRouter } from "../modelRouter";
+import { EvalBrief, EvalScore } from "./types";
+export declare class EvalJudge {
+    private readonly llm;
+    private readonly router;
+    constructor(llm: LlmCaller, router?: ModelRouter);
+    judge(brief: EvalBrief, project: Project, agentRunId: string, opts?: {
+        persona?: AgentPersona;
+    }): Promise<EvalScore>;
+}
+//# sourceMappingURL=judge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"judge.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/eval/judge.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AACpE,OAAO,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAgC,SAAS,EAAE,MAAM,SAAS,CAAC;AAgD7E,qBAAa,SAAS;IAGR,OAAO,CAAC,QAAQ,CAAC,GAAG;IAFhC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAER,GAAG,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,WAAW;IAI3D,KAAK,CACT,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,EAClB,IAAI,GAAE;QAAE,OAAO,CAAC,EAAE,YAAY,CAAA;KAAO,GACpC,OAAO,CAAC,SAAS,CAAC;CA+CtB"}

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvalJudge = void 0;
+const zod_1 = require("zod");
+const modelRouter_1 = require("../modelRouter");
+const personas_1 = require("../personas");
+const types_1 = require("./types");
+/**
+ * LLM-as-judge — scores a finalized Project against an EvalBrief's rubric.
+ *
+ * Uses the critic-tier model (vision-capable Sonnet) with a strict structured
+ * output. Independent from the live Critic that runs during a real agent run;
+ * the judge is allowed to be slower / more expensive because it runs offline.
+ */
+const RUBRIC_WEIGHTS = {
+    hookStrength: 0.2,
+    voVisualSync: 0.2,
+    pacingFit: 0.15,
+    brandSafety: 0.15,
+    costVsTier: 0.1,
+    intentMatch: 0.2,
+};
+/**
+ * Apply persona criticEmphasis as additive deltas to the base weights, then
+ * renormalise so the weight set still sums to 1. Keeps scores comparable
+ * across personas while letting each persona's "what matters most" lean
+ * the aggregate score.
+ */
+function weightsForPersona(persona) {
+    if (!persona)
+        return RUBRIC_WEIGHTS;
+    const emphasis = personas_1.PERSONA_PACKS[persona].criticEmphasis;
+    const adjusted = { ...RUBRIC_WEIGHTS };
+    for (const [axis, delta] of Object.entries(emphasis)) {
+        const key = axis;
+        adjusted[key] = Math.max(0, adjusted[key] + (delta ?? 0));
+    }
+    const total = Object.values(adjusted).reduce((s, v) => s + v, 0);
+    if (total <= 0)
+        return RUBRIC_WEIGHTS;
+    for (const k of Object.keys(adjusted)) {
+        adjusted[k] = adjusted[k] / total;
+    }
+    return adjusted;
+}
+const JudgeOutputSchema = zod_1.z.object({
+    rubric: types_1.EvalRubricSchema,
+    notes: zod_1.z.string(),
+});
+class EvalJudge {
+    constructor(llm, router) {
+        this.llm = llm;
+        this.router = router ?? new modelRouter_1.ModelRouter();
+    }
+    async judge(brief, project, agentRunId, opts = {}) {
+        const model = this.router.pickFor("critic");
+        const weights = weightsForPersona(opts.persona);
+        const messages = [
+            {
+                role: "system",
+                content: [
+                    "You are an offline quality judge for AI-generated short videos.",
+                    "Score the project against the rubric on each axis (0-1, two decimals).",
+                    "Be harsh: 1.0 means publish-without-edit; 0.7 is good but with one fixable issue;",
+                    "0.4 means a re-roll is needed. Cite concrete clip ids in `notes`.",
+                ].join(" "),
+            },
+            {
+                role: "user",
+                content: [
+                    `Brief id: ${brief.id} (niche: ${brief.niche})`,
+                    `What "good" looks like:\n${brief.goodOutputNotes}`,
+                    `\nProject JSON:\n${JSON.stringify(project, null, 2)}`,
+                ].join("\n\n"),
+            },
+        ];
+        const result = await this.llm.structured({
+            model,
+            fallbackModel: this.router.fallbackFor("critic"),
+            messages,
+            schema: JudgeOutputSchema,
+            schemaName: "EvalJudgeResult",
+            temperature: 0,
+        });
+        const aggregate = Object.keys(weights).reduce((sum, key) => sum + result.data.rubric[key] * weights[key], 0);
+        return {
+            briefId: brief.id,
+            agentRunId,
+            rubric: result.data.rubric,
+            score: Number(aggregate.toFixed(3)),
+            judgeNotes: result.data.notes,
+            scoredAt: new Date().toISOString(),
+        };
+    }
+}
+exports.EvalJudge = EvalJudge;

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

@@ -0,0 +1,28 @@
+import { ToolContext, ToolOutcome } from "../toolRegistry";
+import { AgentRunTrace } from "./types";
+export declare function setTracePersistence(fn: (trace: AgentRunTrace) => Promise<void>): void;
+export declare function startTrace(opts: {
+    agentRunId: string;
+    briefId?: string;
+    modelRouting: Record<string, string>;
+    rngSeed: string;
+}): AgentRunTrace;
+export declare function getTrace(agentRunId: string): AgentRunTrace | undefined;
+export declare function endTrace(agentRunId: string): Promise<AgentRunTrace | undefined>;
+/**
+ * Drop-in replacement for runTool that records the call in the active trace.
+ * Use this in eval mode; production code can keep calling runTool directly.
+ */
+export declare function runToolRecorded<O = unknown>(name: string, input: unknown, ctx: ToolContext): Promise<ToolOutcome<O>>;
+/**
+ * C46 — wrap a pipeline stage so its wall-clock duration lands in
+ * `trace.stageTimings` AND on a single machine-readable log line. Lets us
+ * distinguish slow-but-progressing from actually-stuck without scraping
+ * trace.json (Loki picks up the log; trace.json keeps it for post-mortems).
+ *
+ * Counts duration whether the stage resolves or throws — so a crashed stage
+ * still leaves a timing footprint. Caller decides whether to swallow the
+ * error.
+ */
+export declare function trackStage<T>(agentRunId: string, stage: string, fn: () => Promise<T>, log?: (msg: string, ctx: Record<string, unknown>) => void): Promise<T>;
+//# sourceMappingURL=recorder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/eval/recorder.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,WAAW,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnF,OAAO,EAAE,aAAa,EAA8B,MAAM,SAAS,CAAC;AAcpE,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAErF;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,aAAa,CAWhB;AAED,wBAAgB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAEtE;AAED,wBAAsB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAgBrF;AAED;;;GAGG;AACH,wBAAsB,eAAe,CAAC,CAAC,GAAG,OAAO,EAC/C,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,WAAW,GACf,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CASzB;AAED;;;;;;;;;GASG;AACH,wBAAsB,UAAU,CAAC,CAAC,EAChC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GACxD,OAAO,CAAC,CAAC,CAAC,CAiBZ"}

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setTracePersistence = setTracePersistence;
+exports.startTrace = startTrace;
+exports.getTrace = getTrace;
+exports.endTrace = endTrace;
+exports.runToolRecorded = runToolRecorded;
+exports.trackStage = trackStage;
+const toolRegistry_1 = require("../toolRegistry");
+const logger_1 = require("../../../utils/logger");
+/**
+ * Recording wrapper around runTool — every tool call is appended to a trace
+ * buffer keyed by agentRunId. Replay reads this buffer back; offline eval
+ * compares two recordings against the same brief.
+ *
+ * Storage is in-memory by default; the host swaps in a Firestore-backed
+ * implementation by setting the persistence callback.
+ */
+const traces = new Map();
+let persistFn = null;
+function setTracePersistence(fn) {
+    persistFn = fn;
+}
+function startTrace(opts) {
+    const trace = {
+        agentRunId: opts.agentRunId,
+        briefId: opts.briefId,
+        startedAt: new Date().toISOString(),
+        modelRouting: opts.modelRouting,
+        rngSeed: opts.rngSeed,
+        toolCalls: [],
+    };
+    traces.set(opts.agentRunId, trace);
+    return trace;
+}
+function getTrace(agentRunId) {
+    return traces.get(agentRunId);
+}
+async function endTrace(agentRunId) {
+    const trace = traces.get(agentRunId);
+    if (!trace)
+        return undefined;
+    trace.endedAt = new Date().toISOString();
+    if (persistFn) {
+        try {
+            await persistFn(trace);
+        }
+        catch (err) {
+            // Persistence failure must not poison the agent run, but surface to ops.
+            logger_1.logger.error("eval recorder: trace persist failed", {
+                agentRunId: trace.agentRunId,
+                err: err instanceof Error ? err.stack ?? err.message : String(err),
+            });
+        }
+    }
+    return trace;
+}
+/**
+ * Drop-in replacement for runTool that records the call in the active trace.
+ * Use this in eval mode; production code can keep calling runTool directly.
+ */
+async function runToolRecorded(name, input, ctx) {
+    const ts = Date.now();
+    const outcome = await (0, toolRegistry_1.runTool)(name, input, ctx);
+    const trace = traces.get(ctx.agentRunId);
+    if (trace) {
+        const entry = { ts, tool: name, input, outcome };
+        trace.toolCalls.push(entry);
+    }
+    return outcome;
+}
+/**
+ * C46 — wrap a pipeline stage so its wall-clock duration lands in
+ * `trace.stageTimings` AND on a single machine-readable log line. Lets us
+ * distinguish slow-but-progressing from actually-stuck without scraping
+ * trace.json (Loki picks up the log; trace.json keeps it for post-mortems).
+ *
+ * Counts duration whether the stage resolves or throws — so a crashed stage
+ * still leaves a timing footprint. Caller decides whether to swallow the
+ * error.
+ */
+async function trackStage(agentRunId, stage, fn, log) {
+    const startedAt = Date.now();
+    try {
+        return await fn();
+    }
+    finally {
+        const durationMs = Date.now() - startedAt;
+        const trace = traces.get(agentRunId);
+        if (trace) {
+            const timing = { stage, startedAt, durationMs };
+            (trace.stageTimings ?? (trace.stageTimings = [])).push(timing);
+        }
+        log?.(`[timing] stage=${stage} ms=${durationMs}`, {
+            agentRunId,
+            stage,
+            durationMs,
+        });
+    }
+}

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

@@ -0,0 +1,16 @@
+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).
+ *
+ * Use these to:
+ *   1. Catch routing regressions (router persona !== expected niche).
+ *   2. Catch planner regressions (tier mix, schema validity, scene count).
+ *   3. Score quality drift after prompt / model / rubric changes.
+ *
+ * Add new briefs alongside the change that needs them; do not bulk-grow
+ * without a reason — every brief costs 4 LLM calls per run.
+ */
+export declare const SEED_EVAL_BRIEFS: EvalBrief[];
+//# sourceMappingURL=seedBriefs.d.ts.map

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

@@ -0,0 +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"}