videobook 0.0.0-stage → 0.1.0

package/dist/goal-plan.js

@@ -0,0 +1,220 @@
+import { z } from "zod";
+import { LIGHTNING_VIDEO_MODEL } from "./lightning-defaults.js";
+import { GOAL_PROMPT_BUDGET, goalPromptWords } from "./goal-prompt-budget.js";
+import { GOAL_STYLE_IDS, goalStyleFragment, resolveGoalStyleOptions } from "./goal-styles.js";
+export { compileGoalV3Approval, compileGoalV3Steps, goalMediaRefSchema, goalPlanV3Schema, isGoalPlanV3, refreshGoalPlanV3 } from "./goal-plan-v3.js";
+export { GOAL_PROMPT_BUDGET, goalPromptWords } from "./goal-prompt-budget.js";
+export const GOAL_VIDEO_TOOL = "generate_video";
+export const GOAL_VIDEO_MODEL = LIGHTNING_VIDEO_MODEL;
+const GOAL_IMAGE_MODELS = {
+    "nano-banana-2-1": { text: "kie:nano-banana-2-1", edit: "kie:nano-banana-2-1" },
+    sunburst: { text: "kie:gpt-image-2-5-sunburst-text-to-image", edit: "kie:gpt-image-2-5-sunburst-image-to-image" },
+    flare: { text: "kie:gpt-image-2-5-flare-text-to-image", edit: "kie:gpt-image-2-5-flare-image-to-image" },
+};
+const GOAL_MAX_SHOTS = 8;
+const goalPrompt = (limit) => z.string().trim().min(1).max(limit)
+    .regex(/^[^@]*$/u, "Use Reference 1, Reference 2 and plain text in plan prompts; input references are added automatically");
+export const goalStyleSchema = z.object({
+    id: z.enum(GOAL_STYLE_IDS), options: z.record(z.string(), z.string()),
+}).strict().superRefine((style, context) => {
+    try {
+        resolveGoalStyleOptions(style.id, style.options);
+    }
+    catch (error) {
+        context.addIssue({ code: "custom", path: ["options"], message: error instanceof Error ? error.message : String(error), fatal: true });
+    }
+}).overwrite(style => ({ ...style, options: resolveGoalStyleOptions(style.id, style.options) }));
+export const legacyGoalPlanSchema = z.object({
+    title: z.string().trim().min(1).max(120),
+    continuity: z.string().trim().min(1).max(3000),
+    aspectRatio: z.enum(["16:9", "9:16", "1:1"]),
+    shots: z.array(z.object({
+        title: z.string().trim().min(1).max(120),
+        prompt: z.string().trim().min(1).max(6000),
+        durationSeconds: z.number().int().min(4).max(30),
+    })).min(1).max(GOAL_MAX_SHOTS),
+}).strict();
+export const goalPlanSchema = legacyGoalPlanSchema.extend({
+    version: z.literal(2),
+    style: goalStyleSchema.default({ id: "cinematic", options: {} }),
+    title: goalPrompt(120),
+    continuity: goalPrompt(3000),
+    imageModel: z.enum(["sunburst", "flare", "nano-banana-2-1"]).default("sunburst"),
+    storyboardLayout: z.enum(["four-panel", "six-panel"]).optional(),
+    referenceRoles: z.array(z.enum(["scene", "character", "prop", "reference"])).max(8).optional(),
+    imageResolution: z.enum(["1K", "2K"]).default("2K"),
+    videoResolution: z.enum(["480p", "720p"]).default("720p"),
+    frameContinuity: z.boolean().default(false),
+    frame: z.object({ prompt: goalPrompt(6000) }).strict(),
+    shots: z.array(z.object({
+        title: goalPrompt(120),
+        storyboardPrompt: goalPrompt(6000),
+        endingPrompt: goalPrompt(6000).nullable().default(null),
+        videoPrompt: goalPrompt(6000),
+        durationSeconds: z.number().int().min(4).max(30),
+    }).strict()).min(1).max(GOAL_MAX_SHOTS),
+}).strict();
+export const goalPlannerResponseSchema = goalPlanSchema.extend({
+    storyboardLayout: z.enum(["four-panel", "six-panel"]).default("six-panel"),
+    referenceRoles: z.array(z.enum(["scene", "character", "prop", "reference"])).max(8).default([]),
+    title: goalPrompt(80),
+    continuity: goalPrompt(600),
+    frame: z.object({ prompt: goalPrompt(400) }).strict(),
+    shots: z.array(goalPlanSchema.shape.shots.element.extend({
+        title: goalPrompt(80),
+        storyboardPrompt: goalPrompt(500),
+        endingPrompt: goalPrompt(250).nullable().default(null),
+        videoPrompt: goalPrompt(400),
+    })).min(1).max(GOAL_MAX_SHOTS),
+});
+export function goalPromptBudgetIssues(plan) {
+    const fields = [
+        ["Title", plan.title, GOAL_PROMPT_BUDGET.title],
+        ["Continuity", plan.continuity, GOAL_PROMPT_BUDGET.continuity],
+        ["Frame", plan.frame.prompt, GOAL_PROMPT_BUDGET.frame],
+        ...plan.shots.flatMap((shot, index) => [
+            [`Shot ${index + 1} title`, shot.title, GOAL_PROMPT_BUDGET.title],
+            [`Storyboard ${index + 1}`, shot.storyboardPrompt, plan.storyboardLayout === "six-panel" ? 48 : GOAL_PROMPT_BUDGET.storyboard],
+            [`Ending ${index + 1}`, shot.endingPrompt ?? "", GOAL_PROMPT_BUDGET.ending],
+            [`Video ${index + 1}`, shot.videoPrompt, GOAL_PROMPT_BUDGET.video],
+        ]),
+    ];
+    return fields.flatMap(([label, value, limit]) => {
+        const words = goalPromptWords(value);
+        return words > limit ? [`${label}: ${words} words; limit ${limit}.`] : [];
+    });
+}
+export function goalBriefConstraints(brief) {
+    const words = {
+        one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8,
+        nine: 9, ten: 10, eleven: 11, twelve: 12,
+    };
+    const modifiers = "(?:(?:short|funny|comedic|cinematic|animated|portrait|vertical|square|landscape|horizontal)[ -]+){0,3}";
+    const count = new RegExp(`\\b(\\d+|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve)\\s+${modifiers}(?:\\d+(?:\\.\\d+)?[ -]*(?:s|secs?|seconds?)[ -]*)?${modifiers}(?:clips?|videos?)\\b`, "iu").exec(brief);
+    const multiplier = /\b(\d+)\s*[x×]\s*(\d+)\s*(?:s|secs?|seconds?)\b/iu.exec(brief);
+    const clipDuration = /\b(\d+(?:\.\d+)?)[ -]*(?:s|secs?|seconds?)[ -]*(?:clips?|shots?|scenes?|each)\b/iu.exec(brief)
+        ?? /\b(?:clips?|shots?|scenes?)\s+(?:of\s+)?(\d+(?:\.\d+)?)[ -]*(?:s|secs?|seconds?)\b/iu.exec(brief);
+    const duration = /\b(\d+(?:\.\d+)?)[ -]*(?:s|secs?|seconds?)\b/iu.exec(brief);
+    const shotCount = count ? words[count[1].toLowerCase()] ?? Number(count[1])
+        : multiplier ? Number(multiplier[1]) : 1;
+    const durationSeconds = multiplier ? Number(multiplier[2]) : clipDuration ? Number(clipDuration[1]) : duration ? Number(duration[1]) : shotCount === 1 ? 20 : 10;
+    if (!Number.isInteger(shotCount) || shotCount < 1 || shotCount > GOAL_MAX_SHOTS) {
+        throw new Error(`A goal supports 1–${GOAL_MAX_SHOTS} clips. Choose a smaller shot count.`);
+    }
+    if (!Number.isInteger(durationSeconds) || durationSeconds < 4 || durationSeconds > 30) {
+        throw new Error("Each goal clip must be a whole number of seconds from 4 to 30.");
+    }
+    const aspectRatio = /\b(?:16:9|landscape|horizontal|widescreen)\b/iu.test(brief) ? "16:9"
+        : /\b(?:1:1|square)\b/iu.test(brief) ? "1:1" : "9:16";
+    return { shotCount, durationSeconds, aspectRatio };
+}
+function styledGoalPrompt(plan, stage, text) {
+    const fragment = goalStyleFragment(plan.style, stage);
+    return fragment ? `${text}\n\n${fragment}` : text;
+}
+function goalReferenceName(plan, index) {
+    return plan.storyboardLayout === "six-panel" ? `Reference ${index + 1} (${plan.referenceRoles?.[index] ?? "reference"})` : `Character ${index + 1}`;
+}
+function goalReferenceLegend(plan, characters, frame = null) {
+    return `${[...(frame ? [plan.storyboardLayout === "six-panel" ? "@image1 approved scene: keep clothes, props, place" : "@image1 full frame: keep clothes, props"] : []), ...characters.map((_, index) => `@image${index + (frame ? 2 : 1)} ${goalReferenceName(plan, index)}`)].join("; ")}.`;
+}
+function goalImageStep(id, plan, prompt, references) {
+    const models = GOAL_IMAGE_MODELS[plan.imageModel];
+    return {
+        id,
+        tool: "generate_image",
+        params: {
+            model: references.length > 0 ? models.edit : models.text,
+            prompt,
+            refs: { image: [...references] },
+            options: {
+                aspect_ratio: plan.aspectRatio,
+                resolution: plan.imageResolution,
+                ...(plan.imageModel === "nano-banana-2-1" ? { output_format: "png" } : { background: "opaque" }),
+            },
+        },
+    };
+}
+export function compileFrameSteps(plan, characters) {
+    return [goalImageStep("frame", plan, `${styledGoalPrompt(plan, "frame", `${plan.continuity}\n\n${plan.frame.prompt}`)}\n\n${goalReferenceLegend(plan, characters)}`, characters.map(character => character.address))];
+}
+function storyboardLayoutPrompt(plan, index) {
+    const six = plan.storyboardLayout === "six-panel";
+    const beat = plan.shots[index].durationSeconds / (six ? 6 : 4);
+    const time = (value) => six ? Number(value.toFixed(1)) : value;
+    const times = Array.from({ length: six ? 6 : 4 }, (_, position) => `${time(position * beat)}–${time((position + 1) * beat)}s`);
+    return `${six ? "2 columns by 3 rows, six-panel" : "2x2"} storyboard. Each ${plan.aspectRatio}. Left-right, top-bottom: ${six ? "hook; setup; action; escalation; reaction; payoff" : "setup; action; reaction; ending"}. Below pictures: timing + action/camera notes. Times: ${times.join("; ")}. Pictures text-free.`;
+}
+export function compileStoryboardSteps(plan, characters, frame, indexes = plan.shots.map((_, index) => index)) {
+    const frames = [...indexes.map(index => ({ index, ending: false })), ...(plan.frameContinuity ? indexes.map(index => ({ index, ending: true })) : [])];
+    return frames.map(({ index, ending }) => goalImageStep(`storyboard${index + 1 + (ending ? plan.shots.length : 0)}`, plan, `${styledGoalPrompt(plan, ending ? "ending" : "storyboard", ending ? `Ending frame. ${goalEndingPrompt(plan, index)}` : `${storyboardLayoutPrompt(plan, index)}\n\n${goalStillPrompt(plan, "storyboards", index)}`)}\n\n${goalReferenceLegend(plan, characters, "full")}`, [frame, ...characters.map(character => character.address)]));
+}
+function goalEndingPrompt(plan, index) {
+    const shot = plan.shots[index];
+    return shot.endingPrompt ?? `Final moment: ${shot.videoPrompt}`;
+}
+export function goalStillPrompt(plan, stage, index) {
+    if (stage === "frame" && index === 0)
+        return plan.frame.prompt;
+    if (stage === "storyboards" && index >= 0 && index < plan.shots.length) {
+        const shot = plan.shots[index];
+        return `Shot ${index + 1}: ${shot.title} (${shot.durationSeconds}s). ${shot.storyboardPrompt}${plan.storyboardLayout === "six-panel" ? "" : `\nAction: ${shot.videoPrompt}`}`;
+    }
+    if (stage === "storyboards" && plan.frameContinuity && index >= plan.shots.length && index < plan.shots.length * 2)
+        return goalEndingPrompt(plan, index - plan.shots.length);
+    throw new Error("There is no still at this stage and index");
+}
+export function compileReviseStillStep(plan, characters, stage, index, current, feedback, frame) {
+    const basePrompt = goalStillPrompt(plan, stage, index);
+    const storyboard = stage === "storyboards" && index < plan.shots.length;
+    if (stage === "storyboards" && !frame)
+        throw new Error("Choose a full frame before revising storyboards");
+    const references = ["@image1: previous version", ...(frame ? ["@image2: full frame"] : []),
+        ...characters.map((_, position) => `@image${position + (frame ? 3 : 2)}: ${goalReferenceName(plan, position)}`)];
+    return goalImageStep(stage === "frame" ? "frame" : `storyboard${index + 1}`, plan, `${styledGoalPrompt(plan, "revise", `${storyboard ? `${storyboardLayoutPrompt(plan, index)}\n\n` : ""}${basePrompt}\n\nChange @image1: ${feedback.replace(/[.!?]+$/u, "")}. Keep rest.${storyboard ? plan.storyboardLayout === "six-panel" ? " Six distinct moments." : " Four distinct moments." : ""}`)}\n\n${references.join("; ")}.`, [current, ...(frame ? [frame] : []), ...characters.map(character => character.address)]);
+}
+function goalShotParams(plan, index, storyboard, ending, options) {
+    const shot = plan.shots[index];
+    const fragment = goalStyleFragment(plan.style, "video");
+    const six = plan.storyboardLayout === "six-panel";
+    const references = [storyboard, ...(ending ? [ending] : []), ...(six && options.frame ? [options.frame] : []), ...(six ? (options.characters ?? []).map(character => character.address) : [])];
+    const sceneSlot = ending ? 3 : 2;
+    const legend = six ? [options.frame ? `@image${sceneSlot} approved scene` : "", ...(options.characters ?? []).map((_, position) => `@image${sceneSlot + (options.frame ? 1 : 0) + position} ${goalReferenceName(plan, position)}`)].filter(Boolean).join("; ") : "";
+    return {
+        model: GOAL_VIDEO_MODEL,
+        prompt: `${shot.videoPrompt}${options.feedback ? `\nRevision: ${options.feedback}` : ""}\n\n@image1 storyboard. ${six ? "Six beats in reading order, follow its timestamps" : `Four beats in order, ${shot.durationSeconds / 4}s each`}. Same people, place. Full-screen.${fragment ? ` ${fragment}` : ""}${ending ? " @image2 ending pose." : ""}${legend ? ` ${legend}.` : ""} No grid, borders, notes, text. No music.`,
+        refs: { image: references },
+        mode: "r2v",
+        options: {
+            duration: shot.durationSeconds,
+            aspect_ratio: plan.aspectRatio,
+            resolution: plan.videoResolution,
+            generate_audio: true,
+        },
+    };
+}
+export function compileVideoSteps(goalId, plan, storyboards, endings = [], options = {}) {
+    if (storyboards.length !== plan.shots.length)
+        throw new Error("Approve a storyboard for every shot before generating videos");
+    if (plan.frameContinuity && endings.length !== plan.shots.length)
+        throw new Error("Approve an ending frame for every shot before generating videos");
+    const steps = [
+        ...(options.indexes ?? plan.shots.map((_, index) => index)).map(index => ({
+            id: `shot${index + 1}`,
+            tool: GOAL_VIDEO_TOOL,
+            params: goalShotParams(plan, index, storyboards[index], plan.frameContinuity ? endings[index] : undefined, options),
+        })),
+    ];
+    if (plan.shots.length > 1 && options.assemble !== false)
+        steps.push({
+            id: "assemble",
+            tool: "assemble_goal",
+            params: {
+                goal_id: goalId,
+                artifact_ids: plan.shots.map((_, index) => ({
+                    $ref: { step_id: `shot${index + 1}`, output: "asset_id" },
+                })),
+            },
+        });
+    return steps;
+}

