Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

Offer 15-second Grok video clips

Claude0a7c3e9ea939
diff --git a/client/src/components/settings/ImageGenTab.jsx b/client/src/components/settings/ImageGenTab.jsx
index 11fd63b5ac..5052e47e0c 100644
--- a/client/src/components/settings/ImageGenTab.jsx
+++ b/client/src/components/settings/ImageGenTab.jsx
@@ -949,7 +949,7 @@ export function ImageGenTab() {
</p>
<div className="grid grid-cols-1 sm:grid-cols-[1fr_auto] gap-2 sm:items-center border border-port-border rounded-lg px-3 py-2 bg-port-bg/40">
<FormField
- label={<>Default video backend<span className="block text-xs text-gray-500 mt-0.5">Used when a video render names no backend and its surface has no pin. Grok clips render at 6s or 10s on xAI&rsquo;s fixed video backend.</span></>}
+ label={<>Default video backend<span className="block text-xs text-gray-500 mt-0.5">Used when a video render names no backend and its surface has no pin. Grok clips render at 6, 10 or 15 seconds on xAI&rsquo;s fixed video backend.</span></>}
labelClassName="text-sm text-gray-300"
className="contents"
>
diff --git a/client/src/components/sprites/WalkWorkflow.jsx b/client/src/components/sprites/WalkWorkflow.jsx
index 5484573c0b..b9480b0850 100644
--- a/client/src/components/sprites/WalkWorkflow.jsx
+++ b/client/src/components/sprites/WalkWorkflow.jsx
@@ -35,7 +35,7 @@ const CELL_PX = 96; // preview cell size — the strip animates at 96px/frame
const LOOP_KEYFRAMES = '@keyframes sprite-walk-loop { to { background-position-x: var(--sprite-walk-loop-end) } }';
// Clip length only decides how much source footage the packer can choose from;
// the CYCLE'S look (walk vs run) comes from the frame-count + speed controls.
-// The offered lengths live in lib/grokVideoClip.js — see there for why 6s/10s
+// The offered lengths live in lib/grokVideoClip.js — see there for why 6/10/15 s
// are the only two (#3022).
// Delivered clip length for a run, when the server managed to probe it
@@ -267,7 +267,7 @@ function DirectionCard({
<p
className={`text-[10px] ${clipLength.mismatch ? 'text-port-warning' : 'text-gray-500'}`}
title={clipLength.mismatch
- ? 'grok delivered a different clip length than requested — its image_to_video tool renders only 6s or 10s'
+ ? 'grok delivered a different clip length than requested — its image_to_video tool renders only 6, 10 or 15 s'
: 'Source clip length grok delivered (probed from the file)'}
>
{clipLength.text}
@@ -729,7 +729,7 @@ export default function WalkWorkflow({
/>
<label className="flex items-center gap-1.5 text-xs text-gray-400" htmlFor={`walk-clip-${recordId}`} title={provider === 'local'
? "The local model renders on a fixed frame grid, so this length is snapped to the nearest legal clip. Length only affects how much source footage the packer has to choose from, not the walk's speed."
- : "grok renders 6s or 10s clips — these are the only lengths it offers, and a shorter request comes back as 6s. Length only affects how much source footage the packer has to choose from, not the walk's speed."}>
+ : "grok renders 6, 10 or 15 s clips — these are the only lengths it offers, and a shorter request comes back as 6s. Length only affects how much source footage the packer has to choose from, not the walk's speed."}>
Clip
<select
id={`walk-clip-${recordId}`}
diff --git a/client/src/components/sprites/WalkWorkflow.test.jsx b/client/src/components/sprites/WalkWorkflow.test.jsx
index f2a11f328a..000cf9791e 100644
--- a/client/src/components/sprites/WalkWorkflow.test.jsx
+++ b/client/src/components/sprites/WalkWorkflow.test.jsx
@@ -256,7 +256,7 @@ describe('WalkWorkflow render-lane picker (#4876)', () => {
});
it('describes the clip length in LOCAL terms when the local lane is selected', () => {
- // The grok copy names 6s/10s clips, which is not what H3 renders.
+ // The grok copy names 6/10/15 s clips, which is not what H3 renders.
renderPanel({ providers: PROVIDERS, provider: 'local', onProviderChange: vi.fn() });
expect(screen.getByLabelText(/^Clip/).closest('label')).toHaveAttribute(
'title', expect.stringContaining('fixed frame grid'),
@@ -481,9 +481,9 @@ describe('WalkWorkflow observable render', () => {
describe('WalkWorkflow authoring controls', () => {
it('offers a set-level Cycle target, Preview speed, and grok-real Clip options', () => {
renderRun({ id: 'walk-east-deadbeef', direction: 'east', status: 'error', postprocessError: 'x' });
- // Clip length is now just grok's real 6s/10s options (shorter was a no-op).
+ // Clip length is now just grok's real 6/10/15 s options (shorter was a no-op).
const clip = screen.getByRole('combobox', { name: /Clip/ });
- expect([...clip.options].map((o) => o.value)).toEqual(['6', '10']);
+ expect([...clip.options].map((o) => o.value)).toEqual(['6', '10', '15']);
// Frame count + speed are ONE set-level target now (#2985), not per-render
// inputs that can drift between directions.
expect(screen.getByRole('combobox', { name: /Cycle target/ })).toBeTruthy();
@@ -910,7 +910,7 @@ describe('WalkWorkflow reprocess + reopen', () => {
});
// The delivered-clip-length readout (#3022). grok's image_to_video offers only
-// 6s/10s and renders 6s for anything shorter, so the requested length is not a
+// 6/10/15 s and renders 6s for anything shorter, so the requested length is not a
// promise — the card reports what the server probed off the file, and says so
// loudly when the two disagree.
describe('delivered clip length', () => {
diff --git a/server/lib/creativeDirectorVideoCompiler.js b/server/lib/creativeDirectorVideoCompiler.js
index 6fff22a0a0..a95b7857b5 100644
--- a/server/lib/creativeDirectorVideoCompiler.js
+++ b/server/lib/creativeDirectorVideoCompiler.js
@@ -14,7 +14,7 @@ export function validateVideoShot(project, scene, isFirst) {
const unsupported = [];
if (isFirst && scene.useContinuationFromPrior) unsupported.push('continuation without a prior shot');
if (backend === 'grok' && !GROK_VIDEO_DURATIONS.includes(scene.durationSeconds)) {
- unsupported.push(`duration (choose ${GROK_VIDEO_DURATIONS.join(' or ')} seconds)`);
+ unsupported.push(`duration (choose ${GROK_VIDEO_DURATIONS.slice(0, -1).join(', ')} or ${GROK_VIDEO_DURATIONS.at(-1)} seconds)`);
}
if (backend === 'reactor') {
if (scene.durationSeconds < REACTOR_MIN_CLIP_SECONDS || scene.durationSeconds > REACTOR_MAX_CLIP_SECONDS) {
diff --git a/server/lib/grokVideoClip.js b/server/lib/grokVideoClip.js
index 44c2d9d683..9804dcaba2 100644
--- a/server/lib/grokVideoClip.js
+++ b/server/lib/grokVideoClip.js
@@ -28,6 +28,13 @@
* hand-copied literals in a schema are how a schema and its service drift apart
* (as `[1,2,3,6,10]` here and `[6,10]` in the schema already had).
*
+ * 2026-10-12: xAI's video API (grok-imagine-video-1.5 / 1.5-lite) now takes a
+ * `duration` of 1–15 s (default 8), so 15 s joins the list as the new longest
+ * clip. The CLI tool was last measured at 6/10 only; `generateVideo` probes
+ * every delivered clip and warns when one comes back shorter than requested,
+ * which is the check that confirms 15 s through the CLI (and would show
+ * whether shorter clips are now honored too).
+ *
* If grok's tool ever gains shorter clips, change this list — the walk picker,
* both Zod schemas, and the service gates all follow from it. Confirm with a
* probe (every packaged walk run stamps `sourceVideoSeconds` for exactly this
@@ -35,7 +42,7 @@
*/
/** Clip lengths (seconds) grok's image_to_video delivers, ascending. */
-export const GROK_VIDEO_DURATIONS = Object.freeze([6, 10]);
+export const GROK_VIDEO_DURATIONS = Object.freeze([6, 10, 15]);
/** Fallback when a caller omits (or requests an undeliverable) clip length. */
export const GROK_VIDEO_DEFAULT_DURATION = 6;
diff --git a/server/lib/grokVideoClip.test.js b/server/lib/grokVideoClip.test.js
index 94eeee1f66..e70a542096 100644
--- a/server/lib/grokVideoClip.test.js
+++ b/server/lib/grokVideoClip.test.js
@@ -9,7 +9,7 @@ describe('grokVideoClip', () => {
// down here so a future "shorter clips save render time" change has to come
// with a new measurement rather than an assumption.
it('offers exactly the clip lengths grok delivers', () => {
- expect(GROK_VIDEO_DURATIONS).toEqual([6, 10]);
+ expect(GROK_VIDEO_DURATIONS).toEqual([6, 10, 15]);
expect(Object.isFrozen(GROK_VIDEO_DURATIONS)).toBe(true);
});
@@ -52,11 +52,12 @@ describe('nearestGrokDuration — translating another backend\'s continuous leng
expect(nearestGrokDuration(7)).toBe(10);
expect(nearestGrokDuration(8)).toBe(10);
expect(nearestGrokDuration(10)).toBe(10);
+ expect(nearestGrokDuration(12)).toBe(15);
});
it('clamps a request longer than the longest clip', () => {
- expect(nearestGrokDuration(30)).toBe(10);
- expect(nearestGrokDuration(600)).toBe(10);
+ expect(nearestGrokDuration(30)).toBe(15);
+ expect(nearestGrokDuration(600)).toBe(15);
});
it('accepts a numeric string', () => {
diff --git a/server/lib/musicVideoShotTiming.js b/server/lib/musicVideoShotTiming.js
index 5e6d7faade..4409fc4d18 100644
--- a/server/lib/musicVideoShotTiming.js
+++ b/server/lib/musicVideoShotTiming.js
@@ -310,7 +310,7 @@ export function clipRelativeCues(cues, windowStartSec, windowEndSec) {
/**
* The Grok CLI request that covers a cutaway shot of `spanSec`: the shortest
- * deliverable clip at least that long (6 or 10s), or the longest when none is.
+ * deliverable clip at least that long (6, 10 or 15 s), or the longest when none is.
* `uncoveredSec > 0` means one clip cannot cover the shot — split the scene
* rather than loop or stretch the clip.
*/
diff --git a/server/lib/musicVideoShotTiming.test.js b/server/lib/musicVideoShotTiming.test.js
index 1c8c897f0c..cc31f4943f 100644
--- a/server/lib/musicVideoShotTiming.test.js
+++ b/server/lib/musicVideoShotTiming.test.js
@@ -80,7 +80,7 @@ describe('shotSplitLimit', () => {
it('bounds a performance by the lip-sync window and a Grok footage cutaway by its longest clip', () => {
const fal = SOURCE_AUDIO_LIPSYNC.fal;
expect(shotSplitLimit({ shotMode: 'performance' }, 'fal')).toBeCloseTo(fal.maxAudioSec - PERFORMANCE_WINDOW_MARGIN_SEC, 6);
- expect(shotSplitLimit({ shotMode: 'cutaway' }, 'grok')).toBe(10);
+ expect(shotSplitLimit({ shotMode: 'cutaway' }, 'grok')).toBe(15);
// Blocked outright (not split) or unbounded lanes have no limit.
expect(shotSplitLimit({ shotMode: 'performance' }, 'grok')).toBeNull();
expect(shotSplitLimit({ shotMode: 'cutaway' }, 'fal')).toBeNull();
diff --git a/server/lib/musicVideoValidation.js b/server/lib/musicVideoValidation.js
index 83f72bea3a..7359b565b8 100644
--- a/server/lib/musicVideoValidation.js
+++ b/server/lib/musicVideoValidation.js
@@ -16,6 +16,7 @@ import { CROSS_LINK_EDIT_TARGETS } from './musicVideoCrossLinks.js';
*/
import { z } from 'zod';
+import { GROK_VIDEO_DURATIONS } from './grokVideoClip.js';
import { knownFilmStyleIdSchema } from './filmStyleGrammars.js';
const makingOfId = z.string().regex(/^[A-Za-z0-9_-]{1,100}$/);
@@ -133,7 +134,7 @@ export const musicVideoVideoSettingsSchema = z.object({
// (see generationMode below).
backend: z.enum(['local', 'grok', 'fal']).nullable().optional(),
modelId: z.string().max(64).nullable().optional(),
- grokDuration: z.union([z.literal(6), z.literal(10)]).optional(),
+ grokDuration: z.union(GROK_VIDEO_DURATIONS.map((d) => z.literal(d))).optional(),
// fal.ai clip length in seconds. Loosely bounded (not a closed enum) for the
// same reason routes/videoGen.js's falDuration is: fal's own model catalog,
// not PortOS, owns the set of valid durations per model. null/omitted lets
diff --git a/server/routes/musicVideoSceneSplit.test.js b/server/routes/musicVideoSceneSplit.test.js
index 672c0abecf..8dfd5f8ed8 100644
--- a/server/routes/musicVideoSceneSplit.test.js
+++ b/server/routes/musicVideoSceneSplit.test.js
@@ -77,8 +77,8 @@ describe('POST /:id/scenes/:sceneId/split', () => {
expect(stored.scenes[1].takes.map((t) => t.assetId)).toEqual(['singer.png', 'clip-whole-verse']);
});
- it('splits a Grok cutaway at its 10-second clip limit when the director renders on Grok', async () => {
- const shot = await projects.addProjectScene(project.id, { label: 'Bridge', startSec: 30, endSec: 55 });
+ it('splits a Grok cutaway at its 15-second clip limit when the director renders on Grok', async () => {
+ const shot = await projects.addProjectScene(project.id, { label: 'Bridge', startSec: 30, endSec: 70 });
await projects.updateScene(project.id, shot.sceneId, { videoHistoryId: 'clip-bridge' });
const res = await split(shot.sceneId, { backend: 'grok' });
expect(res.status).toBe(200);
@@ -86,9 +86,9 @@ describe('POST /:id/scenes/:sceneId/split', () => {
// A cutaway clip still starts where the first piece does: it stays selected.
expect(pieces.map((p) => p.videoHistoryId)).toEqual(['clip-bridge', null, null]);
expect(pieces).toHaveLength(3);
- for (const p of pieces) expect(p.endSec - p.startSec).toBeLessThanOrEqual(10);
+ for (const p of pieces) expect(p.endSec - p.startSec).toBeLessThanOrEqual(15);
expect(pieces[0].startSec).toBe(30);
- expect(pieces.at(-1).endSec).toBe(55);
+ expect(pieces.at(-1).endSec).toBe(70);
});
it('gives a sung line held across an unavoidable cut to both pieces', async () => {
diff --git a/server/services/creativeDirector/projectsFile.test.js b/server/services/creativeDirector/projectsFile.test.js
index 8e741ab5a2..7e82140447 100644
--- a/server/services/creativeDirector/projectsFile.test.js
+++ b/server/services/creativeDirector/projectsFile.test.js
@@ -107,7 +107,7 @@ describe('Video treatment artifacts', () => {
await file.updateProject(p.id, { renderBackend: { video: { mode: 'grok' } } });
const rounded = videoTreatment();
rounded.scenes = Array.from({ length: 15 }, (_, order) => ({ ...rounded.scenes[0], sceneId: `scene-${order}`, order, durationSeconds: 8 }));
- await expect(file.setTreatment(p.id, { ...rounded, productionRevision: (await file.getProject(p.id)).videoWorkRevision || 0 })).rejects.toThrow('choose 6 or 10 seconds');
+ await expect(file.setTreatment(p.id, { ...rounded, productionRevision: (await file.getProject(p.id)).videoWorkRevision || 0 })).rejects.toThrow('choose 6, 10 or 15 seconds');
await file.setTreatment(p.id, { ...videoTreatment(), productionRevision: (await file.getProject(p.id)).videoWorkRevision || 0 });
expect((await file.getProject(p.id)).treatment.artifact.targetDurationSeconds).toBe(120);
});
diff --git a/server/services/creativeDirectorPrompts.test.js b/server/services/creativeDirectorPrompts.test.js
index cb6a77a6a6..550669fa18 100644
--- a/server/services/creativeDirectorPrompts.test.js
+++ b/server/services/creativeDirectorPrompts.test.js
@@ -283,7 +283,7 @@ describe('standalone Video treatment planning', () => {
it('distinguishes pinned Grok durations from unresolved inherited capabilities', async () => {
const project = { ...baseProject, workspace: 'video' };
const grok = await buildTreatmentPrompt({ ...project, renderBackend: { video: { mode: 'grok' } } });
- expect(grok).toContain('"durationSeconds":[6,10]');
+ expect(grok).toContain('"durationSeconds":[6,10,15]');
const inherited = await buildTreatmentPrompt(project);
expect(inherited).toContain('"backendCompatibility":"unresolved"');
expect(inherited).toContain('source record IDs are not image filenames');
diff --git a/server/services/musicVideo/shotPlan.js b/server/services/musicVideo/shotPlan.js
index 52b28b1f3d..be63b4b117 100644
--- a/server/services/musicVideo/shotPlan.js
+++ b/server/services/musicVideo/shotPlan.js
@@ -28,13 +28,14 @@ import { performanceCapability } from '../../lib/musicVideoShotTiming.js';
import { normalizeMusicVideoProductionPolicy } from '../../lib/musicVideoMediumPlan.js';
import { deliveryNotesWithin } from './lyricMarkers.js';
import { snapSectionsToGrid } from './audioAnalysis.js';
+import { GROK_VIDEO_DURATIONS } from '../../lib/grokVideoClip.js';
const EPS = 1e-6;
const SECTION_LABEL_MAX = 120;
const LYRIC_TEXT_MAX = 2000;
// An untimed-end cue lasts until the next cue, capped here.
const OPEN_CUE_MAX_SEC = 8;
-// Grok renders fixed 6s/10s clips; a local model's default render is ~5s
+// Grok renders fixed 6/10/15 s clips; a local model's default render is ~5s
// (121 frames at 24fps). A project pacing ceiling can only shorten either.
const DEFAULT_LOCAL_CLIP_CAPACITY_SEC = 5;
const DEFAULT_MIN_SHOT_SEC = 2;
@@ -68,7 +69,7 @@ export function validSections(sections) {
/** Seconds of footage one generated clip provides for the project's renderer. */
export function resolveClipCapacitySec(videoSettings) {
- if (videoSettings?.backend === 'grok') return videoSettings.grokDuration === 6 ? 6 : 10;
+ if (videoSettings?.backend === 'grok') return GROK_VIDEO_DURATIONS.includes(videoSettings.grokDuration) ? videoSettings.grokDuration : 10;
return DEFAULT_LOCAL_CLIP_CAPACITY_SEC;
}
diff --git a/server/services/videoGen/backendPin.test.js b/server/services/videoGen/backendPin.test.js
index 797ec5e021..9a673d694c 100644
--- a/server/services/videoGen/backendPin.test.js
+++ b/server/services/videoGen/backendPin.test.js
@@ -122,10 +122,10 @@ describe('grokVideoJobParams', () => {
});
it('rounds a local-lane duration UP to a length grok delivers', () => {
- // An 8s scene must not silently come back 6s — grok only does 6 or 10.
+ // An 8s scene must not silently come back 6s — grok only does 6, 10 or 15.
expect(grokVideoJobParams(grokOn, { durationSeconds: 8 }).duration).toBe(10);
expect(grokVideoJobParams(grokOn, { durationSeconds: 4 }).duration).toBe(6);
- expect(grokVideoJobParams(grokOn, { durationSeconds: 30 }).duration).toBe(10);
+ expect(grokVideoJobParams(grokOn, { durationSeconds: 30 }).duration).toBe(15);
});
it('defaults the clip length when none is given', () => {
diff --git a/server/services/videoGen/grok.js b/server/services/videoGen/grok.js
index 4128b66049..451354f4d2 100644
--- a/server/services/videoGen/grok.js
+++ b/server/services/videoGen/grok.js
@@ -2,7 +2,7 @@
* Video Gen — xAI Grok Build CLI provider (image-first flow).
*
* Grok has no text-to-video tool: its `image_to_video` animates a source
- * image (durations 6s/10s). So the flow, following grok's bundled
+ * image (durations 6/10/15 s). So the flow, following grok's bundled
* `game-animation-frames` skill, is image-first — one headless agent turn
* that (1) generates a base image with `image_gen` when the caller didn't
* supply one, then (2) animates it with `image_to_video`, saving the MP4 to
@@ -38,6 +38,7 @@ import { mutateVideoHistory } from './history.js';
import { noImageReason, deriveAspectRatio, GROK_ASPECT_RATIOS } from '../imageGen/grok.js';
import { resolveGrokDuration } from '../../lib/grokVideoClip.js';
import { withSpawnCwdEnv } from '../../lib/spawnCwd.js';
+import { probeVideoDuration } from '../../lib/ffmpeg.js';
import { maintenance } from '../../lib/maintenanceAdmission.js';
// 30 minutes — an image-first video turn is two sequential tool calls
@@ -298,6 +299,14 @@ async function runGrokVideo(job, jobId, bin, args, {
return finalizeJobFailure(job, jobId, proc, `${prefix}${noVideoReason(stdoutTail)}`);
}
await copyFileGuarded(stagingPath, outputPath);
+ // grok's agent picks its own image_to_video length (see grokVideoClip.js),
+ // so record what it actually delivered and flag a clip that came back
+ // short: that is how a 15 s request is confirmed through the CLI.
+ const deliveredSec = await probeVideoDuration(outputPath).catch(() => null);
+ if (Number.isFinite(deliveredSec)) {
+ meta.deliveredSec = Math.round(deliveredSec * 100) / 100;
+ if (deliveredSec < meta.duration - 1) console.warn(`⚠️ grok delivered ${meta.deliveredSec}s for a ${meta.duration}s request [${jobId.slice(0, 8)}]`);
+ }
// Removing the scratch directory also removes the harvested staging file.
await cleanup();
if (activeProcs.get(jobId) === proc) activeProcs.delete(jobId);
diff --git a/server/services/videoGen/grok.test.js b/server/services/videoGen/grok.test.js
index 1f4d5593fb..eb457e6068 100644
--- a/server/services/videoGen/grok.test.js
+++ b/server/services/videoGen/grok.test.js
@@ -83,6 +83,7 @@ vi.mock('../../lib/ffmpeg.js', async () => {
...actual,
optimizeForStreaming: vi.fn(async () => {}),
generateThumbnail: vi.fn(async (_p, jobId) => `${jobId}.jpg`),
+ probeVideoDuration: vi.fn(async () => null),
};
});
@@ -92,6 +93,7 @@ const { loadHistory } = await import('./history.js');
const { createMaintenanceAdmission } = await import('../../lib/maintenanceAdmission.js');
const { rmGuarded, unlinkGuarded } = await import('../../lib/fileUtils.js');
const realFiles = await vi.importActual('../../lib/fileUtils.js');
+const { probeVideoDuration } = await import('../../lib/ffmpeg.js');
const flush = () => new Promise((r) => setImmediate(r));
const scratchDirFor = (jobId) => join(tmpdir(), `portos-grok-video-${jobId}`);
@@ -228,6 +230,29 @@ describe('videoGen/grok — harvest and finalize', () => {
expect(history[0]).toEqual(expect.objectContaining({ id: job.jobId, modelId: 'grok', mode: 'text', duration: 6 }));
});
+ it('records the delivered length and warns when a 15 s request comes back short', async () => {
+ probeVideoDuration.mockResolvedValueOnce(10.04);
+ const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+ const completed = vi.fn();
+ videoGenEvents.on('completed', completed);
+
+ const job = await grok.generateVideo({ prompt: 'a fox running', duration: 15 });
+ expect(promptOf()).toContain('for 15 seconds');
+ await mkdir(scratchDirFor(job.jobId), { recursive: true });
+ await writeFile(stagingPathFor(job.jobId), MP4_BYTES);
+ await closeChild(0, 0);
+
+ const deadline = Date.now() + 5000;
+ while (Date.now() < deadline && completed.mock.calls.length === 0) {
+ await new Promise((r) => setTimeout(r, 50));
+ }
+ expect(completed).toHaveBeenCalledTimes(1);
+ expect(warn).toHaveBeenCalledWith(expect.stringContaining('grok delivered 10.04s for a 15s request'));
+ const history = await loadHistory();
+ expect(history.find((h) => h.id === job.jobId)).toEqual(expect.objectContaining({ duration: 15, deliveredSec: 10.04 }));
+ warn.mockRestore();
+ });
+
it('rejects a staged file that is not MP4 (signature sniff)', async () => {
const failed = vi.fn();
videoGenEvents.on('failed', failed);
diff --git a/server/services/videoGen/modes.js b/server/services/videoGen/modes.js
index 32e85184dd..2a837e64c1 100644
--- a/server/services/videoGen/modes.js
+++ b/server/services/videoGen/modes.js
@@ -68,7 +68,7 @@ export function isVideoModeUsable(settings, mode) {
* intent, but the FALLBACK differs deliberately: image gen prefers an enabled
* cloud backend, while video falls back to LOCAL. A local video render is free
* and fully controllable (model/frames/fps/LoRAs); grok video spends remote
- * quota and only delivers 6s or 10s clips (see lib/grokVideoClip.js). Silently
+ * quota and only delivers 6/10/15 s clips (see lib/grokVideoClip.js). Silently
* upgrading every unpinned video render to a paid backend because the user
* enabled grok for IMAGES would be a surprise spend — grok video renders only
* when a request, record, or explicit user pin names it.