videoclaw 3.0.0-alpha.1

package/dist/video/execution-status.js

@@ -0,0 +1,666 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { artifactPathFor, writeArtifact } from './artifact-store.js';
+import { writeStageCheckpoint } from './checkpoints.js';
+import { appendProjectEvent } from './events.js';
+import { appendGenerationTelemetry, buildGenerationTelemetryFromPoll, } from './generation-telemetry.js';
+import { pollExecutionPayload } from './execution-runtime.js';
+import { deriveAssetManifestFromSelection } from './scene-candidates.js';
+import { readSceneCandidatesArtifact, sceneCandidatesPathFor, writeSceneCandidatesArtifact, } from './scene-candidate-store.js';
+import { markPending } from './scene-selection.js';
+import { readSceneSelectionArtifact, writeSceneSelectionArtifact, } from './scene-selection-store.js';
+import { buildProjectStatusReport } from './status.js';
+import { ensureProjectWorkspace, readProjectManifest, resolveProjectWorkspace, updateProjectManifestState } from './workspace.js';
+function mergeAssets(existing, incoming) {
+    const byId = new Map(existing.map((asset) => [asset.id, asset]));
+    for (const asset of incoming) {
+        byId.set(asset.id, asset);
+    }
+    return [...byId.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+/**
+ * Ids of candidate-derived OUTPUT assets are `${candidate.id}-output-${n}`
+ * (see `deriveAssetManifestFromSelection`). Operator/keyframe INPUT assets use
+ * `${kind}-${path}` ids (see `parseAssetSpec` in `asset-spec.ts`), so this
+ * pattern never matches an input keyframe.
+ */
+const DERIVED_OUTPUT_ID_RE = /-output-\d+$/;
+/**
+ * Candidate-mode `execute-status` re-derives the asset-manifest from the
+ * SELECTED candidate outputs. Before any winner is selected the derived
+ * manifest is empty, so a naive overwrite DELETES the per-scene INPUT image
+ * keyframes that `buildExecutionPayload` needs to keep pending scenes on the
+ * image-to-video path (no keyframe → text-to-video → fresh character every
+ * scene). This preserves the existing manifest's INPUT assets (operator
+ * image keyframe / audio / video reference assets whose ids are NOT candidate
+ * outputs) and merges them under the freshly-derived outputs — the same
+ * merge-preserve shape the
+ * non-candidate branch already uses via `mergeAssets`. Derived outputs win on
+ * id collision; the two id namespaces never collide so both survive.
+ */
+async function preserveInputKeyframes(workspace, derived) {
+    const manifestPath = artifactPathFor(workspace, 'asset-manifest');
+    if (!existsSync(manifestPath))
+        return derived;
+    let existing = [];
+    try {
+        const parsed = JSON.parse(await readFile(manifestPath, 'utf-8'));
+        existing = Array.isArray(parsed.assets) ? parsed.assets : [];
+    }
+    catch {
+        return derived;
+    }
+    // Preserve EVERY operator INPUT asset (image keyframe, audio, or video/V2V
+    // reference) — i.e. any asset whose id is NOT a candidate-derived output.
+    // Narrowing to image/audio would re-introduce the same wipe bug for input
+    // `video:` references on the first pre-selection poll; the `-output-` id
+    // guard alone cleanly separates inputs from derived outputs.
+    const inputs = existing.filter((asset) => !DERIVED_OUTPUT_ID_RE.test(asset.id));
+    if (inputs.length === 0)
+        return derived;
+    return { projectSlug: derived.projectSlug, assets: mergeAssets(inputs, derived.assets) };
+}
+/** Immutably replace one candidate within the candidates artifact. */
+function updateCandidate(artifact, sceneIndex, candidateId, fn) {
+    return {
+        ...artifact,
+        scenes: artifact.scenes.map((scene) => scene.sceneIndex !== sceneIndex
+            ? scene
+            : { ...scene, candidates: scene.candidates.map((c) => (c.id === candidateId ? fn(c) : c)) }),
+    };
+}
+/**
+ * Per-scene candidate poll — the auto-chain / per-scene-submit safety net.
+ *
+ * The single `execution-report` records only the LAST submission's job, but in
+ * candidate mode each scene carries its OWN adapter job id on
+ * `candidate.source.externalJobId`. When the latest report is blocked / job-less
+ * (e.g. a later scene failed to submit and overwrote the report), the legacy
+ * single-job poll bails with `execution-already-blocked` and strands earlier
+ * scenes' in-flight jobs. This polls every still-`pending` candidate that has its
+ * own job id, promotes each independently, and re-derives the asset-manifest — so
+ * one blocked scene never hides the rest of the chain's progress.
+ *
+ * Returns the full refresh result, or `null` when there is no candidate artifact
+ * or no pending candidate carries a job id (the caller then keeps the legacy
+ * blocked-report behavior — preserving today's output for non-candidate runs).
+ */
+async function pollPendingSceneCandidates(args) {
+    const { workspace, root, projectSlug, baseReport } = args;
+    if (!existsSync(sceneCandidatesPathFor(root, projectSlug)))
+        return null;
+    const candidates = await readSceneCandidatesArtifact(root, projectSlug);
+    let selection = await readSceneSelectionArtifact(root, projectSlug);
+    const pending = [];
+    for (const scene of candidates.scenes) {
+        for (const candidate of scene.candidates) {
+            if (candidate.status === 'pending' && candidate.source.externalJobId) {
+                pending.push({ sceneIndex: scene.sceneIndex, candidate });
+            }
+        }
+    }
+    if (pending.length === 0)
+        return null;
+    const lastCheckedAt = new Date().toISOString();
+    const outputDir = `${workspace.projectDir}/outputs`;
+    let updatedCandidates = candidates;
+    const allOutputs = [];
+    const issues = [];
+    let completed = 0;
+    let failed = 0;
+    let stillPending = 0;
+    let lastJobId = null;
+    for (const { sceneIndex, candidate } of pending) {
+        const jobId = candidate.source.externalJobId;
+        lastJobId = jobId;
+        let poll;
+        try {
+            poll = await pollExecutionPayload({
+                projectSlug,
+                routeId: candidate.route,
+                externalJobId: jobId,
+                outputDir,
+                workspaceRoot: workspace.root,
+            }, { env: args.env });
+        }
+        catch (error) {
+            issues.push(`scene ${sceneIndex} (${candidate.id}): poll failed — ${error.message}`);
+            stillPending += 1;
+            continue;
+        }
+        allOutputs.push(...poll.outputs);
+        if (poll.issues.length)
+            issues.push(...poll.issues.map((issue) => `scene ${sceneIndex}: ${issue}`));
+        const completedWithoutOutputs = poll.status === 'completed' && poll.outputs.length === 0;
+        if (poll.status === 'completed' && !completedWithoutOutputs) {
+            const sceneOutputs = [];
+            for (const out of poll.outputs) {
+                if (out.kind !== 'image' && out.kind !== 'video' && out.kind !== 'audio')
+                    continue;
+                // Honor a per-output scene tag; untagged outputs attach to this job's scene.
+                if (typeof out.sceneIndex === 'number' && out.sceneIndex !== sceneIndex)
+                    continue;
+                sceneOutputs.push({ kind: out.kind, path: out.path });
+            }
+            updatedCandidates = updateCandidate(updatedCandidates, sceneIndex, candidate.id, (prev) => ({
+                ...prev,
+                status: 'completed',
+                completedAt: lastCheckedAt,
+                outputs: sceneOutputs.length > 0 ? sceneOutputs : prev.outputs,
+            }));
+            selection = markPending(selection, sceneIndex, [candidate.id]);
+            completed += 1;
+        }
+        else if (poll.status === 'failed' || completedWithoutOutputs) {
+            if (completedWithoutOutputs) {
+                issues.push(`scene ${sceneIndex}: completed but provider returned no outputs to ingest.`);
+            }
+            updatedCandidates = updateCandidate(updatedCandidates, sceneIndex, candidate.id, (prev) => ({
+                ...prev,
+                status: 'failed',
+                completedAt: lastCheckedAt,
+            }));
+            failed += 1;
+        }
+        else {
+            stillPending += 1;
+        }
+    }
+    await writeSceneCandidatesArtifact(root, projectSlug, updatedCandidates);
+    await writeSceneSelectionArtifact(root, projectSlug, selection);
+    const derived = deriveAssetManifestFromSelection(projectSlug, updatedCandidates, selection);
+    const merged = await preserveInputKeyframes(workspace, derived);
+    const assetManifestPath = await writeArtifact(workspace, 'asset-manifest', merged);
+    // Aggregate: still-pending dominates (keep polling); else completed if any
+    // scene finished; else everything we polled failed.
+    const status = stillPending > 0 ? 'pending' : completed > 0 ? 'completed' : 'failed';
+    const rawResult = {
+        reason: 'per-scene-candidate-poll',
+        polled: pending.length,
+        completed,
+        failed,
+        stillPending,
+    };
+    const poll = {
+        status,
+        externalJobId: lastJobId,
+        outputs: allOutputs,
+        issues,
+        rawResult,
+    };
+    const reportPath = artifactPathFor(workspace, 'execution-report');
+    const updatedReport = {
+        ...baseReport,
+        poll: {
+            lastCheckedAt,
+            status,
+            issues,
+            ...(status === 'completed' ? { outputsIngested: allOutputs.length } : {}),
+            rawResult,
+        },
+    };
+    if (status === 'completed') {
+        await writeStageCheckpoint(workspace, {
+            stage: 'assets',
+            status: 'completed',
+            generatedAt: lastCheckedAt,
+            artifacts: { 'asset-manifest': assetManifestPath, 'execution-report': reportPath },
+            summary: 'Pending per-scene candidate jobs completed and outputs were ingested.',
+            issues: [],
+            nextAction: 'Run review on the generated outputs.',
+        });
+        await updateProjectManifestState(workspace, {
+            updatedAt: lastCheckedAt,
+            currentStage: 'review',
+            lastCompletedStage: 'assets',
+            lastCheckpointStatus: 'completed',
+        });
+    }
+    else if (status === 'failed') {
+        await writeStageCheckpoint(workspace, {
+            stage: 'assets',
+            status: 'failed',
+            generatedAt: lastCheckedAt,
+            artifacts: { 'execution-report': reportPath },
+            summary: 'Pending per-scene candidate jobs failed.',
+            issues,
+            nextAction: 'Resolve provider issues and resubmit the affected scenes.',
+        });
+        await updateProjectManifestState(workspace, {
+            updatedAt: lastCheckedAt,
+            currentStage: 'assets',
+            lastCompletedStage: 'storyboard',
+            lastCheckpointStatus: 'failed',
+        });
+    }
+    else {
+        await writeStageCheckpoint(workspace, {
+            stage: 'assets',
+            status: 'pending',
+            generatedAt: lastCheckedAt,
+            artifacts: { 'execution-report': reportPath },
+            summary: 'Per-scene candidate jobs are still pending.',
+            issues,
+            nextAction: 'Poll execution status again later.',
+        });
+        await updateProjectManifestState(workspace, {
+            updatedAt: lastCheckedAt,
+            currentStage: 'assets',
+            lastCompletedStage: 'storyboard',
+            lastCheckpointStatus: 'pending',
+        });
+    }
+    await writeArtifact(workspace, 'execution-report', updatedReport);
+    await appendProjectEvent(workspace, {
+        type: 'execution.status.refreshed',
+        recordedAt: lastCheckedAt,
+        payload: {
+            reportPath,
+            status,
+            externalJobId: lastJobId,
+            outputsIngested: allOutputs.length,
+        },
+    });
+    await appendGenerationTelemetry(workspace, buildGenerationTelemetryFromPoll({
+        report: updatedReport,
+        poll,
+        recordedAt: lastCheckedAt,
+    }));
+    return { reportPath, report: updatedReport, poll, assetManifestPath };
+}
+export async function refreshExecutionStatus(projectSlug, options = {}) {
+    const root = options.root ?? process.cwd();
+    const resolvedWorkspace = resolveProjectWorkspace(projectSlug, root);
+    const projectManifest = await readProjectManifest(resolvedWorkspace);
+    if (!projectManifest) {
+        const now = new Date().toISOString();
+        const reportPath = artifactPathFor(resolvedWorkspace, 'execution-report');
+        const issues = [
+            `Execution status unavailable for ${projectSlug}: project manifest is missing. Run \`vclaw video init ${projectSlug}\` first.`,
+        ];
+        const poll = {
+            status: 'failed',
+            externalJobId: null,
+            outputs: [],
+            issues,
+            rawResult: {
+                reason: 'missing-project-manifest',
+            },
+        };
+        const report = {
+            projectSlug,
+            productionMode: options.productionMode ?? 'storyboard',
+            operationKind: 'text-to-video',
+            routeId: null,
+            status: 'blocked',
+            dryRun: false,
+            generatedAt: now,
+            blockers: issues,
+            executedSteps: ['execution-status-requested'],
+            taskCount: 0,
+            poll: {
+                lastCheckedAt: now,
+                status: 'failed',
+                issues,
+                rawResult: poll.rawResult,
+            },
+        };
+        return {
+            reportPath,
+            report,
+            poll,
+        };
+    }
+    const workspace = await ensureProjectWorkspace(projectSlug, root);
+    const status = await buildProjectStatusReport(projectSlug, root, options.productionMode ?? 'storyboard');
+    if (status.productionMode === 'director' && status.storyboardReviewStale) {
+        throw new Error(`Execution status unavailable for ${projectSlug}: storyboard review is stale. Refresh ${status.storyboardReviewPath ?? 'storyboard.md'} before continuing.`);
+    }
+    const reportPath = artifactPathFor(workspace, 'execution-report');
+    if (!existsSync(reportPath)) {
+        const lastCheckedAt = new Date().toISOString();
+        const issues = ['Execution status unavailable: execution-report artifact is missing. Run execution first.'];
+        const poll = {
+            status: 'failed',
+            externalJobId: null,
+            outputs: [],
+            issues,
+            rawResult: {
+                reason: 'missing-execution-report',
+            },
+        };
+        const updatedReport = {
+            projectSlug,
+            productionMode: status.productionMode,
+            operationKind: 'text-to-video',
+            routeId: null,
+            status: 'blocked',
+            dryRun: false,
+            generatedAt: lastCheckedAt,
+            blockers: issues,
+            executedSteps: ['execution-status-requested'],
+            taskCount: 0,
+            poll: {
+                lastCheckedAt,
+                status: 'failed',
+                issues,
+                rawResult: poll.rawResult,
+            },
+        };
+        await writeStageCheckpoint(workspace, {
+            stage: 'assets',
+            status: 'failed',
+            generatedAt: lastCheckedAt,
+            artifacts: {
+                'execution-report': reportPath,
+            },
+            summary: 'Execution status refresh failed.',
+            issues,
+            nextAction: 'Run execution before polling execution status.',
+        });
+        await updateProjectManifestState(workspace, {
+            updatedAt: lastCheckedAt,
+            currentStage: 'assets',
+            lastCompletedStage: 'storyboard',
+            lastCheckpointStatus: 'failed',
+        });
+        await writeArtifact(workspace, 'execution-report', updatedReport);
+        await appendProjectEvent(workspace, {
+            type: 'execution.status.refreshed',
+            recordedAt: lastCheckedAt,
+            payload: {
+                reportPath,
+                status: 'failed',
+                externalJobId: null,
+                outputsIngested: 0,
+            },
+        });
+        return {
+            reportPath,
+            report: updatedReport,
+            poll,
+        };
+    }
+    const report = JSON.parse(await readFile(reportPath, 'utf-8'));
+    if (!report.routeId || !report.submission?.externalJobId) {
+        // The latest report has no pollable job of its own. Before bailing, poll any
+        // still-pending per-scene candidate jobs (auto-chain / per-scene submits each
+        // carry their own job id) so one blocked scene doesn't strand the rest of the
+        // chain. No candidate artifact / no pending job → null → legacy bail below.
+        const candidateResult = await pollPendingSceneCandidates({
+            workspace,
+            root,
+            projectSlug,
+            baseReport: report,
+            env: options.env,
+        });
+        if (candidateResult)
+            return candidateResult;
+        const lastCheckedAt = new Date().toISOString();
+        const reportHasBlockers = Array.isArray(report.blockers) && report.blockers.length > 0;
+        const issues = reportHasBlockers
+            ? [...report.blockers]
+            : !report.routeId
+                ? ['Execution status unavailable: last execution report has no provider route id.']
+                : ['Execution status unavailable: last execution report has no live adapter job id.'];
+        const reason = reportHasBlockers
+            ? 'execution-already-blocked'
+            : !report.routeId
+                ? 'missing-provider-route-id'
+                : 'missing-live-adapter-job-id';
+        const nextAction = reportHasBlockers
+            ? 'Resolve execution blockers and rerun execution.'
+            : 'Rerun execution to create a live adapter job id before polling status.';
+        const poll = {
+            status: 'failed',
+            externalJobId: null,
+            outputs: [],
+            issues,
+            rawResult: {
+                reason,
+            },
+        };
+        const updatedReport = {
+            ...report,
+            poll: {
+                lastCheckedAt,
+                status: 'failed',
+                issues,
+                rawResult: poll.rawResult,
+            },
+        };
+        await writeStageCheckpoint(workspace, {
+            stage: 'assets',
+            status: 'failed',
+            generatedAt: lastCheckedAt,
+            artifacts: {
+                'execution-report': reportPath,
+            },
+            summary: 'Execution status refresh failed.',
+            issues,
+            nextAction,
+        });
+        await updateProjectManifestState(workspace, {
+            updatedAt: lastCheckedAt,
+            currentStage: 'assets',
+            lastCompletedStage: 'storyboard',
+            lastCheckpointStatus: 'failed',
+        });
+        await writeArtifact(workspace, 'execution-report', updatedReport);
+        await appendProjectEvent(workspace, {
+            type: 'execution.status.refreshed',
+            recordedAt: lastCheckedAt,
+            payload: {
+                reportPath,
+                status: 'failed',
+                externalJobId: null,
+                outputsIngested: 0,
+            },
+        });
+        return {
+            reportPath,
+            report: updatedReport,
+            poll,
+        };
+    }
+    const poll = await pollExecutionPayload({
+        projectSlug,
+        routeId: report.routeId,
+        externalJobId: report.submission.externalJobId,
+        outputDir: `${workspace.projectDir}/outputs`,
+        workspaceRoot: workspace.root,
+    }, {
+        env: options.env,
+    });
+    const completedWithoutOutputs = poll.status === 'completed' && poll.outputs.length === 0;
+    const normalizedPollStatus = completedWithoutOutputs ? 'failed' : poll.status;
+    const normalizedIssues = completedWithoutOutputs
+        ? [...poll.issues, 'Execution completed but provider returned no outputs to ingest.']
+        : poll.issues;
+    const pollMetadata = {
+        lastCheckedAt: new Date().toISOString(),
+        status: normalizedPollStatus,
+        issues: normalizedIssues,
+        ...(normalizedPollStatus === 'completed' ? { outputsIngested: poll.outputs.length } : {}),
+        rawResult: poll.rawResult,
+    };
+    const updatedReport = {
+        ...report,
+        poll: pollMetadata,
+    };
+    const lastCheckedAt = pollMetadata.lastCheckedAt;
+    // Candidate-mode detection mirrors executeProject: if a candidate artifact
+    // exists, or the last report carries `candidatesByScene`, treat this poll as
+    // a candidate-mode poll and route output ingestion through the candidate
+    // store. Otherwise we keep the legacy direct-asset-manifest behavior.
+    const candidateMode = existsSync(sceneCandidatesPathFor(root, projectSlug))
+        || Array.isArray(report.candidatesByScene);
+    let assetManifestPath;
+    if (normalizedPollStatus === 'completed') {
+        if (candidateMode) {
+            // Candidate path — update per-scene candidates, append to
+            // pendingCandidateIds, then re-derive asset-manifest from selection.
+            const candidates = await readSceneCandidatesArtifact(root, projectSlug);
+            const selection = await readSceneSelectionArtifact(root, projectSlug);
+            // Group poll outputs by sceneIndex. Outputs without a sceneIndex are
+            // attached to every candidate we created for this run (preserves the
+            // legacy fallback when adapters don't tag outputs).
+            const outputsByScene = new Map();
+            const untaggedOutputs = [];
+            for (const out of poll.outputs) {
+                const kind = out.kind === 'image' || out.kind === 'video' || out.kind === 'audio'
+                    ? out.kind
+                    : null;
+                if (!kind)
+                    continue;
+                const candidateOutput = { kind, path: out.path };
+                if (typeof out.sceneIndex === 'number') {
+                    const existing = outputsByScene.get(out.sceneIndex) ?? [];
+                    existing.push(candidateOutput);
+                    outputsByScene.set(out.sceneIndex, existing);
+                }
+                else {
+                    untaggedOutputs.push(candidateOutput);
+                }
+            }
+            const candidateIdsByScene = new Map();
+            for (const entry of report.candidatesByScene ?? []) {
+                candidateIdsByScene.set(entry.sceneIndex, entry.candidateId);
+            }
+            let updatedCandidates = candidates;
+            let updatedSelection = selection;
+            for (const [sceneIndex, candidateId] of candidateIdsByScene) {
+                const sceneOutputs = [
+                    ...(outputsByScene.get(sceneIndex) ?? []),
+                    ...untaggedOutputs,
+                ];
+                const sceneIdx = updatedCandidates.scenes.findIndex((s) => s.sceneIndex === sceneIndex);
+                if (sceneIdx === -1)
+                    continue;
+                const candIdx = updatedCandidates.scenes[sceneIdx].candidates.findIndex((c) => c.id === candidateId);
+                if (candIdx === -1)
+                    continue;
+                const prev = updatedCandidates.scenes[sceneIdx].candidates[candIdx];
+                const next = {
+                    ...prev,
+                    status: 'completed',
+                    completedAt: lastCheckedAt,
+                    outputs: sceneOutputs.length > 0 ? sceneOutputs : prev.outputs,
+                };
+                const nextCandidates = [...updatedCandidates.scenes[sceneIdx].candidates];
+                nextCandidates[candIdx] = next;
+                const nextScenes = [...updatedCandidates.scenes];
+                nextScenes[sceneIdx] = {
+                    ...updatedCandidates.scenes[sceneIdx],
+                    candidates: nextCandidates,
+                };
+                updatedCandidates = { ...updatedCandidates, scenes: nextScenes };
+                updatedSelection = markPending(updatedSelection, sceneIndex, [candidateId]);
+            }
+            await writeSceneCandidatesArtifact(root, projectSlug, updatedCandidates);
+            await writeSceneSelectionArtifact(root, projectSlug, updatedSelection);
+            // Derive asset-manifest from selection so the legacy review/publish
+            // readers keep seeing a coherent manifest. Before any operator has
+            // selected a winner the derived `assets` is empty, so preserve the
+            // existing manifest's INPUT image/audio keyframes (merge-preserve) —
+            // otherwise the first post-`produce` poll would wipe the per-scene
+            // keyframes that keep pending scenes on the image-to-video path.
+            const derived = deriveAssetManifestFromSelection(projectSlug, updatedCandidates, updatedSelection);
+            const merged = await preserveInputKeyframes(workspace, derived);
+            assetManifestPath = await writeArtifact(workspace, 'asset-manifest', merged);
+        }
+        else {
+            const existingAssetManifest = existsSync(artifactPathFor(workspace, 'asset-manifest'))
+                ? JSON.parse(await readFile(artifactPathFor(workspace, 'asset-manifest'), 'utf-8'))
+                : { projectSlug, assets: [] };
+            const nextAssetManifest = {
+                projectSlug,
+                assets: mergeAssets(existingAssetManifest.assets ?? [], poll.outputs),
+            };
+            assetManifestPath = await writeArtifact(workspace, 'asset-manifest', nextAssetManifest);
+        }
+        await writeStageCheckpoint(workspace, {
+            stage: 'assets',
+            status: 'completed',
+            generatedAt: lastCheckedAt,
+            artifacts: {
+                'asset-manifest': assetManifestPath,
+                'execution-report': reportPath,
+            },
+            summary: 'Live execution completed and outputs were ingested.',
+            issues: [],
+            nextAction: 'Run review on the generated outputs.',
+        });
+        await updateProjectManifestState(workspace, {
+            updatedAt: lastCheckedAt,
+            currentStage: 'review',
+            lastCompletedStage: 'assets',
+            lastCheckpointStatus: 'completed',
+        });
+    }
+    else if (normalizedPollStatus === 'failed') {
+        await writeStageCheckpoint(workspace, {
+            stage: 'assets',
+            status: 'failed',
+            generatedAt: lastCheckedAt,
+            artifacts: {
+                'execution-report': reportPath,
+            },
+            summary: 'Live execution failed.',
+            issues: normalizedIssues,
+            nextAction: 'Resolve provider issues and resubmit execution.',
+        });
+        await updateProjectManifestState(workspace, {
+            updatedAt: lastCheckedAt,
+            currentStage: 'assets',
+            lastCompletedStage: 'storyboard',
+            lastCheckpointStatus: 'failed',
+        });
+    }
+    else {
+        await writeStageCheckpoint(workspace, {
+            stage: 'assets',
+            status: 'pending',
+            generatedAt: lastCheckedAt,
+            artifacts: {
+                'execution-report': reportPath,
+            },
+            summary: 'Live execution is still pending.',
+            issues: normalizedIssues,
+            nextAction: 'Poll execution status again later.',
+        });
+        await updateProjectManifestState(workspace, {
+            updatedAt: lastCheckedAt,
+            currentStage: 'assets',
+            lastCompletedStage: 'storyboard',
+            lastCheckpointStatus: 'pending',
+        });
+    }
+    await writeArtifact(workspace, 'execution-report', updatedReport);
+    await appendProjectEvent(workspace, {
+        type: 'execution.status.refreshed',
+        recordedAt: lastCheckedAt,
+        payload: {
+            reportPath,
+            status: normalizedPollStatus,
+            externalJobId: poll.externalJobId,
+            outputsIngested: poll.outputs.length,
+        },
+    });
+    await appendGenerationTelemetry(workspace, buildGenerationTelemetryFromPoll({
+        report: updatedReport,
+        poll: {
+            ...poll,
+            status: normalizedPollStatus,
+            issues: normalizedIssues,
+        },
+        recordedAt: lastCheckedAt,
+    }));
+    return {
+        reportPath,
+        report: updatedReport,
+        poll,
+        ...(assetManifestPath ? { assetManifestPath } : {}),
+    };
+}
+//# sourceMappingURL=execution-status.js.map