package/dist/goal-planner-prompt.js

@@ -0,0 +1,28 @@
+import { GOAL_PROMPT_BUDGET, goalBriefConstraints } from "./goal-plan.js";
+import { goalStyle, goalStyleSummary, resolveGoalStyleOptions } from "./goal-styles.js";
+const cinematicInstructions = `Plan video. Return version 2 JSON. Barebones prompts: short noun/verb fragments, present tense. No filler, prose, jargon lists or stacked adjectives. Name inputs Reference 1, Reference 2. Infer referenceRoles in input order: scene, character, prop or reference; use actual pixels and the brief. Continuity: identity, props, place, style once. Frame: the edited scene with the requested characters and props. storyboardLayout: six-panel. Storyboard: six semicolon-separated action/camera notes, hook/setup/action/escalation/reaction/payoff; 2 columns by 3 rows with timestamps and shot notes below pictures. Let the storyboard guide the video. videoPrompt: only essential motion and sound; do not retell the panels. Sound: ambience or speech. No music. Opening, escalation, payoff. Word ceilings, not targets: title ${GOAL_PROMPT_BUDGET.title}, continuity ${GOAL_PROMPT_BUDGET.continuity}, frame ${GOAL_PROMPT_BUDGET.frame}, storyboard 48, ending ${GOAL_PROMPT_BUDGET.ending}, video ${GOAL_PROMPT_BUDGET.video}. Match shot count, seconds and aspect ratio. Portrait default; centre subjects, leave headroom. Nano Banana 2.1, 2K, Seedance 2.5 720p unless specified. One continuous 20-second video by default; create multiple clips only when explicitly requested. frameContinuity false; endingPrompt null. No @tokens, tools, invented assets or continuity promises.`;
+export function goalPlannerInstructions(selection, constraints) {
+    const style = goalStyle(selection.id);
+    if (!style.planner)
+        return cinematicInstructions;
+    const options = resolveGoalStyleOptions(selection.id, selection.options);
+    const beats = style.options.find(option => option.key === "format")?.choices.find(choice => choice.value === options.format)?.beats;
+    return `${cinematicInstructions}\n\n${style.planner} Selected style: ${goalStyleSummary(selection)}.${beats ? ` Content arc: ${beats}; expand to six beats.` : ""} Use ${constraints.aspectRatio} throughout.`;
+}
+export function constrainGoalPlannerPlan(plan, brief, selection) {
+    const constraints = goalBriefConstraints(brief);
+    if (plan.shots.length !== constraints.shotCount)
+        throw new Error("The planner returned a different shot count. Try planning again.");
+    const defaults = goalStyle(selection.id).defaults;
+    const imageModel = /\b(flare|sunburst)\b/iu.exec(brief)?.[1]?.toLowerCase();
+    const imageResolution = /\b(1k|2k)\b/iu.exec(brief)?.[1]?.toUpperCase();
+    const videoResolution = /\b(480p|720p)\b/iu.exec(brief)?.[1]?.toLowerCase();
+    return {
+        ...plan, style: { id: selection.id, options: resolveGoalStyleOptions(selection.id, selection.options) },
+        aspectRatio: constraints.aspectRatio, frameContinuity: false, storyboardLayout: "six-panel",
+        imageModel: imageModel ?? "nano-banana-2-1",
+        imageResolution: imageResolution ?? defaults.imageResolution ?? "2K",
+        videoResolution: videoResolution ?? defaults.videoResolution ?? "720p",
+        shots: plan.shots.map(shot => ({ ...shot, durationSeconds: constraints.durationSeconds, endingPrompt: null })),
+    };
+}

package/dist/goal-prompt-budget.js

@@ -0,0 +1,4 @@
+export const GOAL_PROMPT_BUDGET = { title: 6, continuity: 30, frame: 20, storyboard: 32, ending: 12, video: 12 };
+export function goalPromptWords(value) {
+    return value.trim().split(/\s+/u).filter(Boolean).length;
+}

package/dist/goal-reference-images.js

@@ -0,0 +1,25 @@
+import { findPrimaryMediaFile } from "videobook-engine";
+import { mimeForImageFilename } from "./jobs/describe-image.js";
+export async function goalPlannerImages(engine, references) {
+    return Promise.all(references.map(async (reference, index) => {
+        const manifest = await engine.files.manifest(reference.artifactId);
+        const file = manifest.ok ? findPrimaryMediaFile(manifest.value.files, "image") : null;
+        if (!file)
+            throw new Error(`Reference ${index + 1} has no readable image`);
+        const bytes = await engine.files.read(reference.artifactId, file.name);
+        if (!bytes.ok)
+            throw new Error(bytes.error.message);
+        return [
+            { type: "input_text", text: `Reference ${index + 1}: ${reference.label}` },
+            { type: "input_image", image_url: `data:${mimeForImageFilename(file.name)};base64,${bytes.value.toString("base64")}`, detail: "high" },
+        ];
+    })).then(images => images.flat());
+}
+export async function goalReferenceHashes(engine, artifactIds) {
+    return Promise.all(artifactIds.map(async (artifactId) => {
+        const artifact = engine.artifacts.get(artifactId);
+        const manifest = await engine.files.manifest(artifactId);
+        const file = artifact.ok && manifest.ok ? findPrimaryMediaFile(manifest.value.files, artifact.value.kind) : null;
+        return { artifactId, objectHash: file?.objectHash ?? null };
+    }));
+}

package/dist/goal-state.js

@@ -0,0 +1,261 @@
+import { notebookGridTag } from "videobook-engine/notebook-grid";
+import { cancelChainRun, getChainRun } from "./chain-executor.js";
+import { coldOpenSource } from "./cold-open.js";
+import { emptyGoalEstimates, findGoalCell, goalContent, requireGoalContent, saveGoal, writeGoalContent } from "./goal-store.js";
+import { GOAL_VIDEO_TOOL, refreshGoalPlanV3 } from "./goal-plan.js";
+import { suggestedColdOpen } from "./lightning-defaults.js";
+import { mutateNotebook } from "./notebook-mutations.js";
+import { goalStageAttempts, goalStillStaleReason } from "./goal-stills.js";
+export const LEGACY_GOAL_MESSAGE = "Goal mode now starts from character images. Start a new /goal.";
+export function activeGoalStage(goal) {
+    return goal.stage === "assembly" ? "videos" : goal.stage;
+}
+function outputString(outputs, key) {
+    const value = outputs?.[key];
+    return typeof value === "string" ? value : null;
+}
+function producerCell(document, chainId, step) {
+    const tagged = document.cells.filter(cell => cell.inputs?.chainRunId === `${chainId}:${step.id}`).sort((a, b) => b.id.localeCompare(a.id))[0];
+    const outputId = outputString(step.outputs, "cell_id");
+    const edge = document.edges.find(candidate => candidate.target === outputId && candidate.targetInput === "media");
+    return tagged ?? document.cells.find(cell => cell.id === edge?.source);
+}
+function goalChainSteps(engine, document, chainId) {
+    const chain = chainId ? getChainRun(engine, chainId) : null;
+    return chain?.steps.map(step => {
+        const producer = producerCell(document, chain.chainId, step);
+        return {
+            id: step.id, chainId: chain.chainId, status: step.status, error: step.error,
+            artifactId: outputString(step.outputs, "asset_id") ?? outputString(step.outputs, "img_asset_id") ?? outputString(step.outputs, "vid_asset_id"),
+            cellId: producer?.id ?? null,
+            address: producer ? notebookGridTag(producer.slot) : outputString(step.outputs, "address"),
+            outputCellId: outputString(step.outputs, "cell_id"), startedAt: step.startedAt ?? null,
+        };
+    }) ?? [];
+}
+function stageOutputIndex(stepId) {
+    if (stepId === "frame" || stepId === "scene" || stepId === "video")
+        return 0;
+    return Number(/\d+$/u.exec(stepId)?.[0]) - 1;
+}
+function completedStageOutputs(engine, goal, document) {
+    return goalChainSteps(engine, document, goal.chainId).flatMap(step => {
+        if (step.status !== "completed" || !step.artifactId || step.id === "assemble")
+            return [];
+        const index = stageOutputIndex(step.id);
+        if (!Number.isInteger(index) || index < 0)
+            return [];
+        const cell = document.cells.find(candidate => candidate.id === step.outputCellId);
+        return [{ index, artifactId: step.artifactId, cellId: step.outputCellId, producerCellId: step.cellId, address: cell ? notebookGridTag(cell.slot) : null }];
+    });
+}
+function allGoalChainSteps(engine, document, chainId) {
+    return goalChainSteps(engine, document, chainId).flatMap(step => {
+        const producers = document.cells.filter(cell => cell.inputs?.chainRunId === `${chainId}:${step.id}`);
+        if (producers.length === 0)
+            return [step];
+        return producers.map(producer => {
+            const outputCellId = document.edges.find(edge => edge.source === producer.id && edge.targetInput === "media")?.target ?? null;
+            return { ...step, cellId: producer.id, outputCellId, address: notebookGridTag(producer.slot) };
+        });
+    });
+}
+export async function writeGoalCombinationState(engine, goal, error) {
+    if (!goal.combined)
+        return goal;
+    const updated = await mutateNotebook(engine, goal.notebookId, "goal_combine_complete", document => ({
+        ...document, cells: document.cells.map(cell => cell.id === goal.combined?.cellId ? { ...cell, inputs: { ...cell.inputs, state: error ? "error" : "completed" } } : cell),
+    }));
+    if (!updated.ok)
+        throw new Error(updated.error.message);
+    return saveGoal(engine, { ...goal, combined: { ...goal.combined, status: error ? "failed" : "completed", error } });
+}
+export function reconcileFinish(engine, goal) {
+    const finish = goal.finish;
+    if (goal.planVersion !== 3 || !finish || finish.status !== "running")
+        return goal;
+    const job = finish.jobId ? engine.jobs.queue.get(finish.jobId) : null;
+    if (job && ["queued", "running", "completing"].includes(job.state))
+        return goal;
+    if (job?.state === "done") {
+        const result = job.result && typeof job.result === "object" ? job.result : null;
+        const finalArtifactId = finish.finalArtifactId ?? (typeof result?.finalArtifactId === "string" && result.finalArtifactId ? result.finalArtifactId : null);
+        if (finalArtifactId && engine.artifacts.get(finalArtifactId).ok) {
+            const coldOpenArtifactId = finish.coldOpenArtifactId ?? (typeof result?.coldOpenArtifactId === "string" ? result.coldOpenArtifactId : null);
+            return saveGoal(engine, { ...goal, status: "completed", error: null, finish: { ...finish, status: "completed", finalArtifactId, coldOpenArtifactId, error: null } });
+        }
+    }
+    return saveGoal(engine, { ...goal, status: "review", finish: { ...finish, status: "failed", error: job?.error?.message ?? "Finishing was interrupted. Retry the cold open." } });
+}
+async function coldOpenReview(engine, goal) {
+    if (goal.planVersion !== 3 || !goal.finish?.sourceArtifactId)
+        return null;
+    try {
+        const source = await coldOpenSource(engine, goal.finish.sourceArtifactId, goal.finish.sourceObjectHash ?? undefined);
+        const approved = goal.finish.status !== "review" && goal.finish.startSeconds != null && goal.finish.endSeconds != null;
+        const range = approved
+            ? { startSeconds: goal.finish.startSeconds, endSeconds: goal.finish.endSeconds }
+            : suggestedColdOpen(source.durationSeconds);
+        return { ...range, durationSeconds: source.durationSeconds, sourceObjectHash: source.file.objectHash, analysisUsd: 0 };
+    }
+    catch {
+        return null;
+    }
+}
+export async function reconcileGoal(engine, goal, document) {
+    if (goal.planVersion === 1) {
+        if (!["planning", "review", "running"].includes(goal.status))
+            return goal;
+        if (goal.chainId)
+            cancelChainRun(engine, goal.chainId);
+        if (goal.planningJobId)
+            await engine.jobs.queue.abort(goal.planningJobId, LEGACY_GOAL_MESSAGE);
+        return saveGoal(engine, { ...goal, status: "failed", error: LEGACY_GOAL_MESSAGE });
+    }
+    if (goal.combined?.status === "running") {
+        const job = goal.combined.jobId ? engine.jobs.queue.get(goal.combined.jobId) : null;
+        if (!job || ["failed", "aborted"].includes(job.state))
+            goal = await writeGoalCombinationState(engine, goal, job?.error?.message ?? "Combining was interrupted. Retry the combined video.");
+    }
+    if (["completed", "cancelled", "review"].includes(goal.status))
+        return goal;
+    if (goal.status === "planning") {
+        const job = goal.planningJobId ? engine.jobs.queue.get(goal.planningJobId) : null;
+        return job && ["failed", "aborted"].includes(job.state)
+            ? saveGoal(engine, { ...goal, status: "failed", error: job.error?.message ?? "Planning was interrupted" }) : goal;
+    }
+    const stage = activeGoalStage(goal);
+    const run = goal.stages[stage];
+    const chain = run ? getChainRun(engine, run.chainId) : null;
+    if (!run || !chain)
+        return goal;
+    const merged = new Map(run.outputs.map(output => [output.index, output]));
+    for (const output of completedStageOutputs(engine, goal, document))
+        merged.set(output.index, output);
+    const outputs = [...merged.values()].sort((a, b) => a.index - b.index);
+    const attempts = run.attempts?.map(attempt => {
+        if (attempt.artifactId)
+            return attempt;
+        const step = goalChainSteps(engine, document, attempt.chainId).find(candidate => candidate.id === attempt.stepId);
+        return step?.status === "completed" && step.artifactId ? { ...attempt, artifactId: step.artifactId, cellId: step.outputCellId } : attempt;
+    });
+    let next = { ...goal, stages: { ...goal.stages, [stage]: { ...run, outputs, ...(attempts ? { attempts } : {}) } } };
+    const assembled = stage === "videos" && goal.assembly?.artifactIds && JSON.stringify(goal.assembly.artifactIds) === JSON.stringify(outputs.map(output => output.artifactId));
+    if (chain.status === "completed" || assembled && !goal.resumeStage) {
+        const content = requireGoalContent(engine, goal);
+        if (goal.planVersion === 3) {
+            const cleared = { resumeStage: null, resumeStatus: null, resumeOutputs: null, resumeFinish: null };
+            if (outputs.length !== 1)
+                next = { ...next, status: "failed", error: "The stage finished without all of its media outputs. Retry the stage.", ...cleared };
+            else if (stage === "videos") {
+                next = {
+                    ...next, status: "review", error: null, ...cleared,
+                    finish: { status: "review", sourceArtifactId: outputs[0].artifactId, finalArtifactId: null, error: null },
+                };
+            }
+            else {
+                const previousScene = run.outputs[0]?.artifactId ?? null;
+                await writeGoalContent(engine, goal, { ...content, revision: content.revision + 1 });
+                const sceneChanged = previousScene !== null && previousScene !== outputs[0].artifactId;
+                const finish = sceneChanged ? null : goal.finish ?? goal.resumeFinish ?? null;
+                const keepCompleted = finish?.status === "completed" && Boolean(finish.finalArtifactId);
+                next = {
+                    ...next, stage: goal.resumeStage ?? "videos", status: keepCompleted ? "completed" : "review", error: null, ...cleared,
+                    finish,
+                };
+            }
+        }
+        else {
+            const stagedPlan = content.plan && "shots" in content.plan ? content.plan : null;
+            const shotCount = stagedPlan?.shots.length ?? 0;
+            const expected = stage === "frame" ? 1 : stage === "storyboards" && stagedPlan && "frameContinuity" in stagedPlan && stagedPlan.frameContinuity ? 2 * shotCount : shotCount;
+            if (outputs.length !== expected)
+                next = { ...next, status: "failed", error: "The stage finished without all of its media outputs. Retry the stage." };
+            else if (stage === "videos") {
+                next = { ...next, status: goal.assembly || expected === 1 || goal.resumeStage ? "completed" : "failed", error: goal.assembly || expected === 1 || goal.resumeStage ? null : "The finished clips still need to be assembled" };
+                if (goal.combined && JSON.stringify(run.outputs.map(output => output.artifactId)) !== JSON.stringify(outputs.map(output => output.artifactId)))
+                    next.combined = { ...goal.combined, status: "failed", error: "Video selection changed. Assemble the selected clips before combining again." };
+            }
+            else {
+                await writeGoalContent(engine, goal, { ...content, revision: content.revision + 1 });
+                next = { ...next, stage: goal.resumeStage ?? (stage === "frame" ? "storyboards" : "videos"), status: goal.resumeStatus ?? "review", error: null };
+            }
+            next = { ...next, resumeStage: null, resumeStatus: null, resumeOutputs: null };
+        }
+    }
+    else if (["failed", "interrupted", "cancelled"].includes(chain.status)) {
+        next = { ...next, status: chain.status, error: chain.error,
+            ...(goal.resumeOutputs ? { stages: { ...next.stages, [stage]: { ...next.stages[stage], outputs: goal.resumeOutputs } } } : {}),
+        };
+    }
+    else {
+        next = { ...next, stage: chain.steps.some(step => step.id === "assemble" && step.status === "running") ? "assembly" : stage, status: "running", error: null };
+    }
+    return JSON.stringify(next) === JSON.stringify(goal) ? goal : saveGoal(engine, next);
+}
+export async function publicGoal(engine, goal, document) {
+    const cell = findGoalCell(document, goal);
+    const content = cell ? goalContent(cell) : { brief: "", characters: [], revision: 0, plan: null, estimate: emptyGoalEstimates() };
+    const stages = Object.fromEntries(await Promise.all(Object.entries(goal.stages).map(async ([stage, run]) => [stage, {
+            ...run,
+            ...(stage === "videos" ? { attempts: goalStageAttempts(engine, goal, "videos") } : {}),
+            outputs: await Promise.all(run.outputs.map(async (output) => {
+                const outputCell = document.cells.find(candidate => candidate.id === output.cellId);
+                const versions = goalStageAttempts(engine, goal, stage).filter(attempt => attempt.index === output.index).slice().reverse().map(attempt => {
+                    const versionCell = document.cells.find(candidate => candidate.id === attempt.cellId);
+                    const step = getChainRun(engine, attempt.chainId)?.steps.find(candidate => candidate.id === attempt.stepId);
+                    return {
+                        ...attempt, address: versionCell ? notebookGridTag(versionCell.slot) : null,
+                        status: step?.status ?? "interrupted", current: attempt.artifactId === output.artifactId,
+                    };
+                });
+                const stagedPlan = content.plan && "version" in content.plan && content.plan.version === 2 ? content.plan : null;
+                const stale = stagedPlan && (stage === "frame" || stage === "storyboards" || stage === "videos")
+                    ? await goalStillStaleReason(engine, goal, document, stagedPlan, content.characters, stage, output) : null;
+                return { ...output, address: outputCell ? notebookGridTag(outputCell.slot) : null, versions, stale };
+            })),
+            steps: goalChainSteps(engine, document, run.chainId),
+            allSteps: [...run.previousChainIds, run.chainId].flatMap(chainId => allGoalChainSteps(engine, document, chainId)),
+        }])));
+    const shotPlan = content.plan && "shots" in content.plan ? content.plan : null;
+    const stillCount = shotPlan ? shotPlan.shots.length * ("frameContinuity" in shotPlan && shotPlan.frameContinuity ? 2 : 1) : 1;
+    const displayedPlan = content.plan && "version" in content.plan && content.plan.version === 3 ? refreshGoalPlanV3(content.plan, document) : content.plan;
+    const v3Plan = displayedPlan && "version" in displayedPlan && displayedPlan.version === 3;
+    const still = v3Plan
+        ? goal.stage === "videos" || goal.stage === "assembly" ? content.estimate.videos : content.estimate.frame
+        : goal.stage === "videos"
+            ? { ...content.estimate.storyboards, usd: content.estimate.storyboards.usd === null ? null : content.estimate.storyboards.usd / stillCount }
+            : content.estimate.frame;
+    return {
+        kind: "video-goal", ...goal, ...content, plan: displayedPlan,
+        finish: goal.finish ?? null,
+        finalArtifactId: goal.finish?.finalArtifactId ?? null,
+        coldOpen: await coldOpenReview(engine, goal),
+        estimate: { ...content.estimate, still },
+        address: cell ? notebookGridTag(cell.slot) : null,
+        assemblyStale: goalAssemblyStale(engine, goal),
+        stages: stages,
+        steps: goalChainSteps(engine, document, goal.chainId),
+    };
+}
+export function goalAssemblyStale(engine, goal) {
+    if (!goal.assembly)
+        return false;
+    const clips = engine.sequences.getPrimary().clips;
+    const sources = goal.assembly.artifactIds ?? goal.clipIds.map(id => clips.find(clip => clip.clipId === id)?.source.artifactId ?? null);
+    return JSON.stringify(sources) !== JSON.stringify(completedGoalVideos(engine, goal));
+}
+export function completedGoalVideos(engine, goal) {
+    const run = goal.stages.videos;
+    const selected = new Map((run?.outputs ?? []).map(output => [output.index, output.artifactId]));
+    const chainId = run?.chainId ?? (goal.planVersion === 1 ? goal.chainId : null);
+    if (goal.status === "running" || selected.size === 0) {
+        for (const step of chainId ? getChainRun(engine, chainId)?.steps ?? [] : []) {
+            const id = outputString(step.outputs, "asset_id") ?? outputString(step.outputs, "vid_asset_id");
+            const index = stageOutputIndex(step.id);
+            if (step.tool === GOAL_VIDEO_TOOL && step.status === "completed" && id && Number.isInteger(index) && index >= 0)
+                selected.set(index, id);
+        }
+    }
+    return [...selected.entries()].sort(([left], [right]) => left - right).map(([, id]) => id);
+}