From 61a523b321a8379e3269cc2da76c6fc1eab0051a Mon Sep 17 00:00:00 2001
From: Hermes Agent <hermes-agent@users.noreply.github.com>
Date: Wed, 24 Jun 2026 01:31:55 +0000
Subject: [PATCH] feat(video): build video generation -> ingest -> publish
 (flag-OFF)

Builds the missing generation half of the video pipeline; the Meta Graph
publish branches already existed gated behind ARIES_VIDEO_PUBLISH_ENABLED.
Provider is Grok/xAI via Hermes (Aries sends a high-level request and never
names the tool). Ships dormant: the flag stays OFF and IG video is inert
until a Meta IG Business account is linked to the Page (#691).

- schema: width_px/height_px/duration_seconds on creative_assets/posts/
  scheduled_posts (+ migration 20260623120000); thread mediaMetadata from
  scheduled_posts -> worker -> scheduled-dispatch -> publishToMetaGraph
  (direct + composio seam), built only for a video surface with all 3 dims.
- ingest: branch on type=generated_video / media_type=video -> write
  media_type, real aspect_ratio, and dims; logo-composite skips video.
- synthesize: copy the linked asset's dims onto the posts row.
- outbound: VIDEO_EXECUTION_CONTRACT + per-clip 9:16 brief, gated on the
  flag + videoRenderCount>0; byte-identical contextBlock when off.
- publish: Composio FB feed-video (FACEBOOK_CREATE_VIDEO_POST, new
  publish_video op) + IG REELS/STORIES two-step container+publish; this
  also fixes the previously broken single-call IG branch. A pre-publish
  validateMediaForSurface throw is wrapped as ComposioToolError so it is
  classified never-posted (a raw MetaPublishError was mis-classified
  outcome-unknown). IG feed-video validated against reel 9:16 constraints.
- dashboard: video assets render as <video> (shared MediaPreview already
  supported it); manual-schedule route threads dims.
- contract spec for the Hermes side: docs/plans/2026-06-23-video-generation.md

verify + validate:social-content + validate:execution-provider all green;
composio-publisher 22/22.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018Jq6YvGxzP23enohEiMpmD
---
 .env.example                                  |   6 +-
 .../publishing/scheduled-dispatch/route.ts    |  16 +
 .../[jobId]/posts/[postId]/schedule/route.ts  |  25 +-
 .../integrations/composio/composio-config.ts  |   1 +
 .../composio/composio-publisher-provider.ts   | 193 ++++++-
 .../direct/direct-meta-provider.ts            |   1 +
 backend/integrations/providers/types.ts       |   6 +
 backend/integrations/publish-dispatch.ts      |   1 +
 backend/marketing/auto-schedule.ts            |  14 +
 backend/marketing/hermes-callbacks.ts         |   8 +-
 backend/marketing/ingest-production-assets.ts |  75 ++-
 backend/marketing/ports/hermes.ts             |   8 +
 backend/marketing/synthesize-publish-posts.ts |  81 +--
 backend/marketing/workspace-views.ts          |  22 +-
 backend/social-content/scheduled-posts.ts     |  14 +-
 backend/social-content/workflow-request.ts    | 122 +++++
 docker-compose.yml                            |   2 +
 docs/plans/2026-06-23-video-generation.md     | 143 ++++++
 frontend/aries-v1/post-workspace.tsx          |   1 +
 frontend/aries-v1/review-item.tsx             |   1 +
 lib/api/aries-v1.ts                           |   2 +
 lib/api/marketing.ts                          |   2 +
 .../20260623120000_video_media_metadata.sql   |  23 +
 .../automations/scheduled-posts-worker.mjs    |   4 +
 scripts/init-db.js                            |  12 +
 tests/composio-publisher.test.ts              | 218 +++++++-
 tests/marketing-auto-schedule.test.ts         |   8 +-
 .../ingest-production-assets.test.ts          |  12 +-
 tests/marketing/video-ingest-dims.test.ts     | 289 +++++++++++
 .../workspace-video-asset-mapping.test.ts     | 232 +++++++++
 tests/social-content-schedule-dims.test.ts    | 243 +++++++++
 .../video-production-context.test.ts          | 231 +++++++++
 tests/video-publish-dispatch-wiring.test.ts   | 482 ++++++++++++++++++
 tests/video-synthesize-dims.test.ts           | 208 ++++++++
 34 files changed, 2614 insertions(+), 92 deletions(-)
 create mode 100644 docs/plans/2026-06-23-video-generation.md
 create mode 100644 migrations/20260623120000_video_media_metadata.sql
 create mode 100644 tests/marketing/video-ingest-dims.test.ts
 create mode 100644 tests/marketing/workspace-video-asset-mapping.test.ts
 create mode 100644 tests/social-content-schedule-dims.test.ts
 create mode 100644 tests/social-content/video-production-context.test.ts
 create mode 100644 tests/video-publish-dispatch-wiring.test.ts
 create mode 100644 tests/video-synthesize-dims.test.ts

diff --git a/.env.example b/.env.example
index ea85dcdf..221ceafe 100644
--- a/.env.example
+++ b/.env.example
@@ -314,13 +314,15 @@ ANALYTICS_PROVIDER=composio
 # vary by toolkit version, so they are NOT guessed — set the ones you have
 # verified for your account. Unset operations are reported as unavailable
 # (never fabricated). Pattern: COMPOSIO_<PLATFORM>_<OPERATION>_ACTION
-#   operations: PUBLISH_POST, UPLOAD_MEDIA, POST_INSIGHTS, AD_INSIGHTS,
+#   operations: PUBLISH_POST, PUBLISH_VIDEO, UPLOAD_MEDIA, POST_INSIGHTS, AD_INSIGHTS,
 #               ACCOUNT_INSIGHTS, CREATE_AD, LIST_AD_ACCOUNTS, LIST_PAGES, ACCOUNT_INFO
 # Examples (verify slugs against your Composio toolkit version before setting):
 #   COMPOSIO_FACEBOOK_PUBLISH_POST_ACTION=FACEBOOK_CREATE_POST
+#   COMPOSIO_FACEBOOK_PUBLISH_VIDEO_ACTION=FACEBOOK_CREATE_VIDEO_POST
 #   COMPOSIO_INSTAGRAM_PUBLISH_POST_ACTION=INSTAGRAM_POST_IG_USER_MEDIA_PUBLISH
 #   COMPOSIO_FACEBOOK_UPLOAD_MEDIA_ACTION=FACEBOOK_CREATE_PHOTO_POST
 #   COMPOSIO_INSTAGRAM_UPLOAD_MEDIA_ACTION=INSTAGRAM_POST_IG_USER_MEDIA
+#   COMPOSIO_INSTAGRAM_ACCOUNT_INFO_ACTION=INSTAGRAM_GET_USER_INFO
 #   COMPOSIO_META_ADS_CREATE_AD_ACTION=META_ADS_CREATE_AD
 # X (Twitter) publish (#631) — only consulted when ARIES_X_ENABLED=true and
 # PUBLISH_PROVIDER=composio/auto. UPLOAD_MEDIA stages the image (file_uploadable)
@@ -334,9 +336,11 @@ ANALYTICS_PROVIDER=composio
 # passthrough for subreddits that require a post flair.
 #   COMPOSIO_REDDIT_PUBLISH_POST_ACTION=REDDIT_CREATE_REDDIT_POST
 COMPOSIO_FACEBOOK_PUBLISH_POST_ACTION=
+COMPOSIO_FACEBOOK_PUBLISH_VIDEO_ACTION=
 COMPOSIO_INSTAGRAM_PUBLISH_POST_ACTION=
 COMPOSIO_FACEBOOK_UPLOAD_MEDIA_ACTION=
 COMPOSIO_INSTAGRAM_UPLOAD_MEDIA_ACTION=
+COMPOSIO_INSTAGRAM_ACCOUNT_INFO_ACTION=
 COMPOSIO_X_PUBLISH_POST_ACTION=
 COMPOSIO_X_UPLOAD_MEDIA_ACTION=
 COMPOSIO_REDDIT_PUBLISH_POST_ACTION=
diff --git a/app/api/internal/publishing/scheduled-dispatch/route.ts b/app/api/internal/publishing/scheduled-dispatch/route.ts
index 1b3068c4..09462ad7 100644
--- a/app/api/internal/publishing/scheduled-dispatch/route.ts
+++ b/app/api/internal/publishing/scheduled-dispatch/route.ts
@@ -20,6 +20,9 @@ type ScheduledDispatchBody = {
   media_urls?: string[];
   surface?: string;
   media_type?: string;
+  width_px?: number | null;
+  height_px?: number | null;
+  duration_seconds?: number | null;
 };
 
 // Minimal queryable surface so route tests can inject a fake DB.
@@ -198,6 +201,18 @@ export async function POST(req: Request): Promise<Response> {
       ? 'video'
       : 'image';
 
+  // Per-media dimensions/duration forwarded from scheduled_posts (populated by a
+  // later ingest/synthesize step; NULL today). Build mediaMetadata ONLY for a
+  // video surface with all three present — never fabricate (the validator fails
+  // closed on missing video metadata, which is the intended behavior).
+  const widthPx = typeof body.width_px === 'number' && Number.isFinite(body.width_px) ? body.width_px : null;
+  const heightPx = typeof body.height_px === 'number' && Number.isFinite(body.height_px) ? body.height_px : null;
+  const durationSeconds = typeof body.duration_seconds === 'number' && Number.isFinite(body.duration_seconds) ? body.duration_seconds : null;
+  const mediaMetadata: Array<{ widthPx: number; heightPx: number; durationSeconds: number }> | undefined =
+    mediaType === 'video' && widthPx !== null && heightPx !== null && durationSeconds !== null
+      ? [{ widthPx, heightPx, durationSeconds }]
+      : undefined;
+
   // Prefer explicit media_urls, otherwise look up creative assets for the tenant
   let rawMediaUrls: string[] = Array.isArray(body.media_urls)
     ? body.media_urls.filter((u): u is string => typeof u === 'string' && u.trim().length > 0)
@@ -281,6 +296,7 @@ export async function POST(req: Request): Promise<Response> {
         mediaUrls: signedMediaUrls,
         placement: surface,
         mediaType,
+        mediaMetadata,
       });
       results.push({ provider: platform, ok: true });
       if (firstPublishedPostId === null && published.platformPostId) {
diff --git a/app/api/social-content/jobs/[jobId]/posts/[postId]/schedule/route.ts b/app/api/social-content/jobs/[jobId]/posts/[postId]/schedule/route.ts
index ff8cd1a7..e1ea74cc 100644
--- a/app/api/social-content/jobs/[jobId]/posts/[postId]/schedule/route.ts
+++ b/app/api/social-content/jobs/[jobId]/posts/[postId]/schedule/route.ts
@@ -174,7 +174,7 @@ export async function handlePatchScheduleSocialContentPost(
 
   try {
     const lookup = await client.query(
-      'SELECT id, tenant_id, surface, media_type FROM posts WHERE id = $1 AND tenant_id = $2 LIMIT 1',
+      'SELECT id, tenant_id, surface, media_type, width_px, height_px, duration_seconds FROM posts WHERE id = $1 AND tenant_id = $2 LIMIT 1',
       [postIdInt, tenantId],
     );
     if ((lookup.rowCount ?? lookup.rows.length) === 0 || lookup.rows.length === 0) {
@@ -185,15 +185,27 @@ export async function handlePatchScheduleSocialContentPost(
       });
       return NextResponse.json(POST_NOT_FOUND, { status: 404 });
     }
-    // The post's own surface/media_type are authoritative — mirror them onto the
-    // scheduled_posts row so an image story (or reel) dispatches on the right
-    // Meta surface instead of defaulting to 'feed'.
-    const postRow = lookup.rows[0] as { surface?: unknown; media_type?: unknown } | undefined;
+    // The post's own surface/media_type/dims are authoritative — mirror them onto
+    // the scheduled_posts row so an image story (or reel) dispatches on the right
+    // Meta surface instead of defaulting to 'feed', and validateMediaForSurface
+    // has real width/height/duration_seconds at dispatch time.
+    const postRow = lookup.rows[0] as {
+      surface?: unknown;
+      media_type?: unknown;
+      width_px?: unknown;
+      height_px?: unknown;
+      duration_seconds?: unknown;
+    } | undefined;
     const postSurfaceRaw = typeof postRow?.surface === 'string' ? postRow.surface.trim().toLowerCase() : '';
     const postSurface: 'feed' | 'story' | 'reel' =
       postSurfaceRaw === 'story' || postSurfaceRaw === 'reel' ? postSurfaceRaw : 'feed';
     const postMediaType: 'image' | 'video' =
       typeof postRow?.media_type === 'string' && postRow.media_type.trim().toLowerCase() === 'video' ? 'video' : 'image';
+    const toDimPx = (value: unknown): number | null =>
+      typeof value === 'number' && Number.isFinite(value) ? value : null;
+    const postWidthPx = toDimPx(postRow?.width_px);
+    const postHeightPx = toDimPx(postRow?.height_px);
+    const postDurationSeconds = toDimPx(postRow?.duration_seconds);
 
     // Publish-approval gate: a post may only be queued for auto-publish once a
     // human has approved the publish stage. Mirrors the marketing publish path
@@ -225,6 +237,9 @@ export async function handlePatchScheduleSocialContentPost(
       campaignEndDate,
       surface: postSurface,
       mediaType: postMediaType,
+      widthPx: postWidthPx,
+      heightPx: postHeightPx,
+      durationSeconds: postDurationSeconds,
     });
 
     scheduleScheduledPostHonchoWrite({
diff --git a/backend/integrations/composio/composio-config.ts b/backend/integrations/composio/composio-config.ts
index f7cf35c3..891f60b6 100644
--- a/backend/integrations/composio/composio-config.ts
+++ b/backend/integrations/composio/composio-config.ts
@@ -38,6 +38,7 @@ export const TOOLKIT_SLUG: Record<IntegrationPlatform, string> = {
 
 export type ComposioOperation =
   | 'publish_post'
+  | 'publish_video'
   | 'upload_media'
   | 'post_insights'
   | 'ad_insights'
diff --git a/backend/integrations/composio/composio-publisher-provider.ts b/backend/integrations/composio/composio-publisher-provider.ts
index e8eed2f9..2a53674a 100644
--- a/backend/integrations/composio/composio-publisher-provider.ts
+++ b/backend/integrations/composio/composio-publisher-provider.ts
@@ -32,7 +32,15 @@ import {
   ComposioToolError,
 } from './errors';
 import { resolveFacebookManagedPage } from './facebook-page-resolver';
+import { resolveInstagramAccount } from './instagram-account-resolver';
 import { synthesizeStillToVideo, type StillToVideoResult } from '../still-to-video';
+import { MetaPublishError } from '../meta-publishing';
+import {
+  validateMediaForSurface,
+  type MediaMetadata,
+  type MediaSurface,
+  type MediaType,
+} from '../meta-media-validation';
 import pool from '@/lib/db';
 
 function pickId(data: unknown, keys: string[]): string | null {
@@ -183,6 +191,58 @@ export class ComposioPublisherProvider implements PublisherProvider {
     return slug;
   }
 
+  /**
+   * Per-surface media validation for a video/Story/Reel publish, run BEFORE any
+   * `gateway.executeTool` so nothing is ever posted on a malformed payload.
+   *
+   * SAFETY (double-post guard): `validateMediaForSurface` throws a
+   * `MetaPublishError`, which is NOT in `publishNeverReachedPlatform`'s recognized
+   * set (publish-outcome.ts). If that raw error escaped `publishPost`,
+   * `dispatchPublish`'s catch would fail the `publishNeverReachedPlatform` check
+   * and re-wrap it as `provider_publish_outcome_unknown` (`outcomeUnknown:true`) —
+   * surfacing a post that PROVABLY never reached the platform as
+   * needs_manual_reconciliation. Since validation runs before any tool call, the
+   * post definitely never posted, so we rethrow as `ComposioToolError` — a
+   * recognized never-posted verdict — exactly as the X/LinkedIn/YouTube
+   * pre-publish staging failures are surfaced. A validation failure is therefore
+   * unambiguously definitely-never-posted (safe to roll back the claim).
+   */
+  private validateMediaSurfaceOrNeverPosted(
+    input: PublishPostInput,
+    surface: MediaSurface,
+    mediaType: MediaType,
+    slug: string,
+  ): void {
+    const media: MediaMetadata[] = input.mediaUrls.map((url, i) => ({
+      url,
+      widthPx: input.mediaMetadata?.[i]?.widthPx ?? null,
+      heightPx: input.mediaMetadata?.[i]?.heightPx ?? null,
+      durationSeconds: input.mediaMetadata?.[i]?.durationSeconds ?? null,
+    }));
+    try {
+      validateMediaForSurface({ media, surface, mediaType, scheduledFor: input.scheduledFor ?? null });
+    } catch (error) {
+      if (error instanceof MetaPublishError) {
+        throw new ComposioToolError(slug, `${error.code}: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * The IG user id (numeric) the container/publish actions need as `ig_user_id`.
+   * `connected_accounts.external_account_id` is null for IG (it is not in the
+   * connection metadata), so fall back to the verified INSTAGRAM_GET_USER_INFO
+   * resolver, then to `'me'` (the actions accept the literal `'me'`). The resolver
+   * is a read-only pre-publish call that never creates a post.
+   */
+  private async resolveInstagramUserId(connectedAccountId: string, externalAccountId: string | null): Promise<string> {
+    const stored = externalAccountId?.trim();
+    if (stored) return stored;
+    const resolved = await resolveInstagramAccount(this.gateway, this.config, connectedAccountId);
+    return resolved?.igUserId ?? 'me';
+  }
+
   async publishPost(input: PublishPostInput): Promise<PublishResult> {
     // Dry-run never touches Composio.
     if (input.dryRun) {
@@ -248,26 +308,48 @@ export class ComposioPublisherProvider implements PublisherProvider {
         );
       }
 
-      const hasImage = input.mediaUrls.length > 0;
-      if (hasImage) {
-        // Photo post: FACEBOOK_CREATE_PHOTO_POST via the `upload_media` op slot
-        // (COMPOSIO_FACEBOOK_UPLOAD_MEDIA_ACTION=FACEBOOK_CREATE_PHOTO_POST).
-        // Only the first image is posted; multi-image carousel is a future feature.
-        slug = this.requireSlug(input.platform, 'upload_media', 'publish photo posts');
+      if (input.mediaType === 'video') {
+        // Video post: FACEBOOK_CREATE_VIDEO_POST via the `publish_video` op slot
+        // (COMPOSIO_FACEBOOK_PUBLISH_VIDEO_ACTION). The raw mp4 file_url is posted
+        // directly — no pre-stage. Composio has NO distinct FB Reel/Story video
+        // action, so a reel/story video collapses to a Page (feed) video; validate
+        // it against feed-video constraints accordingly.
+        slug = this.requireSlug(input.platform, 'publish_video', 'publish videos');
+        this.validateMediaSurfaceOrNeverPosted(input, 'feed', 'video', slug);
         toolArgs = {
-          url: input.mediaUrls[0],
-          message: input.content,
           page_id: pageId,
-          ...(input.scheduledFor ? { scheduled_publish_time: input.scheduledFor } : {}),
+          file_url: input.mediaUrls[0],
+          description: input.content,
+          // Scheduling requires `published:false` AND `scheduled_publish_time`
+          // TOGETHER (a `scheduled_publish_time` without `published:false` would
+          // publish immediately — the latent bug in the photo/text branch above
+          // is deliberately NOT copied here).
+          ...(input.scheduledFor
+            ? { published: false, scheduled_publish_time: input.scheduledFor }
+            : { published: true }),
         };
       } else {
-        // Text-only post: FACEBOOK_CREATE_POST via the `publish_post` op slot.
-        slug = this.requireSlug(input.platform, 'publish_post', 'publish posts');
-        toolArgs = {
-          message: input.content,
-          page_id: pageId,
-          ...(input.scheduledFor ? { scheduled_publish_time: input.scheduledFor } : {}),
-        };
+        const hasImage = input.mediaUrls.length > 0;
+        if (hasImage) {
+          // Photo post: FACEBOOK_CREATE_PHOTO_POST via the `upload_media` op slot
+          // (COMPOSIO_FACEBOOK_UPLOAD_MEDIA_ACTION=FACEBOOK_CREATE_PHOTO_POST).
+          // Only the first image is posted; multi-image carousel is a future feature.
+          slug = this.requireSlug(input.platform, 'upload_media', 'publish photo posts');
+          toolArgs = {
+            url: input.mediaUrls[0],
+            message: input.content,
+            page_id: pageId,
+            ...(input.scheduledFor ? { scheduled_publish_time: input.scheduledFor } : {}),
+          };
+        } else {
+          // Text-only post: FACEBOOK_CREATE_POST via the `publish_post` op slot.
+          slug = this.requireSlug(input.platform, 'publish_post', 'publish posts');
+          toolArgs = {
+            message: input.content,
+            page_id: pageId,
+            ...(input.scheduledFor ? { scheduled_publish_time: input.scheduledFor } : {}),
+          };
+        }
       }
     } else if (input.platform === 'x') {
       // X (Twitter): a text post, optionally with a single image. Unlike
@@ -508,15 +590,80 @@ export class ComposioPublisherProvider implements PublisherProvider {
         privacyStatus: youtubePrivacyStatus(),
       };
     } else if (input.platform === 'instagram') {
-      // Instagram: caption + media_urls + placement + media_type (unchanged).
-      slug = this.requireSlug(input.platform, 'publish_post', 'publish posts');
-      toolArgs = {
+      // Instagram: a TWO-STEP publish — create a media container, then publish it.
+      //   1. INSTAGRAM_POST_IG_USER_MEDIA          (`upload_media` op) → creation_id
+      //   2. INSTAGRAM_POST_IG_USER_MEDIA_PUBLISH  (`publish_post` op) → ig_media_id
+      // Image and video share the same container action; the surface selects the
+      // container's media_type. A single clean public URL is posted per call
+      // (multi-image carousel is a future feature). The previous single-call shape
+      // matched no real Composio action and never published live, so this is a
+      // ground-up rewrite, not a regression of working behaviour.
+      if (input.mediaUrls.length === 0) {
+        throw new ComposioCapabilityMissingError('instagram', 'publish a post — an image or video is required');
+      }
+      const surface: MediaSurface = input.placement ?? 'feed';
+      const isVideo = input.mediaType === 'video';
+
+      // Resolve BOTH slugs (capability-missing — definitely-never-posted — when unset).
+      const containerSlug = this.requireSlug(input.platform, 'upload_media', 'create a media container');
+      const publishSlug = this.requireSlug(input.platform, 'publish_post', 'publish posts');
+
+      // Fail-closed media validation BEFORE the container is created — nothing is
+      // posted on a malformed payload and a validation failure is never-posted.
+      // An IG feed VIDEO publishes as a REELS container, which Meta requires to be
+      // vertical 9:16, so validate it against reel constraints (not the laxer feed
+      // rules) — catch a non-9:16 clip at Aries rather than at the Meta container.
+      const validationSurface: MediaSurface = isVideo && surface === 'feed' ? 'reel' : surface;
+      this.validateMediaSurfaceOrNeverPosted(input, validationSurface, isVideo ? 'video' : 'image', containerSlug);
+
+      const igUserId = await this.resolveInstagramUserId(conn.connectedAccountId!, conn.externalAccountId ?? null);
+
+      // ── Step 1: create the media container (single clean public URL) ──────
+      const containerArgs: Record<string, unknown> = {
+        ig_user_id: igUserId,
         caption: input.content,
-        media_urls: input.mediaUrls,
-        placement: input.placement ?? 'feed',
-        media_type: input.mediaType ?? 'image',
-        ...(input.scheduledFor ? { scheduled_publish_time: input.scheduledFor } : {}),
       };
+      if (isVideo) {
+        containerArgs.video_url = input.mediaUrls[0];
+        // surface → IG container media_type. reel → REELS; story → STORIES;
+        // feed video → REELS + share_to_feed (a Reel that also lands in the feed).
+        if (surface === 'story') {
+          containerArgs.media_type = 'STORIES';
+        } else {
+          containerArgs.media_type = 'REELS';
+          if (surface === 'feed') containerArgs.share_to_feed = true;
+        }
+      } else {
+        // Feed image: image_url, no media_type (IG defaults to a single IMAGE).
+        containerArgs.image_url = input.mediaUrls[0];
+      }
+
+      const container = await this.gateway.executeTool(containerSlug, {
+        connectedAccountId: conn.connectedAccountId!,
+        arguments: containerArgs,
+      });
+      if (!container.successful) {
+        // The broker explicitly rejected the container — no container, no post.
+        throw new ComposioToolError(containerSlug, container.error ?? 'media container create reported unsuccessful');
+      }
+      const creationId = pickId(container.data, ['id', 'creation_id']);
+      if (!creationId) {
+        throw new ComposioToolError(containerSlug, 'media container create returned no creation id');
+      }
+
+      // ── Step 2: publish the container (executed by the shared call below) ──
+      // This is the ONLY outcome-unknown boundary for IG: a transport drop after
+      // this call may have published. A failed container above is never-posted.
+      slug = publishSlug;
+      toolArgs = {
+        ig_user_id: igUserId,
+        creation_id: creationId,
+        // Bounded server-side poll for the container to finish processing (<=300).
+        max_wait_seconds: 300,
+        poll_interval_seconds: 5,
+      };
+      // The published media id comes back as ig_media_id (or id).
+      idKeys = ['ig_media_id', 'id', 'media_id'];
     } else {
       // Unknown / unhandled platform — refuse explicitly rather than silently
       // falling through to an Instagram payload on the wrong network.
diff --git a/backend/integrations/direct/direct-meta-provider.ts b/backend/integrations/direct/direct-meta-provider.ts
index 02d6ba54..8cf35e22 100644
--- a/backend/integrations/direct/direct-meta-provider.ts
+++ b/backend/integrations/direct/direct-meta-provider.ts
@@ -113,6 +113,7 @@ export class DirectMetaProvider
       mediaUrls: input.mediaUrls,
       placement,
       mediaType,
+      mediaMetadata: input.mediaMetadata,
       scheduledFor: input.scheduledFor ?? null,
     });
 
diff --git a/backend/integrations/providers/types.ts b/backend/integrations/providers/types.ts
index 921f5782..9d62394e 100644
--- a/backend/integrations/providers/types.ts
+++ b/backend/integrations/providers/types.ts
@@ -174,6 +174,12 @@ export interface PublishPostInput {
    * live post when this is not true.
    */
   approved?: boolean;
+  /**
+   * Optional positional per-media width/height/duration (provider-agnostic),
+   * aligned to mediaUrls. Mirror of MetaPublishRequest.mediaMetadata; forwarded
+   * to the publisher so video surfaces can be validated. NULL/undefined today.
+   */
+  mediaMetadata?: Array<{ widthPx?: number | null; heightPx?: number | null; durationSeconds?: number | null }>;
 }
 
 export interface PublishAdInput {
diff --git a/backend/integrations/publish-dispatch.ts b/backend/integrations/publish-dispatch.ts
index ab5449ad..c95f4b93 100644
--- a/backend/integrations/publish-dispatch.ts
+++ b/backend/integrations/publish-dispatch.ts
@@ -113,6 +113,7 @@ export async function dispatchPublish(
       mediaUrls: request.mediaUrls,
       placement: request.placement,
       mediaType: request.mediaType,
+      mediaMetadata: request.mediaMetadata,
       scheduledFor: request.scheduledFor ?? null,
       // The handlers only dispatch already-approved posts; the seam still enforces
       // its own guard, so make the cleared approval explicit.
diff --git a/backend/marketing/auto-schedule.ts b/backend/marketing/auto-schedule.ts
index d92f6fac..7881d95c 100644
--- a/backend/marketing/auto-schedule.ts
+++ b/backend/marketing/auto-schedule.ts
@@ -138,6 +138,10 @@ export interface AutoScheduleInputRow {
   surface?: AutoScheduleSurface;
   /** Media type (image|video), mirrored onto scheduled_posts. Default 'image'. */
   mediaType?: 'image' | 'video';
+  /** Per-media video dims mirrored onto scheduled_posts. NULL today. */
+  widthPx?: number | null;
+  heightPx?: number | null;
+  durationSeconds?: number | null;
   /** Hermes's free-form time hint, currently unused — recorded for future override hooks. */
   recommendedTimeWindow?: string | null;
 }
@@ -161,6 +165,10 @@ export interface AutoScheduleSlot {
   surface: AutoScheduleSurface;
   /** Media type carried through to the scheduled_posts upsert. */
   mediaType: 'image' | 'video';
+  /** Per-media video dims carried through to the scheduled_posts upsert. NULL today. */
+  widthPx: number | null;
+  heightPx: number | null;
+  durationSeconds: number | null;
   /** Derived UTC instant ready for `scheduled_posts.scheduled_for`. */
   scheduledFor: Date;
   /** Audit trail: which weekday name we used (e.g. "Monday" or "fallback: first day in window"). */
@@ -263,6 +271,9 @@ export function computeAutoScheduleSlots(input: ComputeAutoScheduleSlotsInput):
       platform: row.platform,
       surface,
       mediaType,
+      widthPx: row.widthPx ?? null,
+      heightPx: row.heightPx ?? null,
+      durationSeconds: row.durationSeconds ?? null,
       scheduledFor: utc,
       appliedDay,
       appliedWallTime: wallTimeIso,
@@ -393,6 +404,9 @@ export async function autoSchedulePosts(
         platforms: [slot.platform],
         surface: slot.surface,
         mediaType: slot.mediaType,
+        widthPx: slot.widthPx,
+        heightPx: slot.heightPx,
+        durationSeconds: slot.durationSeconds,
         campaignEndDate: input.campaignEnd,
       });
       scheduled += 1;
diff --git a/backend/marketing/hermes-callbacks.ts b/backend/marketing/hermes-callbacks.ts
index a1ec2df6..47ea3280 100644
--- a/backend/marketing/hermes-callbacks.ts
+++ b/backend/marketing/hermes-callbacks.ts
@@ -1424,7 +1424,7 @@ async function autoScheduleApprovedPostsForJob(doc: SocialContentJobRuntimeDocum
   // than collapsing onto its feed sibling's slot. ORDER BY id is added for
   // stable logging output even though the ordinal mapping does not depend on it.
   const postRows = await pool.query<AutoSchedulePostRow>(
-    `SELECT id, platform, idempotency_key, surface, media_type
+    `SELECT id, platform, idempotency_key, surface, media_type, width_px, height_px, duration_seconds
        FROM posts
       WHERE job_id = $1 AND tenant_id = $2
       ORDER BY id`,
@@ -1464,6 +1464,9 @@ export interface AutoSchedulePostRow {
   idempotency_key: string | null;
   surface: string | null;
   media_type: string | null;
+  width_px: number | null;
+  height_px: number | null;
+  duration_seconds: number | null;
 }
 
 /**
@@ -1536,6 +1539,9 @@ export function buildAutoScheduleRows(
         recommendedDay: target?.recommendedDay ?? null,
         surface: normalizeScheduleSurface(row.surface),
         mediaType: normalizeScheduleMediaType(row.media_type),
+        widthPx: row.width_px,
+        heightPx: row.height_px,
+        durationSeconds: row.duration_seconds,
       };
     })
     .filter((r): r is AutoScheduleInputRow => r !== null);
diff --git a/backend/marketing/ingest-production-assets.ts b/backend/marketing/ingest-production-assets.ts
index 02481590..dd7d8edb 100644
--- a/backend/marketing/ingest-production-assets.ts
+++ b/backend/marketing/ingest-production-assets.ts
@@ -109,6 +109,12 @@ type CreativeAssetEntry = {
   path?: string;
   prompt?: string;
   placement?: string;
+  media_type?: string;
+  surface?: string;
+  width?: number;
+  height?: number;
+  duration_seconds?: number;
+  mime?: string;
   [key: string]: unknown;
 };
 
@@ -117,7 +123,10 @@ type CreativeAssetEntry = {
 // exclude video and story/reel/carousel placements.
 function isFrameEligibleEntry(asset: CreativeAssetEntry): boolean {
   const type = typeof asset.type === 'string' ? asset.type.trim().toLowerCase() : '';
-  if (type === 'video') return false;
+  const mediaType = typeof asset.media_type === 'string' ? asset.media_type.trim().toLowerCase() : '';
+  // Never composite a logo onto video (the new contract emits type
+  // 'generated_video' / media_type 'video'; legacy emitted type 'video').
+  if (type === 'video' || type === 'generated_video' || mediaType === 'video') return false;
   const placement = typeof asset.placement === 'string' ? asset.placement.trim().toLowerCase() : '';
   return placement === '' || placement === 'feed';
 }
@@ -171,20 +180,25 @@ export function resolveHermesAssetReadPath(reportedPath: string): string | null
 // 0 rows and the existing row keeps its ref — replay stays idempotent. The
 // partial unique index (WHERE checksum IS NOT NULL) is named so null-checksum
 // rows never collide. This mirrors story-composer.ts's INSERT_COMPOSED_ASSET_SQL.
+// Params: $1 tenantId, $2 jobId, $3 sourceAssetId, $4 storageKey, $5 checksum,
+// $6 variantBatchId, $7 variantIndex, $8 storageKind,
+// $9 mediaType, $10 aspectRatio, $11 widthPx, $12 heightPx, $13 durationSeconds
 const INSERT_PRODUCTION_ASSET_SQL = `
   INSERT INTO creative_assets (
     id, tenant_id, source_type, source_job_id, source_asset_id,
     storage_kind, storage_key, media_type,
     aspect_ratio, checksum, permission_scope,
     learning_lifecycle, usable_for_generation,
-    variant_batch_id, variant_index, served_asset_ref
+    variant_batch_id, variant_index, served_asset_ref,
+    width_px, height_px, duration_seconds
   )
   SELECT
     g.id, $1, 'generated_by_aries', $2, $3,
-    $8, $4, 'image',
-    '4:5', $5, 'generated',
+    $8, $4, $9,
+    $10, $5, 'generated',
     'observed', false,
-    $6, $7, '/api/internal/hermes/media/' || g.id::text
+    $6, $7, '/api/internal/hermes/media/' || g.id::text,
+    $11, $12, $13
   FROM (SELECT gen_random_uuid() AS id) g
   ON CONFLICT (tenant_id, checksum) WHERE checksum IS NOT NULL DO NOTHING
   RETURNING id
@@ -321,17 +335,52 @@ export async function ingestProductionCreativeAssetsToDb(
         ? asset.assetId.trim()
         : basename;
 
+      // Derive media type: 'video' when the entry carries video markers.
+      const isVideo =
+        asset.type === 'generated_video' ||
+        (typeof asset.media_type === 'string' && asset.media_type.trim().toLowerCase() === 'video');
+      const mediaType: 'image' | 'video' = isVideo ? 'video' : 'image';
+
+      // Derive aspect ratio from width/height when present; else from surface/placement.
+      const entryWidth = typeof asset.width === 'number' && Number.isFinite(asset.width) ? asset.width : null;
+      const entryHeight = typeof asset.height === 'number' && Number.isFinite(asset.height) ? asset.height : null;
+      const entryDuration =
+        typeof asset.duration_seconds === 'number' && Number.isFinite(asset.duration_seconds)
+          ? asset.duration_seconds
+          : null;
+
+      let aspectRatio: string;
+      if (entryWidth !== null && entryHeight !== null && entryWidth > 0 && entryHeight > 0) {
+        // Reduce to a simplified ratio string; map to nearest known where reasonable.
+        if (entryHeight > entryWidth) {
+          aspectRatio = '9:16';
+        } else {
+          aspectRatio = '4:5';
+        }
+      } else {
+        // Infer from surface / placement.
+        const surface = typeof asset.surface === 'string' ? asset.surface.trim().toLowerCase() : '';
+        const placement = typeof asset.placement === 'string' ? asset.placement.trim().toLowerCase() : '';
+        const isVertical = surface === 'reel' || surface === 'story' || placement === 'reel' || placement === 'story';
+        aspectRatio = isVertical ? '9:16' : '4:5';
+      }
+
       // served_asset_ref is built inside the INSERT from the row's own (subselect-
       // generated) id, so it is not passed as a parameter here.
       const result = await pool.query(INSERT_PRODUCTION_ASSET_SQL, [
-        tenantId,
-        jobId,
-        sourceAssetId,
-        storageKey,
-        checksum,
-        variantBatchId,
-        variantIndex,
-        storageKind,
+        tenantId,      // $1
+        jobId,         // $2
+        sourceAssetId, // $3
+        storageKey,    // $4
+        checksum,      // $5
+        variantBatchId, // $6
+        variantIndex,  // $7
+        storageKind,   // $8
+        mediaType,     // $9
+        aspectRatio,   // $10
+        entryWidth,    // $11
+        entryHeight,   // $12
+        entryDuration, // $13
       ]);
 
       const rowCount = result.rowCount ?? 0;
diff --git a/backend/marketing/ports/hermes.ts b/backend/marketing/ports/hermes.ts
index 575190b9..75e49461 100644
--- a/backend/marketing/ports/hermes.ts
+++ b/backend/marketing/ports/hermes.ts
@@ -245,6 +245,13 @@ const LAST30DAYS_GUIDANCE = [
 const PRODUCTION_EXECUTION_CONTRACT =
   'PRODUCTION STAGE EXECUTION CONTRACT: When the input contains "Production context (N images requested)", you MUST return BOTH content_package[] AND artifacts.creative_assets[]. One without the other is incomplete and will fail downstream publish. (A) Call the `image_generate` tool exactly once per image listed — do not return JSON until every image_generate call has completed. (B) Build content_package[] with one entry per post: {post_number, theme, hook, body, cta, hashtags (array of 3-6 relevant hashtags), platforms, format, visual_prompt}. The Nth creative_asset corresponds to the Nth content_package post via post_number. content_package carries the post COPY (caption text, hooks, hashtags). creative_assets carries the rendered IMAGES. Return output:[{stage:"production", content_package:[{post_number:1, theme:"...", hook:"...", body:"...", cta:"...", hashtags:["#tag1","#tag2","#tag3"], platforms:["instagram","facebook"], format:"single_image", visual_prompt:"..."},...], artifacts:{creative_assets:[{assetId:"img_1", type:"generated_image", path:<absolute path returned by image_generate>, prompt:<the rendered visual prompt>, placement:<which post number>}, ...], errors:[]}}]. If image_generate returns success:false for an item, record it in artifacts.errors[] and continue.';
 
+/** Instructs the production agent how to return video clips alongside images.
+ * Kept as a named export so workflow-request.ts can append it to the resume
+ * context block without re-stating the schema (single source of truth).
+ */
+export const VIDEO_EXECUTION_CONTRACT =
+  'VIDEO CLIP RETURN CONTRACT: If the input contains "Video clip N of M requested", produce one 9:16 vertical video per requested clip. Return each clip in artifacts.creative_assets[] alongside the image assets — do NOT skip failed clips, record them in artifacts.errors[] instead (resumability rule). Each video entry in creative_assets MUST include: {assetId:"vid_1", type:"generated_video", media_type:"video", surface:"reel"|"story"|"feed", path:"<basename of the localized mp4 written to the Hermes image-cache — NOT a remote CDN URL>", width:<integer px — MANDATORY>, height:<integer px — MANDATORY>, duration_seconds:<number — MANDATORY>, mime:"video/mp4", aspect_ratio:"9:16"}. Missing or null width/height/duration_seconds will fail closed at dispatch and the clip will not publish. Record render failures in artifacts.errors[] and continue.';
+
 /**
  * Per-stage instruction builders for the weekly social-content pipeline.
  *
@@ -282,6 +289,7 @@ function buildWeeklyProductionInstructions(workflowKey: string): string {
     'You are the Aries content-generation agent. You run ONLY the production stage of the weekly social content pipeline.',
     'Your job is to generate images and post copy. The input carries per-image prompt context and the strategy output.',
     PRODUCTION_EXECUTION_CONTRACT,
+    VIDEO_EXECUTION_CONTRACT,
     'After completing the production stage, return status "requires_approval" with approval.stage="publish", approval.approval_step="approve_publish", approval.workflowStepId="approve_stage_4", approval.prompt="Review creative assets before publish review", approval.resumeToken set, and output:[{stage:"production", ...artifacts}].',
     `Required schema: {"ok":true,"status":"requires_approval","workflowKey":"${workflowKey}","approval":{"stage":"publish","approval_step":"approve_publish","workflowStepId":"approve_stage_4","prompt":"...","resumeToken":"..."},"output":[{"stage":"production", ...}]}.`,
   ].join(' ');
diff --git a/backend/marketing/synthesize-publish-posts.ts b/backend/marketing/synthesize-publish-posts.ts
index 3141006d..8800288e 100644
--- a/backend/marketing/synthesize-publish-posts.ts
+++ b/backend/marketing/synthesize-publish-posts.ts
@@ -207,7 +207,7 @@ function readRequestedStoryCount(doc: SocialContentJobRuntimeDocument): number {
 }
 
 const SELECT_CREATIVE_ASSETS_SQL = `
-  SELECT id, source_asset_id
+  SELECT id, source_asset_id, width_px, height_px, duration_seconds
     FROM creative_assets
    WHERE tenant_id = $1
      AND source_job_id = $2
@@ -220,15 +220,19 @@ const SELECT_CREATIVE_ASSETS_SQL = `
 // calendar's unscheduled-approved backlog query (`published_status='approved'
 // OR status='approved'`) and are schedulable. See the module header for why
 // approved (not draft) is correct for this autonomous-mode deployment.
+// Params: $1 tenantId, $2 jobId, $3 publishRunId, $4 platform,
+// $5 caption, $6 idempotencyKey, $7 creativeAssetIds,
+// $8 mediaType, $9 surface, $10 styleDimension, $11 styleValue,
+// $12 widthPx, $13 heightPx, $14 durationSeconds
 const INSERT_SYNTHESIZED_POST_SQL = `
   INSERT INTO posts (
     tenant_id, job_id, hermes_run_id, platform, media_type,
     caption, status, published_status, idempotency_key, creative_asset_ids, surface,
-    style_dimension, style_value
+    style_dimension, style_value, width_px, height_px, duration_seconds
   ) VALUES (
     $1, $2, $3, $4, $8,
     $5, 'approved', 'approved', $6, $7, $9,
-    $10, $11
+    $10, $11, $12, $13, $14
   )
   ON CONFLICT (tenant_id, platform, idempotency_key) WHERE idempotency_key IS NOT NULL
   DO NOTHING
@@ -450,17 +454,26 @@ export async function synthesizePublishPostsFromContentPackage(
   // Pull the ingested creative_assets so each post can be linked to its image.
   // post_number N (1-indexed) maps to the Nth creative asset in source_asset_id
   // order — the same ordering ingestProductionCreativeAssetsToDb preserves.
-  let assetIdsByPostNumber = new Map<number, string>();
+  // Dims (width_px/height_px/duration_seconds) are threaded into posts rows so
+  // validateMediaForSurface has real metadata at dispatch time.
+  type AssetInfo = { assetId: string; widthPx: number | null; heightPx: number | null; durationSeconds: number | null };
+  let assetInfoByPostNumber = new Map<number, AssetInfo>();
   try {
     const result = await pool.query(SELECT_CREATIVE_ASSETS_SQL, [tenantId, jobId]);
     const rows = (result.rows ?? []) as Array<Record<string, unknown>>;
-    assetIdsByPostNumber = new Map(
+    assetInfoByPostNumber = new Map(
       rows.map((row, index) => {
         const assetId =
           typeof row.source_asset_id === 'string' && row.source_asset_id.trim()
             ? row.source_asset_id.trim()
             : String(row.id ?? '');
-        return [index + 1, assetId] as const;
+        const widthPx = typeof row.width_px === 'number' && Number.isFinite(row.width_px) ? row.width_px : null;
+        const heightPx = typeof row.height_px === 'number' && Number.isFinite(row.height_px) ? row.height_px : null;
+        const durationSeconds =
+          typeof row.duration_seconds === 'number' && Number.isFinite(row.duration_seconds)
+            ? row.duration_seconds
+            : null;
+        return [index + 1, { assetId, widthPx, heightPx, durationSeconds }] as const;
       }),
     );
   } catch (err) {
@@ -489,7 +502,8 @@ export async function synthesizePublishPostsFromContentPackage(
   let total = 0;
 
   for (const entry of entries) {
-    const assetId = assetIdsByPostNumber.get(entry.postNumber);
+    const assetInfo = assetInfoByPostNumber.get(entry.postNumber);
+    const assetId = assetInfo?.assetId;
     const creativeAssetIds = assetId ? [assetId] : [];
     for (const platform of entry.platforms) {
       // Resolve the publish shape (surface + media_type) for this post/platform
@@ -513,17 +527,20 @@ export async function synthesizePublishPostsFromContentPackage(
       const idempotencyKey = `${jobId}:${entry.postNumber}:${platform}:${shape.surface}`;
       try {
         const result = await pool.query(INSERT_SYNTHESIZED_POST_SQL, [
-          tenantId,
-          jobId,
-          publishRunId,
-          platform,
-          entry.caption,
-          idempotencyKey,
-          creativeAssetIds,
-          shape.mediaType,
-          shape.surface,
-          styleDimension,
-          styleValue,
+          tenantId,           // $1
+          jobId,              // $2
+          publishRunId,       // $3
+          platform,           // $4
+          entry.caption,      // $5
+          idempotencyKey,     // $6
+          creativeAssetIds,   // $7
+          shape.mediaType,    // $8
+          shape.surface,      // $9
+          styleDimension,     // $10
+          styleValue,         // $11
+          assetInfo?.widthPx ?? null,          // $12
+          assetInfo?.heightPx ?? null,         // $13
+          assetInfo?.durationSeconds ?? null,  // $14
         ]);
         if ((result.rowCount ?? 0) > 0) {
           inserted++;
@@ -563,7 +580,8 @@ export async function synthesizePublishPostsFromContentPackage(
   const storyBudget = readRequestedStoryCount(doc);
   if (storyBudget > 0) {
     for (const entry of entries.slice(0, storyBudget)) {
-      const assetId = assetIdsByPostNumber.get(entry.postNumber);
+      const assetInfo = assetInfoByPostNumber.get(entry.postNumber);
+      const assetId = assetInfo?.assetId;
       // A story is single-media with no text fallback. Skip entries with no
       // linked creative rather than emit a media-less story that would fail at
       // publish (publishInstagram requires >= 1 media url).
@@ -590,17 +608,20 @@ export async function synthesizePublishPostsFromContentPackage(
         const idempotencyKey = `${jobId}:${entry.postNumber}:${platform}:story`;
         try {
           const result = await pool.query(INSERT_SYNTHESIZED_POST_SQL, [
-            tenantId,
-            jobId,
-            publishRunId,
-            platform,
-            entry.caption,
-            idempotencyKey,
-            storyAssetIds,
-            'image',
-            'story',
-            styleDimension,
-            styleValue,
+            tenantId,        // $1
+            jobId,           // $2
+            publishRunId,    // $3
+            platform,        // $4
+            entry.caption,   // $5
+            idempotencyKey,  // $6
+            storyAssetIds,   // $7
+            'image',         // $8 media_type (story images are always image type)
+            'story',         // $9 surface
+            styleDimension,  // $10
+            styleValue,      // $11
+            null,            // $12 width_px (composed story image — dims not carried from base asset)
+            null,            // $13 height_px
+            null,            // $14 duration_seconds
           ]);
           if ((result.rowCount ?? 0) > 0) {
             inserted++;
diff --git a/backend/marketing/workspace-views.ts b/backend/marketing/workspace-views.ts
index f7e5856b..8b12ca47 100644
--- a/backend/marketing/workspace-views.ts
+++ b/backend/marketing/workspace-views.ts
@@ -1356,7 +1356,8 @@ function syncWorkspaceReviewsFromRuntime(
 }
 
 const SELECT_PRODUCTION_CREATIVE_ASSETS_SQL = `
-  SELECT id, source_asset_id, served_asset_ref, checksum
+  SELECT id, source_asset_id, served_asset_ref, checksum,
+         media_type, aspect_ratio, width_px, height_px, duration_seconds
     FROM creative_assets
    WHERE tenant_id = $1
      AND source_job_id = $2
@@ -1370,6 +1371,11 @@ type ProductionCreativeAssetRow = {
   source_asset_id: string | null;
   served_asset_ref: string | null;
   checksum: string | null;
+  media_type: string | null;
+  aspect_ratio: string | null;
+  width_px: number | null;
+  height_px: number | null;
+  duration_seconds: number | null;
 };
 
 async function queryProductionCreativeAssets(
@@ -1387,6 +1393,14 @@ async function queryProductionCreativeAssets(
         source_asset_id: typeof r.source_asset_id === 'string' ? r.source_asset_id : null,
         served_asset_ref: typeof r.served_asset_ref === 'string' ? r.served_asset_ref : null,
         checksum: typeof r.checksum === 'string' ? r.checksum : null,
+        media_type: typeof r.media_type === 'string' ? r.media_type : null,
+        aspect_ratio: typeof r.aspect_ratio === 'string' ? r.aspect_ratio : null,
+        width_px: typeof r.width_px === 'number' && Number.isFinite(r.width_px) ? r.width_px : null,
+        height_px: typeof r.height_px === 'number' && Number.isFinite(r.height_px) ? r.height_px : null,
+        duration_seconds:
+          typeof r.duration_seconds === 'number' && Number.isFinite(r.duration_seconds)
+            ? r.duration_seconds
+            : null,
       };
     });
   } catch (err) {
@@ -1554,17 +1568,19 @@ export async function buildSocialContentWorkspaceView(
     for (const row of dbProductionAssets) {
       const assetId = row.source_asset_id ?? row.id;
       if (existingAssetIds.has(assetId)) continue;
+      const isVideo = row.media_type === 'video';
       newDbAssets.push({
         reviewId: `${jobId}::creative:${assetId}`,
         reviewType: 'creative' as const,
         assetId,
-        title: 'Generated Image',
+        title: isVideo ? 'Generated Video' : 'Generated Image',
         summary: 'Production creative generated by Hermes.',
         platformLabel: 'Meta',
         status: 'approved' as const,
-        contentType: 'image/png',
+        contentType: isVideo ? 'video/mp4' : 'image/png',
         previewUrl: row.served_asset_ref,
         fullPreviewUrl: row.served_asset_ref,
+        posterUrl: null,
         destinationUrl: null,
         notes: [],
         latestNote: null,
diff --git a/backend/social-content/scheduled-posts.ts b/backend/social-content/scheduled-posts.ts
index 9b27064f..fc992586 100644
--- a/backend/social-content/scheduled-posts.ts
+++ b/backend/social-content/scheduled-posts.ts
@@ -26,6 +26,10 @@ export interface UpsertScheduledPostInput {
   surface?: 'feed' | 'story' | 'reel';
   /** Media type mirrored onto scheduled_posts (image|video). Default 'image'. */
   mediaType?: 'image' | 'video';
+  /** Per-media video dims mirrored onto scheduled_posts. NULL today. */
+  widthPx?: number | null;
+  heightPx?: number | null;
+  durationSeconds?: number | null;
   /**
    * UTC instant when publishing must stop for this row's parent campaign. NULL
    * means "no end date" -- the legacy weekly_social_content behaviour. Set by
@@ -50,14 +54,17 @@ export interface ScheduledPostRecord {
 // effect immediately; a row that goes from event_campaign back to weekly (rare,
 // future cancellation flow) correctly clears the end date.
 const UPSERT_SCHEDULED_POST_SQL = `
-  INSERT INTO scheduled_posts (post_id, tenant_id, scheduled_for, target_platforms, campaign_end_date, surface, media_type, updated_at)
-  VALUES ($1, $2, $3, $4, $5, $6, $7, now())
+  INSERT INTO scheduled_posts (post_id, tenant_id, scheduled_for, target_platforms, campaign_end_date, surface, media_type, width_px, height_px, duration_seconds, updated_at)
+  VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, now())
   ON CONFLICT (post_id) DO UPDATE
     SET scheduled_for = EXCLUDED.scheduled_for,
         target_platforms = EXCLUDED.target_platforms,
         campaign_end_date = EXCLUDED.campaign_end_date,
         surface = EXCLUDED.surface,
         media_type = EXCLUDED.media_type,
+        width_px = EXCLUDED.width_px,
+        height_px = EXCLUDED.height_px,
+        duration_seconds = EXCLUDED.duration_seconds,
         updated_at = now()
     WHERE scheduled_posts.tenant_id = EXCLUDED.tenant_id
   RETURNING id, post_id, tenant_id, scheduled_for, target_platforms, updated_at
@@ -79,6 +86,9 @@ export async function upsertScheduledPost(
     input.campaignEndDate ? input.campaignEndDate.toISOString() : null,
     input.surface ?? 'feed',
     input.mediaType ?? 'image',
+    input.widthPx ?? null,
+    input.heightPx ?? null,
+    input.durationSeconds ?? null,
   ]);
   if ((result.rowCount ?? result.rows.length) === 0 || result.rows.length === 0) {
     // Tenant guard: WHERE clause prevented update; surface typed error so
diff --git a/backend/social-content/workflow-request.ts b/backend/social-content/workflow-request.ts
index 2619c4a6..cee0f557 100644
--- a/backend/social-content/workflow-request.ts
+++ b/backend/social-content/workflow-request.ts
@@ -262,12 +262,33 @@ export type ProductionResumeImagePrompt = {
   targetChannels: string[];
 };
 
+export type ProductionResumeVideoPrompt = {
+  clipIndex: number; // 1-based
+  totalClips: number;
+  prompt: string;
+  aspectRatio: '9:16';
+  targetDurationSeconds: number;
+};
+
 export type ProductionResumeContext = {
   imagePrompts: ProductionResumeImagePrompt[];
+  /** Non-empty only when ARIES_VIDEO_PUBLISH_ENABLED is on and videoClipCount > 0. */
+  videoPrompts?: ProductionResumeVideoPrompt[];
   /** Serialised block ready to append to the Hermes resume `input` string. */
   contextBlock: string;
 };
 
+/**
+ * Gate for video clip production in the resume context. Mirrors the rollout
+ * switch used by synthesize-publish-posts.ts (ARIES_VIDEO_PUBLISH_ENABLED).
+ * Defense-in-depth: ensures video briefs are never emitted when the feature
+ * flag is OFF, even if videoRenderCount was misconfigured as non-zero.
+ */
+function isVideoPublishEnabledForContext(): boolean {
+  const raw = (process.env.ARIES_VIDEO_PUBLISH_ENABLED ?? '').trim().toLowerCase();
+  return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+
 /**
  * Builds per-image prompt context for the production-stage resume call.
  *
@@ -374,6 +395,17 @@ export function buildProductionResumeContext(input: {
   );
   const totalImages = Math.max(1, imageCreativeCount);
 
+  // Video clip count: gated by ARIES_VIDEO_PUBLISH_ENABLED (defense-in-depth so
+  // a rendered clip is never left stranded when the gate is OFF). Default is 0
+  // per SOCIAL_CONTENT_DEFAULT_SCOPE, so the flag-OFF path is byte-identical.
+  const videoClipCount = isVideoPublishEnabledForContext()
+    ? clampCount(
+        req.videoRenderCount ?? req.renderVideoCount,
+        SOCIAL_CONTENT_DEFAULT_SCOPE.video_render_count,
+        MAX_VIDEO_RENDER_COUNT,
+      )
+    : 0;
+
   // --- channel aspect-ratio human hint ---
   const aspectHintByChannel: Record<string, string> = {
     instagram: 'portrait 4:5',
@@ -507,6 +539,70 @@ export function buildProductionResumeContext(input: {
     });
   }
 
+  // --- per-video-clip prompt construction (gated by ARIES_VIDEO_PUBLISH_ENABLED) ---
+  // When videoClipCount === 0 (default, flag OFF) this block is entirely inert
+  // and produces no output — preserving byte-identical contextBlock behavior.
+  const videoPrompts: ProductionResumeVideoPrompt[] = [];
+  if (videoClipCount > 0) {
+    const videoAspectRatio = resolveSocialContentAspectRatio({ channel: primaryChannel, postType: 'video' });
+    for (let i = 0; i < videoClipCount; i++) {
+      const clipIndex = i + 1;
+      const vlines: string[] = [
+        `Generate a short-form vertical video for social media content.`,
+        `This is video clip ${clipIndex} of ${videoClipCount}, part of the same ${windowDays}-day weekly campaign.`,
+        ``,
+        `Brand: ${brandName}`,
+      ];
+      if (offer) vlines.push(`Offer: ${offer}`);
+      if (effectiveBrandVoice) vlines.push(`Brand voice: ${effectiveBrandVoice.slice(0, 200)}`);
+      if (effectiveStyleVibe) vlines.push(`Style and vibe: ${effectiveStyleVibe}`);
+      if (palette.length > 0) vlines.push(`Brand palette: ${palette.join(', ')}`);
+      if (tasteAudienceLine) vlines.push(tasteAudienceLine);
+      if (brandMode === 'dark') {
+        const bg = brandBackground || '#050505';
+        vlines.push(
+          `CRITICAL BRAND REQUIREMENT — this is a DARK-themed brand. The video MUST have a dark, near-black background (${bg}). Use the brand palette as glowing accents; avoid bright/white/light/studio backgrounds.`,
+        );
+      } else if (brandMode === 'light') {
+        vlines.push(
+          `Brand theme: light. Render on a light background${brandBackground ? ` (${brandBackground})` : ''} consistent with the brand.`,
+        );
+      } else if (brandBackground) {
+        vlines.push(`Brand background: ${brandBackground} — keep backgrounds consistent with this brand color.`);
+      }
+      if (brandLogoUrl) {
+        vlines.push(
+          `Brand logo: ${brandLogoUrl} — use the actual brand logo when a mark is shown; do NOT invent, redraw, or substitute a different logo.`,
+        );
+      }
+      if (effectiveMustAvoid.length > 0) vlines.push(`Must avoid: ${effectiveMustAvoid.join(', ')}`);
+
+      if (researchLines.length > 0) {
+        vlines.push('');
+        vlines.push('Brand and audience research:');
+        vlines.push(...researchLines);
+      }
+
+      if (strategyLines.length > 0) {
+        vlines.push('');
+        vlines.push('Creative strategy:');
+        vlines.push(...strategyLines);
+      }
+
+      vlines.push('');
+      vlines.push(`Aspect ratio: ${videoAspectRatio} (vertical 9:16 — optimised for Reels and Stories).`);
+      vlines.push(`Target duration: ~15 seconds (must be between 3 and 90 seconds).`);
+
+      videoPrompts.push({
+        clipIndex,
+        totalClips: videoClipCount,
+        prompt: vlines.filter((l, i) => l !== '' || vlines[i - 1] !== '').join('\n'),
+        aspectRatio: '9:16',
+        targetDurationSeconds: 15,
+      });
+    }
+  }
+
   // --- serialised context block ---
   const contextLines: string[] = [
     `Production context (${totalImages} image${totalImages === 1 ? '' : 's'} requested):`,
@@ -515,6 +611,12 @@ export function buildProductionResumeContext(input: {
     contextLines.push(`--- Image ${img.imageIndex} of ${img.totalImages} ---`);
     contextLines.push(img.prompt);
   }
+  // Video clip prompts are emitted inline after image prompts so the agent sees
+  // all context in one block. Empty when videoClipCount === 0 (byte-identical).
+  for (const vp of videoPrompts) {
+    contextLines.push(`--- Video clip ${vp.clipIndex} of ${vp.totalClips} ---`);
+    contextLines.push(vp.prompt);
+  }
   contextLines.push('');
   contextLines.push('Return your results in this EXACT JSON shape. You MUST include BOTH content_package[] AND artifacts.creative_assets[]. One without the other is incomplete — content_package carries the post COPY (caption text, hooks, hashtags); creative_assets carries the rendered IMAGES. The Nth creative_asset corresponds to the Nth content_package entry via post_number.');
   contextLines.push('');
@@ -551,9 +653,29 @@ export function buildProductionResumeContext(input: {
   contextLines.push('}');
   contextLines.push('');
   contextLines.push('The bridge will also accept `artifacts.images[]` with `{index, status:"generated", filePath, prompt, intendedUse}`, but `creative_assets` is preferred.');
+  // Video return schema — only emitted when videoClipCount > 0 so the
+  // contextBlock is byte-identical to today when video is OFF (default).
+  if (videoClipCount > 0) {
+    contextLines.push('');
+    contextLines.push('Required: when you finish video generation, place each clip in artifacts.creative_assets[] alongside the images, with this shape:');
+    contextLines.push('{');
+    contextLines.push('  "assetId": "vid_1",');
+    contextLines.push('  "type": "generated_video",');
+    contextLines.push('  "media_type": "video",');
+    contextLines.push('  "surface": "reel",');
+    contextLines.push('  "path": "<basename of the localized mp4 in the Hermes image-cache mount — NOT a remote URL>",');
+    contextLines.push('  "width": 1080,');
+    contextLines.push('  "height": 1920,');
+    contextLines.push('  "duration_seconds": 15,');
+    contextLines.push('  "mime": "video/mp4",');
+    contextLines.push('  "aspect_ratio": "9:16"');
+    contextLines.push('}');
+    contextLines.push('MANDATORY: width, height, and duration_seconds must be present and numeric — absent or null fails dispatch. Record failed renders in artifacts.errors[] — never discard a completed clip.');
+  }
 
   return {
     imagePrompts,
+    ...(videoPrompts.length > 0 ? { videoPrompts } : {}),
     contextBlock: contextLines.join('\n'),
   };
 }
diff --git a/docker-compose.yml b/docker-compose.yml
index 3bdd9146..828f8219 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -233,6 +233,8 @@ services:
       COMPOSIO_INSTAGRAM_PUBLISH_POST_ACTION: ${COMPOSIO_INSTAGRAM_PUBLISH_POST_ACTION:-}
       COMPOSIO_FACEBOOK_UPLOAD_MEDIA_ACTION: ${COMPOSIO_FACEBOOK_UPLOAD_MEDIA_ACTION:-}
       COMPOSIO_INSTAGRAM_UPLOAD_MEDIA_ACTION: ${COMPOSIO_INSTAGRAM_UPLOAD_MEDIA_ACTION:-}
+      COMPOSIO_FACEBOOK_PUBLISH_VIDEO_ACTION: ${COMPOSIO_FACEBOOK_PUBLISH_VIDEO_ACTION:-}
+      COMPOSIO_INSTAGRAM_ACCOUNT_INFO_ACTION: ${COMPOSIO_INSTAGRAM_ACCOUNT_INFO_ACTION:-}
       # In-app feedback button — Google Sheet mirror. The feedback API runs in the
       # app process, so these live here only. Mirror activates only when
       # COMPOSIO_ENABLED=true AND all four are set in the prod host .env; otherwise
diff --git a/docs/plans/2026-06-23-video-generation.md b/docs/plans/2026-06-23-video-generation.md
new file mode 100644
index 00000000..7615777a
--- /dev/null
+++ b/docs/plans/2026-06-23-video-generation.md
@@ -0,0 +1,143 @@
+# Video Generation — Hermes return contract + Aries-side wiring
+
+Date: 2026-06-23
+Companion to `docs/plans/2026-05-30-story-reel-video-publishing.md` (the publish epic).
+
+## Goal
+
+Close the loop so Aries can generate short-form vertical video (Reels / Stories /
+feed video) for the weekly social-content pipeline and publish it to Instagram +
+Facebook. The **publish** half (Meta Graph video branches + per-surface
+validation) already existed behind `ARIES_VIDEO_PUBLISH_ENABLED`; this work builds
+the missing **generation → ingest → synthesize → publish-metadata** half.
+
+Provider decision: **video is generated by Grok / xAI (Grok Imagine)**, invoked by
+Hermes. Aries never calls Grok directly and never names the tool — Aries sends a
+high-level "generate a 9:16 video for this post" instruction and Hermes routes to
+its own video tool. Prod publish goes through **Composio** (a new FB/IG video
+branch), consistent with the all-Composio prod policy.
+
+## The contract Hermes must honor (load-bearing — the whole feature rides on it)
+
+On the **production** stage, Hermes emits video assets in the **same**
+`doc.stages.production.primary_output.artifacts.creative_assets[]` array as images,
+extending the existing image shape `{assetId, type, path, prompt, placement}`:
+
+| field | type | required | notes |
+|---|---|---|---|
+| `assetId` | string | yes | stable id (becomes `creative_assets.source_asset_id`) |
+| `type` | string | yes | **`"generated_video"`** (image is `"generated_image"`) |
+| `media_type` | string | yes | **`"video"`** — drives the `creative_assets.media_type` column + all downstream validation |
+| `surface` | string | yes | **`"reel"` \| `"story"` \| `"feed"`** — drives aspect/duration validation |
+| `path` | string | yes | **basename** of an mp4 written into the Hermes image-cache mount (e.g. `"weekly_primary_reel_1.mp4"`); resolved via `<HERMES_IMAGE_CACHE_MOUNT>/<basename>`. Must end `.mp4`/`.mov` |
+| `prompt` | string | yes | generation prompt |
+| `placement` | number\|string | yes | maps to the `content_package` `post_number` |
+| `width` | integer | **yes** | pixels — `validateMediaForSurface` fails closed if missing |
+| `height` | integer | **yes** | pixels — fails closed if missing |
+| `duration_seconds` | number | **yes** | seconds — reel **3–90**, story **≤60**, feed **3–60**; fails closed if missing/≤0 |
+| `mime` | string | recommended | `"video/mp4"` |
+| `aspect_ratio` | string | optional | `"9:16"` for reel/story; Aries derives from width/height if omitted |
+| `cover_path` | string | optional | basename of a poster JPG/PNG in the same mount → dashboard `<video poster>` |
+
+Failed renders go in `artifacts.errors[]` (resumability rule — never discard
+completed clips on a partial failure).
+
+### Two hard requirements
+
+1. **Localize the mp4** into the image-cache mount and report the *basename* —
+   NOT an expiring Grok CDN URL. Composio rejects media URLs with query
+   strings/redirects (signed CDN URLs) for both the IG container and FB
+   `file_url`, and localizing reuses the proven image-serving + checksum-idempotency
+   + tenant-isolation machinery. (`external_url` remains a documented fallback only.)
+2. **`width` / `height` / `duration_seconds` are mandatory.** Every video surface
+   fails closed in `meta-media-validation.ts` without them.
+
+### Two-place agreement
+
+The value Aries *publishes off* is the **publish-stage schedule entry**
+(`doc.stages.publish.primary_output.schedule[].placement` / `.media_type`, read by
+`synthesize-publish-posts.ts`). For a given `post_number`, the `creative_assets[]`
+`surface`/`media_type` here and the publish-stage schedule entry **must agree** (a
+reel asset needs a `placement=reel` / `media_type=video` schedule entry) or the
+post synthesizes as an image and the video is never published.
+
+### Concrete example — one reel asset
+
+```json
+{
+  "content_package": [
+    { "post_number": 1, "platform": "instagram", "caption": "Behind the seams…", "placement": "reel", "media_type": "video" }
+  ],
+  "artifacts": {
+    "creative_assets": [
+      {
+        "assetId": "weekly_primary_reel_1",
+        "type": "generated_video",
+        "media_type": "video",
+        "surface": "reel",
+        "path": "weekly_primary_reel_1.mp4",
+        "prompt": "Vertical 9:16 cinematic product reveal, dark #050505 background, purple accent lighting, 15s, no on-screen text.",
+        "placement": 1,
+        "width": 1080,
+        "height": 1920,
+        "duration_seconds": 15,
+        "mime": "video/mp4",
+        "aspect_ratio": "9:16",
+        "cover_path": "weekly_primary_reel_1_cover.jpg"
+      }
+    ],
+    "errors": []
+  }
+}
+```
+
+## Aries-side state (this branch)
+
+Foundation + generation/ingest half are implemented and reviewer-approved; the
+Composio publish branch is the remaining Aries slice.
+
+- **Schema** — `width_px` / `height_px` / `duration_seconds` (INTEGER, nullable) on
+  `creative_assets`, `posts`, `scheduled_posts` (init-db + `migrations/20260623120000_video_media_metadata.sql`).
+- **Publish back-half threading** — `mediaMetadata` flows
+  `scheduled_posts` → scheduled-posts-worker → scheduled-dispatch route →
+  `dispatchPublish` → `publishToMetaGraph` (direct + Composio seam). Built only for
+  a video surface with all three dims present; never fabricated.
+- **Ingest** (`ingest-production-assets.ts`) — branches on
+  `type==='generated_video'` / `media_type==='video'`: writes `media_type='video'`,
+  a real `aspect_ratio`, and `width_px`/`height_px`/`duration_seconds`; reuses the
+  local-cache read path. Logo-composite is skipped for video.
+- **Synthesize** (`synthesize-publish-posts.ts`) — copies the linked asset's dims
+  onto the `posts` row so the threading above has real values.
+- **Outbound request** (`ports/hermes.ts` `VIDEO_EXECUTION_CONTRACT` +
+  `workflow-request.ts` per-clip brief) — high-level, no tool name; gated on
+  `ARIES_VIDEO_PUBLISH_ENABLED` + `videoRenderCount>0`; **byte-identical when off**.
+- **Dashboard read** (`workspace-views.ts`) — video rows map to `video/mp4` /
+  "Generated Video"; the shared `MediaPreview`/`VideoPreview` already render `<video>`.
+- **Manual schedule route** — threads the three dims (parity with auto-schedule).
+
+### Remaining Aries slice (in progress)
+
+- **Composio video publish branch** (`composio-publisher-provider.ts`,
+  `composio-config.ts`): IG two-step container+publish
+  (`INSTAGRAM_POST_IG_USER_MEDIA` → `INSTAGRAM_POST_IG_USER_MEDIA_PUBLISH`) with
+  `media_type` REELS (feed-video `share_to_feed=true` / reel) / STORIES, and FB
+  feed-video via a new `publish_video` op (`FACEBOOK_CREATE_VIDEO_POST`). This is
+  also the first **correct** IG publish path (the prior single-call IG branch
+  matched no real Composio action). Calls `validateMediaForSurface` pre-publish.
+  - **Composio coverage limit:** IG feed-video / Reel / Story + FB **feed-video**
+    are real. FB Reel and FB Story are NOT distinct Composio actions (both collapse
+    to a normal Page video) — out of scope for v1.
+
+## Gate to flip `ARIES_VIDEO_PUBLISH_ENABLED=1` (deferred)
+
+All required:
+
+1. Hermes emits the contract above (`media_type:'video'` + per-asset
+   width/height/duration + a localized mp4). **External dependency (Hermes repo).**
+2. A Meta IG Business account is linked to the FB Page (issue #691) for IG live
+   verification — IG video is code-complete-but-dormant until then.
+3. `ARIES_VIDEO_PUBLISH_ENABLED=1` set in **both** prod `.env` and the `aries-app`
+   `environment:` block; `COMPOSIO_FACEBOOK_PUBLISH_VIDEO_ACTION` + the IG two-step
+   action keys set.
+4. One weekly job with `videoRenderCount=1` verified end-to-end, ending in a
+   `<video>` rendering in the dashboard (only rendered UI counts as done).
diff --git a/frontend/aries-v1/post-workspace.tsx b/frontend/aries-v1/post-workspace.tsx
index 433deb93..4ca77307 100644
--- a/frontend/aries-v1/post-workspace.tsx
+++ b/frontend/aries-v1/post-workspace.tsx
@@ -1029,6 +1029,7 @@ function CreativeReviewSurface(props: {
                   src={asset.fullPreviewUrl || asset.previewUrl}
                   alt={asset.title}
                   contentType={asset.contentType}
+                  poster={asset.posterUrl ?? undefined}
                   className="min-h-[24rem] overflow-hidden rounded-[1.2rem] border border-white/8 bg-black/20"
                   imageClassName="h-full w-full object-contain bg-black/40"
                   emptyLabel="Preview pending"
diff --git a/frontend/aries-v1/review-item.tsx b/frontend/aries-v1/review-item.tsx
index c907e3a6..fce17620 100644
--- a/frontend/aries-v1/review-item.tsx
+++ b/frontend/aries-v1/review-item.tsx
@@ -449,6 +449,7 @@ export default function AriesReviewItemScreen(props: { reviewId: string; initial
                   src={reviewItem.fullPreviewUrl || reviewItem.previewUrl || null}
                   alt={reviewItem.title}
                   contentType={reviewItem.contentType || null}
+                  poster={reviewItem.posterUrl ?? undefined}
                   href={reviewItem.fullPreviewUrl || reviewItem.previewUrl || null}
                   className="min-h-[24rem] overflow-hidden rounded-[1.2rem] border border-white/8 bg-black/20"
                   imageClassName="h-full w-full object-contain bg-black"
diff --git a/lib/api/aries-v1.ts b/lib/api/aries-v1.ts
index e281806b..95e1169f 100644
--- a/lib/api/aries-v1.ts
+++ b/lib/api/aries-v1.ts
@@ -129,6 +129,8 @@ export type RuntimeReviewItem = {
   contentType?: string | null;
   previewUrl?: string | null;
   fullPreviewUrl?: string | null;
+  /** Optional poster/thumbnail URL for video review items. Null for images. */
+  posterUrl?: string | null;
   destinationUrl?: string | null;
   sections: MarketingReviewSection[];
   attachments: MarketingReviewAttachment[];
diff --git a/lib/api/marketing.ts b/lib/api/marketing.ts
index 349f3f24..7379b2d4 100644
--- a/lib/api/marketing.ts
+++ b/lib/api/marketing.ts
@@ -365,6 +365,8 @@ export interface MarketingCreativeAssetReviewPayload {
   contentType: string | null;
   previewUrl: string | null;
   fullPreviewUrl: string | null;
+  /** Optional poster/thumbnail URL for video assets. Null for images. */
+  posterUrl?: string | null;
   destinationUrl: string | null;
   notes: string[];
   latestNote: string | null;
diff --git a/migrations/20260623120000_video_media_metadata.sql b/migrations/20260623120000_video_media_metadata.sql
new file mode 100644
index 00000000..66a022cc
--- /dev/null
+++ b/migrations/20260623120000_video_media_metadata.sql
@@ -0,0 +1,23 @@
+-- Video media metadata: add explicit width_px / height_px / duration_seconds
+-- columns to the three publish-path tables so a video surface has somewhere to
+-- store the dimensions + duration meta-media-validation.ts hard-requires
+-- (widthPx/heightPx/durationSeconds) for any reel / story-video / feed-video.
+-- duration_seconds is INTEGER to match insights_posts.duration_seconds (INT).
+--
+-- Additive + idempotent (ADD COLUMN IF NOT EXISTS, all nullable). Population of
+-- these columns (ingest -> creative_assets, synthesize -> posts) is a separate
+-- deferred follow-up; this migration only creates the storage.
+-- Applied via scripts/init-db.js on fresh DBs; run manually on existing ones.
+-- Reverse: ALTER TABLE <t> DROP COLUMN duration_seconds, DROP COLUMN height_px, DROP COLUMN width_px;
+
+ALTER TABLE creative_assets ADD COLUMN IF NOT EXISTS width_px INTEGER;
+ALTER TABLE creative_assets ADD COLUMN IF NOT EXISTS height_px INTEGER;
+ALTER TABLE creative_assets ADD COLUMN IF NOT EXISTS duration_seconds INTEGER;
+
+ALTER TABLE posts ADD COLUMN IF NOT EXISTS width_px INTEGER;
+ALTER TABLE posts ADD COLUMN IF NOT EXISTS height_px INTEGER;
+ALTER TABLE posts ADD COLUMN IF NOT EXISTS duration_seconds INTEGER;
+
+ALTER TABLE scheduled_posts ADD COLUMN IF NOT EXISTS width_px INTEGER;
+ALTER TABLE scheduled_posts ADD COLUMN IF NOT EXISTS height_px INTEGER;
+ALTER TABLE scheduled_posts ADD COLUMN IF NOT EXISTS duration_seconds INTEGER;
diff --git a/scripts/automations/scheduled-posts-worker.mjs b/scripts/automations/scheduled-posts-worker.mjs
index 3ea0c37d..ce5ee39f 100644
--- a/scripts/automations/scheduled-posts-worker.mjs
+++ b/scripts/automations/scheduled-posts-worker.mjs
@@ -69,6 +69,7 @@ function buildPool() {
 // we cannot un-call it).
 export const CLAIM_ROW_SQL = `SELECT sp.id, sp.post_id, sp.tenant_id, sp.target_platforms,
             sp.surface, sp.media_type,
+            sp.width_px, sp.height_px, sp.duration_seconds,
             p.caption, p.platform_post_id
      FROM scheduled_posts sp
      LEFT JOIN posts p ON p.id = sp.post_id
@@ -280,6 +281,9 @@ async function dispatchWithRetry(row, baseUrl, secret) {
     // image/video correctly. Default to feed/image for legacy rows.
     surface: typeof row.surface === 'string' ? row.surface : 'feed',
     media_type: typeof row.media_type === 'string' ? row.media_type : 'image',
+    width_px: row.width_px ?? null,
+    height_px: row.height_px ?? null,
+    duration_seconds: row.duration_seconds ?? null,
   });
 
   const headers = {
diff --git a/scripts/init-db.js b/scripts/init-db.js
index 577ffc64..bb912cb2 100644
--- a/scripts/init-db.js
+++ b/scripts/init-db.js
@@ -288,6 +288,9 @@ async function initDb() {
         updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
         variant_batch_id TEXT,
         variant_index INTEGER,
+        width_px INTEGER,
+        height_px INTEGER,
+        duration_seconds INTEGER,
         UNIQUE (tenant_id, id),
         CONSTRAINT creative_assets_exact_image_text_generation_check CHECK (media_type <> 'image' OR usable_for_generation = FALSE OR learning_lifecycle <> 'approved_for_generation' OR array_length(exact_image_text, 1) IS NOT NULL),
         CONSTRAINT creative_assets_competitor_not_usable_check CHECK ((source_type <> 'competitor_meta_ad' AND permission_scope <> 'public_ad_library') OR usable_for_generation = FALSE)
@@ -443,6 +446,9 @@ async function initDb() {
       ALTER TABLE creative_assets ADD COLUMN IF NOT EXISTS learning_lifecycle TEXT NOT NULL DEFAULT 'observed';
       ALTER TABLE creative_assets ADD COLUMN IF NOT EXISTS variant_batch_id TEXT;
       ALTER TABLE creative_assets ADD COLUMN IF NOT EXISTS variant_index INTEGER;
+      ALTER TABLE creative_assets ADD COLUMN IF NOT EXISTS width_px INTEGER;
+      ALTER TABLE creative_assets ADD COLUMN IF NOT EXISTS height_px INTEGER;
+      ALTER TABLE creative_assets ADD COLUMN IF NOT EXISTS duration_seconds INTEGER;
       ALTER TABLE prompt_recipes ADD COLUMN IF NOT EXISTS context_pack JSONB NOT NULL DEFAULT '{}'::jsonb;
       ALTER TABLE generated_assets ADD COLUMN IF NOT EXISTS creative_asset_id UUID;
       ALTER TABLE generated_assets ADD COLUMN IF NOT EXISTS variant_kind TEXT NOT NULL DEFAULT 'memory_assisted';
@@ -562,6 +568,9 @@ async function initDb() {
       -- taste producers. See migrations/20260609000000_marketing_taste_tenant_scoped.sql.
       ALTER TABLE posts ADD COLUMN IF NOT EXISTS style_dimension TEXT;
       ALTER TABLE posts ADD COLUMN IF NOT EXISTS style_value TEXT;
+      ALTER TABLE posts ADD COLUMN IF NOT EXISTS width_px INTEGER;
+      ALTER TABLE posts ADD COLUMN IF NOT EXISTS height_px INTEGER;
+      ALTER TABLE posts ADD COLUMN IF NOT EXISTS duration_seconds INTEGER;
 
       -- Vision QA runs table for brand compliance checks
       CREATE TABLE IF NOT EXISTS vision_qa_runs (
@@ -645,6 +654,9 @@ async function initDb() {
       ALTER TABLE scheduled_posts ADD COLUMN IF NOT EXISTS media_type TEXT NOT NULL DEFAULT 'image';
       ALTER TABLE scheduled_posts DROP CONSTRAINT IF EXISTS scheduled_posts_media_type_check;
       ALTER TABLE scheduled_posts ADD CONSTRAINT scheduled_posts_media_type_check CHECK (media_type IN ('image','video'));
+      ALTER TABLE scheduled_posts ADD COLUMN IF NOT EXISTS width_px INTEGER;
+      ALTER TABLE scheduled_posts ADD COLUMN IF NOT EXISTS height_px INTEGER;
+      ALTER TABLE scheduled_posts ADD COLUMN IF NOT EXISTS duration_seconds INTEGER;
 
       CREATE INDEX IF NOT EXISTS idx_posts_tenant_created ON posts (tenant_id, created_at DESC);
       CREATE INDEX IF NOT EXISTS idx_vision_qa_runs_tenant_post ON vision_qa_runs (tenant_id, post_id);
diff --git a/tests/composio-publisher.test.ts b/tests/composio-publisher.test.ts
index c1f54b15..bd65e76e 100644
--- a/tests/composio-publisher.test.ts
+++ b/tests/composio-publisher.test.ts
@@ -202,15 +202,219 @@ test('#624 FB publishPost with null external_account_id and no page returned thr
   );
 });
 
-test('#624 IG publishPost sends `caption` (not `message`) and no `page_id`', async () => {
-  const gateway = fakeGateway({ executeResult: { data: { id: 'ig_post_42' }, successful: true, error: null } });
-  const provider = new ComposioPublisherProvider(gateway, fakeConfig({ actions: { publish_post: 'IG_POST' } }), fakeDb());
-  await provider.publishPost({ tenantId, platform: 'instagram', content: 'Hello IG', mediaUrls: ['img.jpg'], approved: true });
+// ── IG two-step publish (container → publish) ───────────────────────────────
+//
+// The legacy single-call IG branch (one executeTool with media_urls+placement)
+// matched no real Composio action and never published live, so it was rewritten
+// to the real two-step: INSTAGRAM_POST_IG_USER_MEDIA (container → creation_id)
+// then INSTAGRAM_POST_IG_USER_MEDIA_PUBLISH (creation_id → ig_media_id).
+
+test('IG feed image publishPost is a two-step container→publish (caption on container, ig_user_id, no page_id)', async () => {
+  const gateway = fakeGateway({ executeResult: { data: { id: 'ig_42' }, successful: true, error: null } });
+  const provider = new ComposioPublisherProvider(
+    gateway,
+    // Both slots configured; fakeDb default external_account_id='ext_1' is the IG
+    // user id, so the INSTAGRAM_GET_USER_INFO resolver is skipped entirely.
+    fakeConfig({ actions: { upload_media: 'IG_CONTAINER', publish_post: 'IG_PUBLISH' } }),
+    fakeDb(),
+  );
+  const result = await provider.publishPost({
+    tenantId,
+    platform: 'instagram',
+    content: 'Hello IG',
+    mediaUrls: ['https://cdn.example.com/img.jpg'],
+    approved: true,
+  });
+
+  assert.equal(gateway.calls.length, 2, 'two-step: container then publish');
+
+  const container = gateway.calls[0];
+  assert.equal(container.slug, 'IG_CONTAINER', 'step 1 uses the upload_media (container) slug');
+  const cArgs = container.options.arguments as Record<string, unknown>;
+  assert.equal(cArgs.caption, 'Hello IG', 'caption rides the container');
+  assert.equal(cArgs.image_url, 'https://cdn.example.com/img.jpg', 'feed image uses image_url');
+  assert.equal(cArgs.ig_user_id, 'ext_1', 'ig_user_id from stored external_account_id');
+  assert.equal(cArgs.video_url,  undefined, 'no video_url for an image');
+  assert.equal(cArgs.media_type, undefined, 'no media_type for a single feed image (IG defaults to IMAGE)');
+  assert.equal(cArgs.page_id,    undefined, 'no page_id for Instagram');
+  assert.equal(cArgs.message,    undefined, 'no message for Instagram');
+  assert.equal(cArgs.media_urls, undefined, 'the broken media_urls array shape is gone');
+
+  const publish = gateway.calls[1];
+  assert.equal(publish.slug, 'IG_PUBLISH', 'step 2 uses the publish_post slug');
+  const pArgs = publish.options.arguments as Record<string, unknown>;
+  assert.equal(pArgs.creation_id, 'ig_42', 'publish references the container creation id');
+  assert.equal(pArgs.ig_user_id, 'ext_1', 'publish carries ig_user_id');
+
+  assert.equal(result.externalPostId, 'ig_42', 'externalPostId is the published media id');
+  assert.equal(result.status, 'published');
+});
+
+test('IG reel video container uses video_url + media_type=REELS', async () => {
+  const gateway = fakeGateway({ executeResult: { data: { id: 'ig_reel_1' }, successful: true, error: null } });
+  const provider = new ComposioPublisherProvider(
+    gateway,
+    fakeConfig({ actions: { upload_media: 'IG_CONTAINER', publish_post: 'IG_PUBLISH' } }),
+    fakeDb(),
+  );
+  await provider.publishPost({
+    tenantId,
+    platform: 'instagram',
+    content: 'reel caption',
+    mediaUrls: ['https://cdn.example.com/reel.mp4'],
+    placement: 'reel',
+    mediaType: 'video',
+    mediaMetadata: [{ widthPx: 1080, heightPx: 1920, durationSeconds: 30 }],
+    approved: true,
+  });
+
+  const cArgs = gateway.calls[0].options.arguments as Record<string, unknown>;
+  assert.equal(cArgs.video_url, 'https://cdn.example.com/reel.mp4', 'reel uses video_url');
+  assert.equal(cArgs.media_type, 'REELS', 'reel container media_type=REELS');
+  assert.equal(cArgs.share_to_feed, undefined, 'a pure reel does not force share_to_feed');
+  assert.equal(cArgs.image_url, undefined, 'no image_url for a video');
+});
+
+test('IG feed video → REELS + share_to_feed=true; story video → STORIES', async () => {
+  const meta = [{ widthPx: 1080, heightPx: 1920, durationSeconds: 20 }];
+
+  const feedGw = fakeGateway({ executeResult: { data: { id: 'x' }, successful: true, error: null } });
+  await new ComposioPublisherProvider(
+    feedGw,
+    fakeConfig({ actions: { upload_media: 'IG_CONTAINER', publish_post: 'IG_PUBLISH' } }),
+    fakeDb(),
+  ).publishPost({
+    tenantId, platform: 'instagram', content: 'feed vid',
+    mediaUrls: ['https://cdn.example.com/v.mp4'], placement: 'feed', mediaType: 'video',
+    mediaMetadata: meta, approved: true,
+  });
+  const feedArgs = feedGw.calls[0].options.arguments as Record<string, unknown>;
+  assert.equal(feedArgs.media_type, 'REELS', 'feed video posts as a Reel');
+  assert.equal(feedArgs.share_to_feed, true, 'feed video also lands in the feed');
+
+  const storyGw = fakeGateway({ executeResult: { data: { id: 'x' }, successful: true, error: null } });
+  await new ComposioPublisherProvider(
+    storyGw,
+    fakeConfig({ actions: { upload_media: 'IG_CONTAINER', publish_post: 'IG_PUBLISH' } }),
+    fakeDb(),
+  ).publishPost({
+    tenantId, platform: 'instagram', content: 'story vid',
+    mediaUrls: ['https://cdn.example.com/v.mp4'], placement: 'story', mediaType: 'video',
+    mediaMetadata: meta, approved: true,
+  });
+  const storyArgs = storyGw.calls[0].options.arguments as Record<string, unknown>;
+  assert.equal(storyArgs.media_type, 'STORIES', 'story video container media_type=STORIES');
+  assert.equal(storyArgs.share_to_feed, undefined, 'story video never forces share_to_feed');
+});
+
+test('IG video with invalid media (bad aspect ratio) is rethrown as ComposioToolError (definitely-never-posted), no executeTool', async () => {
+  const gateway = fakeGateway({ executeResult: { data: { id: 'should_not_be_used' }, successful: true, error: null } });
+  const provider = new ComposioPublisherProvider(
+    gateway,
+    fakeConfig({ actions: { upload_media: 'IG_CONTAINER', publish_post: 'IG_PUBLISH' } }),
+    fakeDb(),
+  );
+  await assert.rejects(
+    () =>
+      provider.publishPost({
+        tenantId,
+        platform: 'instagram',
+        content: 'bad reel',
+        mediaUrls: ['https://cdn.example.com/wide.mp4'],
+        placement: 'reel',
+        mediaType: 'video',
+        // 16:9 — a reel requires 9:16. The validator throws MetaPublishError;
+        // the provider MUST rethrow it as a recognized never-posted error so
+        // dispatchPublish does NOT mis-wrap it as outcome-unknown.
+        mediaMetadata: [{ widthPx: 1920, heightPx: 1080, durationSeconds: 30 }],
+        approved: true,
+      }),
+    ComposioToolError,
+    'a fail-closed media validation error must surface as ComposioToolError (never-posted)',
+  );
+  assert.equal(gateway.calls.length, 0, 'no Graph/Composio call may be made when validation fails closed');
+});
 
+test('IG feed-video is validated as a Reel (9:16): a 16:9 feed clip fails closed (never-posted), no executeTool', async () => {
+  // IG feed video publishes as a REELS container (share_to_feed), which Meta
+  // requires to be vertical 9:16. A 16:9 "feed" video must be rejected at Aries
+  // (against reel constraints), not pass the laxer feed rules then 400 at Meta.
+  const gateway = fakeGateway({ executeResult: { data: { id: 'should_not_be_used' }, successful: true, error: null } });
+  const provider = new ComposioPublisherProvider(
+    gateway,
+    fakeConfig({ actions: { upload_media: 'IG_CONTAINER', publish_post: 'IG_PUBLISH' } }),
+    fakeDb(),
+  );
+  await assert.rejects(
+    () =>
+      provider.publishPost({
+        tenantId,
+        platform: 'instagram',
+        content: 'wide feed video',
+        mediaUrls: ['https://cdn.example.com/wide-feed.mp4'],
+        placement: 'feed',
+        mediaType: 'video',
+        mediaMetadata: [{ widthPx: 1920, heightPx: 1080, durationSeconds: 30 }],
+        approved: true,
+      }),
+    ComposioToolError,
+    'a non-9:16 IG feed video must fail closed against reel constraints (never-posted)',
+  );
+  assert.equal(gateway.calls.length, 0, 'no container is created when feed-video validation fails closed');
+});
+
+test('FB video uses FACEBOOK_CREATE_VIDEO_POST (publish_video slot) with file_url + published=true', async () => {
+  const gateway = fakeGateway({ executeResult: { data: { id: 'fb_vid_1' }, successful: true, error: null } });
+  const provider = new ComposioPublisherProvider(
+    gateway,
+    fakeConfig({ actions: { publish_video: 'FB_VIDEO', publish_post: 'FB_POST', upload_media: 'FB_PHOTO' } }),
+    fakeDb(),
+  );
+  const result = await provider.publishPost({
+    tenantId,
+    platform: 'facebook',
+    content: 'fb video caption',
+    mediaUrls: ['https://cdn.example.com/clip.mp4'],
+    placement: 'feed',
+    mediaType: 'video',
+    mediaMetadata: [{ widthPx: 1080, heightPx: 1080, durationSeconds: 20 }],
+    approved: true,
+  });
+
+  assert.equal(gateway.calls.length, 1, 'FB video is a single Page-video call (no pre-stage)');
+  const call = gateway.calls[0];
+  assert.equal(call.slug, 'FB_VIDEO', 'video routes to the publish_video slug');
+  const args = call.options.arguments as Record<string, unknown>;
+  assert.equal(args.file_url, 'https://cdn.example.com/clip.mp4', 'raw mp4 file_url, posted directly');
+  assert.equal(args.description, 'fb video caption', 'caption rides description');
+  assert.equal(args.page_id, 'ext_1', 'page_id from stored external_account_id');
+  assert.equal(args.published, true, 'an unscheduled FB video publishes immediately');
+  assert.equal(args.scheduled_publish_time, undefined, 'no schedule time on a live publish');
+  assert.equal(result.externalPostId, 'fb_vid_1');
+});
+
+test('FB scheduled video sets published=false AND scheduled_publish_time together', async () => {
+  const gateway = fakeGateway({ executeResult: { data: { id: 'fb_vid_sched' }, successful: true, error: null } });
+  const provider = new ComposioPublisherProvider(
+    gateway,
+    fakeConfig({ actions: { publish_video: 'FB_VIDEO' } }),
+    fakeDb(),
+  );
+  const result = await provider.publishPost({
+    tenantId,
+    platform: 'facebook',
+    content: 'scheduled fb video',
+    mediaUrls: ['https://cdn.example.com/clip.mp4'],
+    placement: 'feed',
+    mediaType: 'video',
+    mediaMetadata: [{ widthPx: 1080, heightPx: 1080, durationSeconds: 20 }],
+    scheduledFor: '1999999999',
+    approved: true,
+  });
   const args = gateway.calls[0].options.arguments as Record<string, unknown>;
-  assert.equal(args.caption, 'Hello IG', 'Instagram must still use `caption`');
-  assert.equal(args.message,  undefined, '`message` must not be set for Instagram');
-  assert.equal(args.page_id,  undefined, '`page_id` must not be set for Instagram');
+  assert.equal(args.published, false, 'a scheduled FB video must NOT publish immediately');
+  assert.equal(args.scheduled_publish_time, '1999999999', 'schedule time is passed through');
+  assert.equal(result.status, 'scheduled');
 });
 
 // ── Regression tests for #627: FB image posts use FACEBOOK_CREATE_PHOTO_POST ─
diff --git a/tests/marketing-auto-schedule.test.ts b/tests/marketing-auto-schedule.test.ts
index de6076ff..79cb3800 100644
--- a/tests/marketing-auto-schedule.test.ts
+++ b/tests/marketing-auto-schedule.test.ts
@@ -517,9 +517,9 @@ const WEEKLY_FEED_ONLY = [
 test('buildAutoScheduleRows: promoted story post keeps surface=story despite a feed-only schedule', () => {
   const postRows: AutoSchedulePostRow[] = [
     // feed sibling for ordinal 1
-    { id: 10, platform: 'instagram', idempotency_key: `${STORY_JOB}:1:instagram:feed`, surface: 'feed', media_type: 'image' },
+    { id: 10, platform: 'instagram', idempotency_key: `${STORY_JOB}:1:instagram:feed`, surface: 'feed', media_type: 'image', width_px: null, height_px: null, duration_seconds: null },
     // auto-promoted image story for the SAME ordinal 1
-    { id: 11, platform: 'instagram', idempotency_key: `${STORY_JOB}:1:instagram:story`, surface: 'story', media_type: 'image' },
+    { id: 11, platform: 'instagram', idempotency_key: `${STORY_JOB}:1:instagram:story`, surface: 'story', media_type: 'image', width_px: null, height_px: null, duration_seconds: null },
   ];
 
   const rows = buildAutoScheduleRows(postRows, WEEKLY_FEED_ONLY, STORY_JOB);
@@ -535,7 +535,7 @@ test('buildAutoScheduleRows: promoted story post keeps surface=story despite a f
 
 test('buildAutoScheduleRows: media_type also comes from the post (video preserved)', () => {
   const postRows: AutoSchedulePostRow[] = [
-    { id: 20, platform: 'facebook', idempotency_key: `${STORY_JOB}:1:facebook:reel`, surface: 'reel', media_type: 'video' },
+    { id: 20, platform: 'facebook', idempotency_key: `${STORY_JOB}:1:facebook:reel`, surface: 'reel', media_type: 'video', width_px: null, height_px: null, duration_seconds: null },
   ];
   const rows = buildAutoScheduleRows(postRows, WEEKLY_FEED_ONLY, STORY_JOB);
   assert.equal(rows[0]?.surface, 'reel');
@@ -544,7 +544,7 @@ test('buildAutoScheduleRows: media_type also comes from the post (video preserve
 
 test('buildAutoScheduleRows: null/legacy surface falls back to feed/image', () => {
   const postRows: AutoSchedulePostRow[] = [
-    { id: 30, platform: 'instagram', idempotency_key: `${STORY_JOB}:1:instagram:feed`, surface: null, media_type: null },
+    { id: 30, platform: 'instagram', idempotency_key: `${STORY_JOB}:1:instagram:feed`, surface: null, media_type: null, width_px: null, height_px: null, duration_seconds: null },
   ];
   const rows = buildAutoScheduleRows(postRows, WEEKLY_FEED_ONLY, STORY_JOB);
   assert.equal(rows[0]?.surface, 'feed');
diff --git a/tests/marketing/ingest-production-assets.test.ts b/tests/marketing/ingest-production-assets.test.ts
index 1c520413..24e39a61 100644
--- a/tests/marketing/ingest-production-assets.test.ts
+++ b/tests/marketing/ingest-production-assets.test.ts
@@ -310,16 +310,22 @@ test('ingestProductionCreativeAssetsToDb — inserts row with correct SQL shape'
     // 'ingested_asset'); the no-framing default is 'runtime_asset'.
     assert.ok(sql.includes('$8, $4, '), 'storage_kind must be bound as $8 and storage_key as $4');
     assert.ok(sql.includes("'generated'"), 'permission_scope must be generated');
-    assert.ok(sql.includes("'image'"), 'media_type must be image');
-    assert.ok(sql.includes("'4:5'"), 'aspect_ratio must be 4:5');
+    // media_type ($9) and aspect_ratio ($10) are now bound as params, not SQL literals —
+    // they must NOT appear as hardcoded strings in the SQL.
+    assert.ok(!sql.includes("'image'"), 'media_type must be bound as $9, not a hardcoded literal');
+    assert.ok(!sql.includes("'4:5'"), 'aspect_ratio must be bound as $10, not a hardcoded literal');
 
-    // params: [tenantId, jobId, sourceAssetId, storageKey, checksum, batch, index, storageKind]
+    // params: [tenantId, jobId, sourceAssetId, storageKey, checksum, batch, index, storageKind,
+    //          mediaType, aspectRatio, widthPx, heightPx, durationSeconds]
     assert.equal(params[0], 99, 'param $1 must be tenantId');
     assert.equal(params[1], 'mkt_insert_test', 'param $2 must be jobId');
     assert.equal(params[2], 'asset-001', 'param $3 must be sourceAssetId');
     assert.equal(params[3], path.join(mount, basename), 'param $4 must be the readable mount storagePath');
     assert.ok(typeof params[4] === 'string' && (params[4] as string).length === 64, 'param $5 must be a sha256 hex string');
     assert.equal(params[7], 'runtime_asset', 'param $8 must default to runtime_asset (no framing)');
+    // After the video dims PR, $9=mediaType and $10=aspectRatio are params (not literals).
+    assert.equal(params[8], 'image', 'param $9 must be mediaType=image for a generated_image');
+    assert.equal(params[9], '4:5', 'param $10 must be aspectRatio=4:5 for a feed image entry');
   });
 });
 
diff --git a/tests/marketing/video-ingest-dims.test.ts b/tests/marketing/video-ingest-dims.test.ts
new file mode 100644
index 00000000..6ed614f4
--- /dev/null
+++ b/tests/marketing/video-ingest-dims.test.ts
@@ -0,0 +1,289 @@
+/**
+ * Slice 1 — ingest-production-assets video support.
+ *
+ * Verifies that a Hermes `generated_video` creative_asset entry is ingested
+ * with the correct `media_type`, `aspect_ratio`, `width_px`, `height_px`, and
+ * `duration_seconds` SQL params, and that image entries still produce the
+ * correct media_type / aspect_ratio (now bound as params $9/$10 rather than
+ * hardcoded literals, after the video dims PR).
+ *
+ * Run:
+ *   APP_BASE_URL=https://aries.example.com \
+ *     ./node_modules/.bin/tsx --test tests/marketing/video-ingest-dims.test.ts
+ */
+import assert from 'node:assert/strict';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { ingestProductionCreativeAssetsToDb } from '../../backend/marketing/ingest-production-assets';
+import type { SocialContentJobRuntimeDocument } from '../../backend/marketing/runtime-state';
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+function makeDoc(creativeAssets: unknown[]): SocialContentJobRuntimeDocument {
+  return {
+    schema_name: 'marketing_job_state_schema',
+    schema_version: '1.0.0',
+    job_id: 'mkt_video_dims',
+    tenant_id: '42',
+    job_type: 'weekly_social_content',
+    state: 'completed',
+    status: 'completed',
+    current_stage: 'production',
+    stage_order: ['research', 'strategy', 'production', 'publish'],
+    stages: {
+      research: { stage: 'research', status: 'completed', started_at: null, completed_at: null, failed_at: null, run_id: null, summary: null, primary_output: null, outputs: {}, artifacts: [], errors: [] },
+      strategy: { stage: 'strategy', status: 'completed', started_at: null, completed_at: null, failed_at: null, run_id: null, summary: null, primary_output: null, outputs: {}, artifacts: [], errors: [] },
+      production: {
+        stage: 'production', status: 'completed', started_at: null, completed_at: null,
+        failed_at: null, run_id: null, summary: null,
+        primary_output: { artifacts: { creative_assets: creativeAssets } },
+        outputs: {}, artifacts: [], errors: [],
+      },
+      publish: { stage: 'publish', status: 'not_started', started_at: null, completed_at: null, failed_at: null, run_id: null, summary: null, primary_output: null, outputs: {}, artifacts: [], errors: [] },
+    },
+    approvals: { current: null, history: [] },
+    publish_config: { platforms: [], live_publish_platforms: [], video_render_platforms: [] },
+    brand_kit: null,
+    inputs: { request: {}, brand_url: 'https://example.com' },
+    history: [], errors: [], last_error: null,
+  } as unknown as SocialContentJobRuntimeDocument;
+}
+
+type QueryCall = { sql: string; params: unknown[] };
+
+function makeMockPool(rowCount = 1) {
+  const calls: QueryCall[] = [];
+  const pool = {
+    query(sql: string, params?: unknown[]) {
+      calls.push({ sql, params: params ?? [] });
+      return Promise.resolve({ rows: rowCount > 0 ? [{ id: 'uuid-1' }] : [], rowCount });
+    },
+  };
+  return { pool, calls };
+}
+
+async function withHermesMediaMount<T>(
+  fn: (mount: string, hostImagePath: (basename: string) => string) => Promise<T>,
+): Promise<T> {
+  const mount = path.join(tmpdir(), `aries-video-ingest-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  await mkdir(mount, { recursive: true });
+  const prev = process.env.HERMES_IMAGE_CACHE_MOUNT;
+  process.env.HERMES_IMAGE_CACHE_MOUNT = mount;
+  const hostImagePath = (basename: string) =>
+    `/home/node/.hermes/profiles/aries-content-generator/cache/images/${basename}`;
+  try {
+    return await fn(mount, hostImagePath);
+  } finally {
+    if (prev === undefined) delete process.env.HERMES_IMAGE_CACHE_MOUNT;
+    else process.env.HERMES_IMAGE_CACHE_MOUNT = prev;
+    await rm(mount, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Slice 1 — video entry dims
+// ---------------------------------------------------------------------------
+
+test('video entry: media_type=video, aspect_ratio=9:16, dims populated in SQL params', async () => {
+  // FAIL BEFORE: params[8]='image', params[9]='4:5', params[10..12]=undefined
+  // PASS AFTER:  params[8]='video', params[9]='9:16', params[10]=1080, [11]=1920, [12]=15
+  await withHermesMediaMount(async (mount, hostImagePath) => {
+    const basename = 'clip_reel_01.mp4';
+    await writeFile(path.join(mount, basename), Buffer.from('fakevideobytes'));
+
+    const doc = makeDoc([{
+      assetId: 'vid_1',
+      type: 'generated_video',
+      path: hostImagePath(basename),
+      media_type: 'video',
+      surface: 'reel',
+      width: 1080,
+      height: 1920,
+      duration_seconds: 15,
+    }]);
+    const { pool, calls } = makeMockPool(1);
+    const result = await ingestProductionCreativeAssetsToDb({ jobId: 'mkt_vid1', tenantId: 42, doc, pool });
+
+    assert.equal(result.total, 1);
+    assert.equal(result.inserted, 1);
+    assert.equal(result.skipped, 0);
+    assert.equal(calls.length, 1, 'exactly one INSERT expected');
+
+    const { params } = calls[0];
+    // Param positions (1-based SQL params, 0-based JS array):
+    // $9=mediaType (params[8]), $10=aspectRatio (params[9]),
+    // $11=widthPx (params[10]), $12=heightPx (params[11]), $13=durationSeconds (params[12])
+    assert.equal(params[8], 'video', '$9 mediaType must be "video" for generated_video');
+    assert.equal(params[9], '9:16', '$10 aspectRatio must be 9:16 (portrait from width<height)');
+    assert.equal(params[10], 1080, '$11 widthPx must be 1080');
+    assert.equal(params[11], 1920, '$12 heightPx must be 1920');
+    assert.equal(params[12], 15, '$13 durationSeconds must be 15');
+  });
+});
+
+test('video entry via media_type field (not type field): media_type=video', async () => {
+  await withHermesMediaMount(async (mount, hostImagePath) => {
+    const basename = 'story_vid.mp4';
+    await writeFile(path.join(mount, basename), Buffer.from('fakevideobytes'));
+
+    const doc = makeDoc([{
+      assetId: 'vid_2',
+      type: 'something_else',   // NOT generated_video
+      media_type: 'video',       // but explicit media_type=video
+      path: hostImagePath(basename),
+      surface: 'story',
+      width: 1080,
+      height: 1920,
+      duration_seconds: 30,
+    }]);
+    const { pool, calls } = makeMockPool(1);
+    const result = await ingestProductionCreativeAssetsToDb({ jobId: 'mkt_vid2', tenantId: 42, doc, pool });
+
+    assert.equal(result.inserted, 1);
+    const { params } = calls[0];
+    assert.equal(params[8], 'video', 'media_type field takes precedence to identify video');
+    assert.equal(params[9], '9:16', 'portrait aspect ratio from width < height');
+    assert.equal(params[10], 1080);
+    assert.equal(params[11], 1920);
+    assert.equal(params[12], 30);
+  });
+});
+
+test('image entry: media_type=image as param $9, aspect_ratio=4:5 as param $10, null dims', async () => {
+  // FAIL BEFORE: SQL had hardcoded literals 'image'/'4:5'; after the change they
+  // are params. This test asserts the PARAMS contain the correct values.
+  await withHermesMediaMount(async (mount, hostImagePath) => {
+    const basename = 'feed_image.png';
+    await writeFile(path.join(mount, basename), Buffer.from('fakepng'));
+
+    const doc = makeDoc([{
+      assetId: 'img_1',
+      type: 'generated_image',
+      path: hostImagePath(basename),
+      placement: 'feed',
+      // no width/height/duration_seconds
+    }]);
+    const { pool, calls } = makeMockPool(1);
+    await ingestProductionCreativeAssetsToDb({ jobId: 'mkt_img1', tenantId: 42, doc, pool });
+
+    const { params } = calls[0];
+    assert.equal(params[8], 'image', '$9 mediaType must be "image" for generated_image');
+    assert.equal(params[9], '4:5', '$10 aspectRatio must be "4:5" for feed image (no dims)');
+    assert.equal(params[10], null, '$11 widthPx null when no dims provided');
+    assert.equal(params[11], null, '$12 heightPx null');
+    assert.equal(params[12], null, '$13 durationSeconds null');
+  });
+});
+
+test('video entry without dims: fallback aspect_ratio from reel surface = 9:16, null dims params', async () => {
+  await withHermesMediaMount(async (mount, hostImagePath) => {
+    const basename = 'reel_nodims.mp4';
+    await writeFile(path.join(mount, basename), Buffer.from('fakevideo'));
+
+    const doc = makeDoc([{
+      assetId: 'vid_3',
+      type: 'generated_video',
+      path: hostImagePath(basename),
+      surface: 'reel',
+      // no width/height/duration_seconds
+    }]);
+    const { pool, calls } = makeMockPool(1);
+    await ingestProductionCreativeAssetsToDb({ jobId: 'mkt_nodims', tenantId: 42, doc, pool });
+
+    const { params } = calls[0];
+    assert.equal(params[8], 'video');
+    assert.equal(params[9], '9:16', 'reel surface without dims falls back to 9:16');
+    assert.equal(params[10], null, 'widthPx null when no dims');
+    assert.equal(params[11], null);
+    assert.equal(params[12], null);
+  });
+});
+
+test('landscape video (width > height): aspect_ratio=4:5', async () => {
+  await withHermesMediaMount(async (mount, hostImagePath) => {
+    const basename = 'landscape.mp4';
+    await writeFile(path.join(mount, basename), Buffer.from('fakevideo'));
+
+    const doc = makeDoc([{
+      assetId: 'vid_4',
+      type: 'generated_video',
+      path: hostImagePath(basename),
+      width: 1920,
+      height: 1080,
+      duration_seconds: 60,
+    }]);
+    const { pool, calls } = makeMockPool(1);
+    await ingestProductionCreativeAssetsToDb({ jobId: 'mkt_landscape', tenantId: 42, doc, pool });
+
+    const { params } = calls[0];
+    assert.equal(params[8], 'video');
+    assert.equal(params[9], '4:5', 'landscape (width > height) maps to 4:5');
+    assert.equal(params[10], 1920);
+    assert.equal(params[11], 1080);
+    assert.equal(params[12], 60);
+  });
+});
+
+test('mixed batch: image + video both insert with correct dims', async () => {
+  await withHermesMediaMount(async (mount, hostImagePath) => {
+    const imgBasename = 'feed.png';
+    const vidBasename = 'reel.mp4';
+    await writeFile(path.join(mount, imgBasename), Buffer.from('fakepng'));
+    await writeFile(path.join(mount, vidBasename), Buffer.from('fakevideo'));
+
+    const doc = makeDoc([
+      { assetId: 'img_1', type: 'generated_image', path: hostImagePath(imgBasename) },
+      { assetId: 'vid_1', type: 'generated_video', path: hostImagePath(vidBasename), width: 1080, height: 1920, duration_seconds: 10 },
+    ]);
+    const { pool, calls } = makeMockPool(1);
+    const result = await ingestProductionCreativeAssetsToDb({ jobId: 'mkt_mixed', tenantId: 42, doc, pool });
+
+    assert.equal(result.total, 2);
+    assert.equal(result.inserted, 2);
+    assert.equal(calls.length, 2);
+
+    // First is img (ordered by iteration, not source_asset_id in this test)
+    const imgCall = calls.find((c) => c.params[8] === 'image');
+    const vidCall = calls.find((c) => c.params[8] === 'video');
+    assert.ok(imgCall, 'image INSERT expected');
+    assert.ok(vidCall, 'video INSERT expected');
+
+    assert.equal(imgCall!.params[9], '4:5');
+    assert.equal(imgCall!.params[10], null);
+
+    assert.equal(vidCall!.params[9], '9:16');
+    assert.equal(vidCall!.params[10], 1080);
+    assert.equal(vidCall!.params[11], 1920);
+    assert.equal(vidCall!.params[12], 10);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Guard: the SQL now binds media_type and aspect_ratio as params (not literals)
+// Before the PR: INSERT had hardcoded 'image'/'4:5' literals.
+// After the PR: $9/$10 — the values appear in params, not in the SQL text.
+// ---------------------------------------------------------------------------
+
+test('INSERT SQL: media_type and aspect_ratio are bound as params, not SQL literals', async () => {
+  await withHermesMediaMount(async (mount, hostImagePath) => {
+    const basename = 'check_sql.png';
+    await writeFile(path.join(mount, basename), Buffer.from('fakepng'));
+    const doc = makeDoc([{ assetId: 'img_sql', type: 'generated_image', path: hostImagePath(basename) }]);
+    const { pool, calls } = makeMockPool(1);
+    await ingestProductionCreativeAssetsToDb({ jobId: 'mkt_sql_check', tenantId: 42, doc, pool });
+
+    const { sql } = calls[0];
+    // The old SQL had hardcoded 'image' and '4:5' literals; the new SQL uses $9/$10.
+    // Asserting these are NOT literals guards against the old implementation.
+    assert.ok(!sql.includes("'image'"), "SQL must NOT hardcode 'image' literal (now $9 param)");
+    assert.ok(!sql.includes("'4:5'"), "SQL must NOT hardcode '4:5' literal (now $10 param)");
+    // The new params ARE in the params array.
+    assert.equal(calls[0].params[8], 'image');
+    assert.equal(calls[0].params[9], '4:5');
+  });
+});
diff --git a/tests/marketing/workspace-video-asset-mapping.test.ts b/tests/marketing/workspace-video-asset-mapping.test.ts
new file mode 100644
index 00000000..7267ddd4
--- /dev/null
+++ b/tests/marketing/workspace-video-asset-mapping.test.ts
@@ -0,0 +1,232 @@
+/**
+ * Slice 5 — workspace-views production-asset DB merge maps video rows to
+ * contentType:'video/mp4' and title:'Generated Video'.
+ *
+ * Uses the globalThis.__ariesPgPool seam (same pattern as
+ * pending-approval-count-denorm.test.ts) to inject a mock pool so the test
+ * runs without a live database.
+ *
+ * IMPORTANT: lib/db.ts captures the pool const ONCE at module load time, so
+ * __ariesPgPool must be set BEFORE the first dynamic import of workspace-views
+ * or lib/db. We use a SINGLE mutable-state pool installed at file initialisation
+ * time; each test sets _currentRows before calling buildSocialContentWorkspaceView.
+ *
+ * Run:
+ *   APP_BASE_URL=https://aries.example.com \
+ *     ./node_modules/.bin/tsx --test tests/marketing/workspace-video-asset-mapping.test.ts
+ */
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test, { before } from 'node:test';
+
+// TYPE-only imports — erased at compile time, do NOT trigger lib/db.ts to load.
+import type { Pool } from 'pg';
+import type { SocialContentJobRuntimeDocument } from '../../backend/marketing/runtime-state';
+
+import { resolveProjectRoot } from '../helpers/project-root';
+
+const PROJECT_ROOT = resolveProjectRoot(import.meta.url);
+
+// ---------------------------------------------------------------------------
+// Mutable-state global pool — installed ONCE before lib/db.ts first loads.
+// Each test updates _currentRows; the pool dispatches from that variable.
+// This works around the "pool const captured once" constraint in lib/db.ts.
+// ---------------------------------------------------------------------------
+
+let _currentRows: Array<Record<string, unknown>> = [];
+
+const g = globalThis as typeof globalThis & { __ariesPgPool?: Pool };
+g.__ariesPgPool = {
+  query(sql: string) {
+    if (/SELECT[\s\S]*FROM creative_assets/i.test(sql)) {
+      return Promise.resolve({ rows: _currentRows, rowCount: _currentRows.length });
+    }
+    // Posts query and any other query — return empty.
+    return Promise.resolve({ rows: [], rowCount: 0 });
+  },
+} as unknown as Pool;
+
+// ---------------------------------------------------------------------------
+// Runtime doc factory — minimal doc with numeric tenant_id so queryProductionCreativeAssets
+// proceeds past its tenantNum guard.
+// ---------------------------------------------------------------------------
+
+function makeMinimalDoc(jobId: string): SocialContentJobRuntimeDocument {
+  return {
+    schema_name: 'marketing_job_state_schema',
+    schema_version: '1.0.0',
+    job_id: jobId,
+    tenant_id: '42',  // Number('42') = 42 > 0 → passes guard
+    job_type: 'weekly_social_content',
+    state: 'completed',
+    status: 'completed',
+    current_stage: 'production',
+    stage_order: ['research', 'strategy', 'production', 'publish'],
+    stages: {
+      research: { stage: 'research', status: 'completed', started_at: null, completed_at: null, failed_at: null, run_id: null, summary: null, primary_output: null, outputs: {}, artifacts: [], errors: [] },
+      strategy: { stage: 'strategy', status: 'completed', started_at: null, completed_at: null, failed_at: null, run_id: null, summary: null, primary_output: null, outputs: {}, artifacts: [], errors: [] },
+      production: { stage: 'production', status: 'completed', started_at: null, completed_at: null, failed_at: null, run_id: null, summary: null, primary_output: { artifacts: { creative_assets: [] } }, outputs: {}, artifacts: [], errors: [] },
+      publish: { stage: 'publish', status: 'not_started', started_at: null, completed_at: null, failed_at: null, run_id: null, summary: null, primary_output: null, outputs: {}, artifacts: [], errors: [] },
+    },
+    approvals: { current: null, history: [] },
+    publish_config: { platforms: [], live_publish_platforms: [], video_render_platforms: [] },
+    brand_kit: null,
+    inputs: { request: {}, brand_url: 'https://example.com' },
+    history: [], errors: [], last_error: null,
+    created_at: '2026-06-23T00:00:00.000Z', updated_at: '2026-06-23T00:00:00.000Z',
+  } as unknown as SocialContentJobRuntimeDocument;
+}
+
+async function withEnv<T>(rows: Array<Record<string, unknown>>, run: (dataRoot: string) => Promise<T>): Promise<T> {
+  const prevData = process.env.DATA_ROOT;
+  const prevCode = process.env.CODE_ROOT;
+  const prevMount = process.env.HERMES_IMAGE_CACHE_MOUNT;
+  const dataRoot = await mkdtemp(path.join(tmpdir(), 'aries-video-ws-'));
+  process.env.DATA_ROOT = dataRoot;
+  process.env.CODE_ROOT = PROJECT_ROOT;
+  process.env.HERMES_IMAGE_CACHE_MOUNT = dataRoot;
+  _currentRows = rows;  // configure the shared pool for this test
+  try {
+    return await run(dataRoot);
+  } finally {
+    _currentRows = [];
+    if (prevData === undefined) delete process.env.DATA_ROOT;
+    else process.env.DATA_ROOT = prevData;
+    if (prevCode === undefined) delete process.env.CODE_ROOT;
+    else process.env.CODE_ROOT = prevCode;
+    if (prevMount === undefined) delete process.env.HERMES_IMAGE_CACHE_MOUNT;
+    else process.env.HERMES_IMAGE_CACHE_MOUNT = prevMount;
+    await rm(dataRoot, { recursive: true, force: true });
+  }
+}
+
+// Import buildSocialContentWorkspaceView ONCE via before() hook.
+// lib/db.ts loads during this import and captures the shared mutable pool above.
+// __ariesPgPool is already set at module level before this before() runs.
+let buildSocialContentWorkspaceView: Awaited<typeof import('../../backend/marketing/workspace-views')>['buildSocialContentWorkspaceView'];
+
+before(async () => {
+  const mod = await import('../../backend/marketing/workspace-views');
+  buildSocialContentWorkspaceView = mod.buildSocialContentWorkspaceView;
+});
+
+// ---------------------------------------------------------------------------
+// Slice 5 — workspace-views production-asset merge
+// ---------------------------------------------------------------------------
+
+test('video DB row maps to contentType:video/mp4 and title:Generated Video', async () => {
+  // FAIL BEFORE: media_type was not SELECTed, so isVideo=false → contentType:'image/png'
+  // PASS AFTER:  media_type is SELECTed; isVideo=true → contentType:'video/mp4'
+  await withEnv([
+    {
+      id: 'uuid-vid-1',
+      source_asset_id: 'vid_1',
+      served_asset_ref: '/api/internal/hermes/media/uuid-vid-1',
+      checksum: 'abc123',
+      media_type: 'video',
+      aspect_ratio: '9:16',
+      width_px: 1080,
+      height_px: 1920,
+      duration_seconds: 15,
+    },
+  ], async () => {
+    const jobId = 'mkt_video_ws_test';
+    const view = await buildSocialContentWorkspaceView(jobId, {
+      runtimeDoc: makeMinimalDoc(jobId),
+    });
+
+    const assets = view.creativeReview?.assets ?? [];
+    assert.ok(assets.length > 0, 'video asset must appear in creativeReview.assets');
+
+    const videoAsset = assets.find((a) => a.assetId === 'vid_1');
+    assert.ok(videoAsset, 'vid_1 asset must be present');
+    assert.equal(videoAsset!.contentType, 'video/mp4', 'video row must map to contentType:video/mp4');
+    assert.equal(videoAsset!.title, 'Generated Video', 'video row must map to title:Generated Video');
+    assert.equal(videoAsset!.previewUrl, '/api/internal/hermes/media/uuid-vid-1', 'served_asset_ref threaded as previewUrl');
+  });
+});
+
+test('image DB row still maps to contentType:image/png and title:Generated Image', async () => {
+  await withEnv([
+    {
+      id: 'uuid-img-1',
+      source_asset_id: 'img_1',
+      served_asset_ref: '/api/internal/hermes/media/uuid-img-1',
+      checksum: 'def456',
+      media_type: 'image',
+      aspect_ratio: '4:5',
+      width_px: null,
+      height_px: null,
+      duration_seconds: null,
+    },
+  ], async () => {
+    const jobId = 'mkt_img_ws_test';
+    const view = await buildSocialContentWorkspaceView(jobId, {
+      runtimeDoc: makeMinimalDoc(jobId),
+    });
+
+    const assets = view.creativeReview?.assets ?? [];
+    const imageAsset = assets.find((a) => a.assetId === 'img_1');
+    assert.ok(imageAsset, 'img_1 asset must be present');
+    assert.equal(imageAsset!.contentType, 'image/png', 'image row must stay contentType:image/png');
+    assert.equal(imageAsset!.title, 'Generated Image', 'image row must stay title:Generated Image');
+  });
+});
+
+test('null media_type row defaults to image (not video)', async () => {
+  await withEnv([
+    {
+      id: 'uuid-null-1',
+      source_asset_id: 'null_asset',
+      served_asset_ref: '/api/internal/hermes/media/uuid-null-1',
+      checksum: 'ghi789',
+      media_type: null,  // legacy row with no media_type
+      aspect_ratio: null,
+      width_px: null,
+      height_px: null,
+      duration_seconds: null,
+    },
+  ], async () => {
+    const jobId = 'mkt_null_ws_test';
+    const view = await buildSocialContentWorkspaceView(jobId, {
+      runtimeDoc: makeMinimalDoc(jobId),
+    });
+
+    const assets = view.creativeReview?.assets ?? [];
+    const asset = assets.find((a) => a.assetId === 'null_asset');
+    assert.ok(asset, 'null media_type asset must appear');
+    assert.equal(asset!.contentType, 'image/png', 'null media_type must default to image/png (not video)');
+    assert.equal(asset!.title, 'Generated Image', 'null media_type must default to Generated Image');
+  });
+});
+
+test('mixed batch: image and video assets in same view', async () => {
+  await withEnv([
+    {
+      id: 'uuid-img-m', source_asset_id: 'img_m', served_asset_ref: '/api/internal/hermes/media/uuid-img-m',
+      checksum: 'img_chk', media_type: 'image', aspect_ratio: '4:5', width_px: null, height_px: null, duration_seconds: null,
+    },
+    {
+      id: 'uuid-vid-m', source_asset_id: 'vid_m', served_asset_ref: '/api/internal/hermes/media/uuid-vid-m',
+      checksum: 'vid_chk', media_type: 'video', aspect_ratio: '9:16', width_px: 1080, height_px: 1920, duration_seconds: 10,
+    },
+  ], async () => {
+    const jobId = 'mkt_mixed_ws_test';
+    const view = await buildSocialContentWorkspaceView(jobId, {
+      runtimeDoc: makeMinimalDoc(jobId),
+    });
+
+    const assets = view.creativeReview?.assets ?? [];
+    assert.ok(assets.length >= 2, 'at least two assets expected');
+
+    const img = assets.find((a) => a.assetId === 'img_m');
+    const vid = assets.find((a) => a.assetId === 'vid_m');
+    assert.ok(img && vid, 'both image and video must appear');
+    assert.equal(img!.contentType, 'image/png');
+    assert.equal(vid!.contentType, 'video/mp4');
+    assert.equal(img!.title, 'Generated Image');
+    assert.equal(vid!.title, 'Generated Video');
+  });
+});
diff --git a/tests/social-content-schedule-dims.test.ts b/tests/social-content-schedule-dims.test.ts
new file mode 100644
index 00000000..2c4aa0e2
--- /dev/null
+++ b/tests/social-content-schedule-dims.test.ts
@@ -0,0 +1,243 @@
+/**
+ * Slice 6 — manual schedule route threads width_px/height_px/duration_seconds
+ * from the posts row into the scheduled_posts INSERT.
+ *
+ * Run:
+ *   APP_BASE_URL=https://aries.example.com \
+ *     ./node_modules/.bin/tsx --test tests/social-content-schedule-dims.test.ts
+ */
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  handlePatchScheduleSocialContentPost,
+  type ScheduleRouteQueryable,
+} from '../app/api/social-content/jobs/[jobId]/posts/[postId]/schedule/route';
+
+type Captured = { sql: string; params: unknown[] };
+
+// ---------------------------------------------------------------------------
+// Test queryable factory — posts SELECT returns a post row WITH dims
+// ---------------------------------------------------------------------------
+
+function buildQueryableWithDims(
+  dims: { width_px: number | null; height_px: number | null; duration_seconds: number | null },
+): { queryable: ScheduleRouteQueryable; calls: Captured[] } {
+  const calls: Captured[] = [];
+  let nextScheduledId = 901;
+  const query = (async (sql: string, params: unknown[]) => {
+    const trimmed = sql.trim();
+    calls.push({ sql: trimmed, params });
+    if (trimmed.startsWith('SELECT id, tenant_id') && trimmed.includes('FROM posts')) {
+      const [postId, tenantId] = params as [number, number];
+      return {
+        rows: [{
+          id: postId,
+          tenant_id: tenantId,
+          surface: 'reel',
+          media_type: 'video',
+          width_px: dims.width_px,
+          height_px: dims.height_px,
+          duration_seconds: dims.duration_seconds,
+        }],
+        rowCount: 1,
+      };
+    }
+    if (trimmed.startsWith('INSERT INTO scheduled_posts')) {
+      const [postId, tenantId, scheduledFor, platforms] = params as [number, number, string, string[]];
+      return {
+        rows: [{
+          id: nextScheduledId++,
+          post_id: postId,
+          tenant_id: tenantId,
+          scheduled_for: scheduledFor,
+          target_platforms: platforms,
+          updated_at: '2026-06-23T12:00:00.000Z',
+        }],
+        rowCount: 1,
+      };
+    }
+    // Campaign end date query (resolveCampaignEndDateForJob) — return null.
+    return { rows: [], rowCount: 0 };
+  });
+  return { queryable: { query } as unknown as ScheduleRouteQueryable, calls };
+}
+
+function tenantLoader(tenantId: number) {
+  return async () => ({
+    userId: '1001',
+    tenantId: String(tenantId),
+    tenantSlug: `tenant-${tenantId}`,
+    role: 'tenant_admin' as const,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Slice 6 — dims threaded into scheduled_posts INSERT
+// ---------------------------------------------------------------------------
+
+test('dims: video reel post with 1080x1920 and 15s are in scheduled_posts INSERT params', async () => {
+  // FAIL BEFORE: route did not SELECT/pass width_px/height_px/duration_seconds
+  // PASS AFTER:  route reads from posts row and passes to upsertScheduledPost → params[7..9]
+  const { queryable, calls } = buildQueryableWithDims({ width_px: 1080, height_px: 1920, duration_seconds: 15 });
+
+  const response = await handlePatchScheduleSocialContentPost(
+    'job-dims-test',
+    '42',
+    new Request('http://aries.example.test/api/social-content/jobs/job-dims-test/posts/42/schedule', {
+      method: 'PATCH',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ scheduled_at: '2026-06-25T09:00:00.000Z', platforms: ['instagram'] }),
+    }),
+    {
+      tenantContextLoader: tenantLoader(7),
+      queryable,
+      publishApprovalResolver: async () => true,
+    },
+  );
+
+  assert.equal(response.status, 200, 'response must be 200 OK');
+
+  const insertCall = calls.find((c) => c.sql.startsWith('INSERT INTO scheduled_posts'));
+  assert.ok(insertCall, 'INSERT INTO scheduled_posts must run');
+
+  // UPSERT_SCHEDULED_POST_SQL params (0-based):
+  // [0]=postId [1]=tenantId [2]=scheduledFor [3]=platforms [4]=campaignEndDate
+  // [5]=surface [6]=mediaType [7]=widthPx [8]=heightPx [9]=durationSeconds
+  const p = insertCall!.params;
+  assert.equal(p[5], 'reel', '$6 surface from post row must be reel');
+  assert.equal(p[6], 'video', '$7 mediaType from post row must be video');
+  assert.equal(p[7], 1080, '$8 widthPx must be 1080 from posts row');
+  assert.equal(p[8], 1920, '$9 heightPx must be 1920');
+  assert.equal(p[9], 15, '$10 durationSeconds must be 15');
+});
+
+test('dims: post with null dims passes null into scheduled_posts INSERT', async () => {
+  const { queryable, calls } = buildQueryableWithDims({ width_px: null, height_px: null, duration_seconds: null });
+
+  await handlePatchScheduleSocialContentPost(
+    'job-null-dims',
+    '55',
+    new Request('http://aries.example.test/api/social-content/jobs/job-null-dims/posts/55/schedule', {
+      method: 'PATCH',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ scheduled_at: '2026-06-25T10:00:00.000Z', platforms: ['facebook'] }),
+    }),
+    {
+      tenantContextLoader: tenantLoader(8),
+      queryable,
+      publishApprovalResolver: async () => true,
+    },
+  );
+
+  const insertCall = calls.find((c) => c.sql.startsWith('INSERT INTO scheduled_posts'));
+  assert.ok(insertCall, 'INSERT must run');
+
+  const p = insertCall!.params;
+  assert.equal(p[7], null, '$8 widthPx null when no dims');
+  assert.equal(p[8], null, '$9 heightPx null');
+  assert.equal(p[9], null, '$10 durationSeconds null');
+});
+
+test('dims: SELECT from posts includes the dims columns', async () => {
+  const { queryable, calls } = buildQueryableWithDims({ width_px: 720, height_px: 1280, duration_seconds: 8 });
+
+  await handlePatchScheduleSocialContentPost(
+    'job-select-check',
+    '77',
+    new Request('http://aries.example.test/api/social-content/jobs/job-select-check/posts/77/schedule', {
+      method: 'PATCH',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ scheduled_at: '2026-06-25T11:00:00.000Z', platforms: ['instagram'] }),
+    }),
+    {
+      tenantContextLoader: tenantLoader(9),
+      queryable,
+      publishApprovalResolver: async () => true,
+    },
+  );
+
+  // The route's SELECT must include width_px, height_px, duration_seconds so
+  // the dims can be passed through. This test ensures the SELECT SQL was widened.
+  const selectCall = calls.find((c) => c.sql.startsWith('SELECT id, tenant_id') && c.sql.includes('FROM posts'));
+  assert.ok(selectCall, 'SELECT FROM posts must run');
+  assert.ok(
+    selectCall!.sql.includes('width_px'),
+    'SELECT must include width_px (FAIL BEFORE: was not selected)',
+  );
+  assert.ok(selectCall!.sql.includes('height_px'), 'SELECT must include height_px');
+  assert.ok(selectCall!.sql.includes('duration_seconds'), 'SELECT must include duration_seconds');
+});
+
+// ---------------------------------------------------------------------------
+// Also test upsertScheduledPost directly with dims (unit-level)
+// ---------------------------------------------------------------------------
+
+test('upsertScheduledPost: dims passed as params $8/$9/$10', async () => {
+  const { upsertScheduledPost } = await import('../backend/social-content/scheduled-posts');
+
+  const captured: { sql: string; params: unknown[] }[] = [];
+  const mockQueryable = {
+    query: async (sql: string, params: unknown[]) => {
+      captured.push({ sql, params });
+      return {
+        rows: [{
+          id: '999', post_id: '42', tenant_id: 15,
+          scheduled_for: '2026-06-25T09:00:00.000Z',
+          target_platforms: ['instagram'],
+          updated_at: '2026-06-23T00:00:00.000Z',
+        }],
+        rowCount: 1,
+      };
+    },
+  };
+
+  await upsertScheduledPost(mockQueryable, {
+    tenantId: 15,
+    postId: 42,
+    scheduledFor: new Date('2026-06-25T09:00:00.000Z'),
+    platforms: ['instagram'],
+    surface: 'reel',
+    mediaType: 'video',
+    widthPx: 1080,
+    heightPx: 1920,
+    durationSeconds: 20,
+  });
+
+  assert.equal(captured.length, 1);
+  const p = captured[0]!.params;
+  // $8=widthPx, $9=heightPx, $10=durationSeconds (0-based: p[7], p[8], p[9])
+  assert.equal(p[7], 1080, '$8 widthPx=1080');
+  assert.equal(p[8], 1920, '$9 heightPx=1920');
+  assert.equal(p[9], 20, '$10 durationSeconds=20');
+  // Also verify surface/mediaType are correct
+  assert.equal(p[5], 'reel', '$6 surface=reel');
+  assert.equal(p[6], 'video', '$7 mediaType=video');
+});
+
+test('upsertScheduledPost: null dims map to null params', async () => {
+  const { upsertScheduledPost } = await import('../backend/social-content/scheduled-posts');
+
+  const captured: { sql: string; params: unknown[] }[] = [];
+  const mockQueryable = {
+    query: async (sql: string, params: unknown[]) => {
+      captured.push({ sql, params });
+      return {
+        rows: [{ id: '1', post_id: '1', tenant_id: 1, scheduled_for: new Date().toISOString(), target_platforms: [], updated_at: new Date().toISOString() }],
+        rowCount: 1,
+      };
+    },
+  };
+
+  await upsertScheduledPost(mockQueryable, {
+    tenantId: 1,
+    postId: 1,
+    scheduledFor: new Date(),
+    platforms: [],
+  });
+
+  const p = captured[0]!.params;
+  assert.equal(p[7], null, 'widthPx defaults to null');
+  assert.equal(p[8], null, 'heightPx defaults to null');
+  assert.equal(p[9], null, 'durationSeconds defaults to null');
+});
diff --git a/tests/social-content/video-production-context.test.ts b/tests/social-content/video-production-context.test.ts
new file mode 100644
index 00000000..a5de8ee1
--- /dev/null
+++ b/tests/social-content/video-production-context.test.ts
@@ -0,0 +1,231 @@
+/**
+ * Slice 3 — buildProductionResumeContext emits a 9:16 video brief + the
+ * VIDEO_EXECUTION_CONTRACT schema when videoRenderCount > 0 AND
+ * ARIES_VIDEO_PUBLISH_ENABLED is on.
+ *
+ * CRITICAL golden no-op test: when videoRenderCount === 0 (or flag off) the
+ * contextBlock is byte-identical to the pre-change baseline.
+ *
+ * Run:
+ *   APP_BASE_URL=https://aries.example.com \
+ *     ./node_modules/.bin/tsx --test tests/social-content/video-production-context.test.ts
+ */
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { buildProductionResumeContext } from '../../backend/social-content/workflow-request';
+import type { SocialContentJobRuntimeDocument } from '../../backend/marketing/runtime-state';
+
+// ---------------------------------------------------------------------------
+// Fixture
+// ---------------------------------------------------------------------------
+
+function makeDoc(videoRenderCount = 0): SocialContentJobRuntimeDocument {
+  const ts = '2026-06-23T00:00:00.000Z';
+  const stage = (name: string, status: string) => ({
+    stage: name, status, started_at: ts, completed_at: null, failed_at: null,
+    run_id: null, summary: null, primary_output: null, outputs: {}, artifacts: [], errors: [],
+  });
+  return {
+    schema_name: 'marketing_job_state_schema',
+    schema_version: '1.0.0',
+    job_id: 'mkt_video_ctx',
+    tenant_id: '15',
+    job_type: 'weekly_social_content',
+    state: 'running',
+    status: 'running',
+    current_stage: 'production',
+    stage_order: ['research', 'strategy', 'production', 'publish'],
+    stages: {
+      research: { ...stage('research', 'completed'), stage: 'research' },
+      strategy: { ...stage('strategy', 'completed'), stage: 'strategy' },
+      production: { ...stage('production', 'in_progress'), stage: 'production' },
+      publish: { ...stage('publish', 'not_started'), stage: 'publish' },
+    } as SocialContentJobRuntimeDocument['stages'],
+    approvals: { current: null, history: [] },
+    publish_config: { platforms: [], live_publish_platforms: [], video_render_platforms: [] },
+    brand_kit: {
+      source_url: 'https://brand.example/',
+      canonical_url: 'https://brand.example/',
+      brand_name: 'Test Brand',
+      logo_urls: ['https://brand.example/logo.svg'],
+      colors: { primary: '#111111', secondary: '#f4f4f4', accent: null, palette: ['#111111', '#f4f4f4'] },
+      font_families: ['Inter'],
+      external_links: [],
+      extracted_at: ts,
+      brand_voice_summary: 'Direct and warm.',
+      offer_summary: null,
+      positioning: null,
+      audience: null,
+      tone_of_voice: null,
+      style_vibe: null,
+      path: '/tmp/brand-kit.json',
+    },
+    inputs: {
+      brand_url: 'https://brand.example/',
+      request: {
+        imageCreativeCount: 1,
+        videoRenderCount,
+        channels: ['instagram'],
+      },
+    },
+    errors: [], last_error: null, history: [], created_at: ts, updated_at: ts,
+    social_content_runtime: null, created_by: null, deleted_at: null, deleted_by: null,
+    soft_cancel_requested_at: null,
+  } as SocialContentJobRuntimeDocument;
+}
+
+function withVideoFlag<T>(value: '0' | '1', fn: () => T): T {
+  const prev = process.env.ARIES_VIDEO_PUBLISH_ENABLED;
+  process.env.ARIES_VIDEO_PUBLISH_ENABLED = value;
+  try {
+    return fn();
+  } finally {
+    if (prev === undefined) delete process.env.ARIES_VIDEO_PUBLISH_ENABLED;
+    else process.env.ARIES_VIDEO_PUBLISH_ENABLED = prev;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Slice 3 — video brief emission
+// ---------------------------------------------------------------------------
+
+test('flag ON + videoRenderCount=1: contextBlock emits 9:16 aspect ratio in video clip section', () => {
+  // FAIL BEFORE: video section was not emitted at all (videoClipCount always 0 or not wired)
+  // PASS AFTER:  video clip section appears with "9:16" aspect ratio
+  withVideoFlag('1', () => {
+    const { contextBlock } = buildProductionResumeContext({
+      doc: makeDoc(1),
+      researchOutput: null,
+      strategyOutput: null,
+    });
+    assert.match(contextBlock, /Aspect ratio: 9:16/, 'video clip section must declare 9:16 aspect ratio');
+    assert.match(contextBlock, /--- Video clip 1 of 1 ---/, 'video clip header must appear');
+    assert.match(contextBlock, /Target duration:.*15 seconds/, 'target duration must be stated');
+  });
+});
+
+test('flag ON + videoRenderCount=1: contextBlock emits the VIDEO_EXECUTION_CONTRACT schema fields', () => {
+  withVideoFlag('1', () => {
+    const { contextBlock } = buildProductionResumeContext({
+      doc: makeDoc(1),
+      researchOutput: null,
+      strategyOutput: null,
+    });
+    // Schema emitted in the context block
+    assert.match(contextBlock, /"type": "generated_video"/, 'schema must specify type: generated_video');
+    assert.match(contextBlock, /"media_type": "video"/, 'schema must specify media_type: video');
+    assert.match(contextBlock, /"surface": "reel"/, 'schema must specify surface: reel');
+    assert.match(contextBlock, /"duration_seconds"/, 'schema must include duration_seconds field');
+    assert.match(contextBlock, /width.*height/, 'schema must mention width and height');
+    assert.match(contextBlock, /MANDATORY.*width.*height.*duration_seconds/i, 'MANDATORY clause for dims must be present');
+  });
+});
+
+test('flag ON + videoRenderCount=1: videoPrompts is returned with aspectRatio 9:16', () => {
+  withVideoFlag('1', () => {
+    const result = buildProductionResumeContext({
+      doc: makeDoc(1),
+      researchOutput: null,
+      strategyOutput: null,
+    });
+    assert.ok(result.videoPrompts && result.videoPrompts.length > 0, 'videoPrompts must be non-empty when flag ON');
+    const vp = result.videoPrompts![0]!;
+    assert.equal(vp.aspectRatio, '9:16', 'videoPrompt aspectRatio must be 9:16');
+    assert.equal(vp.clipIndex, 1);
+    assert.equal(vp.totalClips, 1);
+    assert.ok(typeof vp.targetDurationSeconds === 'number', 'targetDurationSeconds must be a number');
+    assert.ok(vp.prompt.length > 0, 'prompt must be non-empty');
+  });
+});
+
+test('flag ON + videoRenderCount=2: clamped to MAX (1) — only 1 clip in this pass', () => {
+  // SOCIAL_CONTENT_MAX_VIDEO_RENDER_COUNT = 1 in this pass (single-clip MVP).
+  // The request with videoRenderCount=2 is clamped to 1 by clampCount().
+  withVideoFlag('1', () => {
+    const { contextBlock, videoPrompts } = buildProductionResumeContext({
+      doc: makeDoc(2),
+      researchOutput: null,
+      strategyOutput: null,
+    });
+    // Clamped to 1, so header reads "1 of 1" (not "1 of 2").
+    assert.match(contextBlock, /--- Video clip 1 of 1 ---/, 'clamped to 1 clip');
+    assert.ok(!contextBlock.includes('--- Video clip 2 of'), 'no second clip section');
+    assert.equal(videoPrompts?.length, 1, 'exactly 1 videoPrompt returned (clamped)');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// CRITICAL golden no-op: byte-identical when flag OFF or videoRenderCount=0
+// ---------------------------------------------------------------------------
+
+test('GOLDEN: flag OFF → contextBlock is byte-identical regardless of videoRenderCount', () => {
+  // This is the core regression guard: the flag OFF path must be byte-identical
+  // to the baseline (no video section, no schema, no dims). If this test breaks,
+  // the contextBlock changed for existing jobs and is a regression.
+  const baseline = withVideoFlag('0', () =>
+    buildProductionResumeContext({ doc: makeDoc(0), researchOutput: null, strategyOutput: null }).contextBlock
+  );
+  withVideoFlag('0', () => {
+    const withCount = buildProductionResumeContext({ doc: makeDoc(1), researchOutput: null, strategyOutput: null }).contextBlock;
+    assert.equal(withCount, baseline, 'flag OFF + videoRenderCount=1 must equal the 0-count baseline');
+    const withTwo = buildProductionResumeContext({ doc: makeDoc(2), researchOutput: null, strategyOutput: null }).contextBlock;
+    assert.equal(withTwo, baseline, 'flag OFF + videoRenderCount=2 must equal the 0-count baseline');
+  });
+});
+
+test('GOLDEN: flag unset → contextBlock byte-identical to flag OFF', () => {
+  const baseline = withVideoFlag('0', () =>
+    buildProductionResumeContext({ doc: makeDoc(0), researchOutput: null, strategyOutput: null }).contextBlock
+  );
+  const prevFlag = process.env.ARIES_VIDEO_PUBLISH_ENABLED;
+  delete process.env.ARIES_VIDEO_PUBLISH_ENABLED;
+  try {
+    const unset = buildProductionResumeContext({ doc: makeDoc(1), researchOutput: null, strategyOutput: null }).contextBlock;
+    assert.equal(unset, baseline, 'flag unset must be byte-identical to flag=0 baseline');
+  } finally {
+    if (prevFlag === undefined) delete process.env.ARIES_VIDEO_PUBLISH_ENABLED;
+    else process.env.ARIES_VIDEO_PUBLISH_ENABLED = prevFlag;
+  }
+});
+
+test('GOLDEN: flag ON + videoRenderCount=0 → contextBlock byte-identical to baseline', () => {
+  const baseline = withVideoFlag('0', () =>
+    buildProductionResumeContext({ doc: makeDoc(0), researchOutput: null, strategyOutput: null }).contextBlock
+  );
+  withVideoFlag('1', () => {
+    const ctx = buildProductionResumeContext({ doc: makeDoc(0), researchOutput: null, strategyOutput: null }).contextBlock;
+    assert.equal(ctx, baseline, 'flag ON + videoRenderCount=0 must be byte-identical (no video section)');
+  });
+});
+
+test('GOLDEN: videoPrompts absent when flag OFF', () => {
+  withVideoFlag('0', () => {
+    const result = buildProductionResumeContext({ doc: makeDoc(1), researchOutput: null, strategyOutput: null });
+    assert.ok(!result.videoPrompts || result.videoPrompts.length === 0, 'videoPrompts must be absent when flag OFF');
+  });
+});
+
+test('GOLDEN: videoPrompts absent when videoRenderCount=0 even with flag ON', () => {
+  withVideoFlag('1', () => {
+    const result = buildProductionResumeContext({ doc: makeDoc(0), researchOutput: null, strategyOutput: null });
+    assert.ok(!result.videoPrompts || result.videoPrompts.length === 0, 'videoPrompts must be absent when count=0');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Guard: existing image-only contextBlock is not disturbed when flag ON
+// ---------------------------------------------------------------------------
+
+test('image section is unaffected by video flag — image prompts still emitted', () => {
+  withVideoFlag('1', () => {
+    const { contextBlock, imagePrompts } = buildProductionResumeContext({
+      doc: makeDoc(1),
+      researchOutput: null,
+      strategyOutput: null,
+    });
+    assert.ok(imagePrompts.length > 0, 'image prompts must still be emitted');
+    assert.match(contextBlock, /--- Image 1 of/, 'image section header must appear');
+    assert.match(contextBlock, /"type": "generated_image"/, 'image schema must still appear');
+  });
+});
diff --git a/tests/video-publish-dispatch-wiring.test.ts b/tests/video-publish-dispatch-wiring.test.ts
new file mode 100644
index 00000000..5ab05119
--- /dev/null
+++ b/tests/video-publish-dispatch-wiring.test.ts
@@ -0,0 +1,482 @@
+/**
+ * Regression tests for the video-publish-foundation wiring:
+ *   Slice 1 — schema DDL (init-db.js + migration)
+ *   Slice 2 — mediaMetadata threading through dispatchPublish and the
+ *             scheduled-dispatch route handler
+ *
+ * FAILING BEFORE the change: the route and dispatchPublish had no
+ * width_px/height_px/duration_seconds columns in scheduled_posts, no
+ * mediaMetadata field in PublishPostInput, and the Composio leg of
+ * dispatchPublish omitted mediaMetadata entirely. The validator
+ * (meta-media-validation.ts) requires all three for any video surface and
+ * fails closed — so every video publish ended with missing_video_metadata
+ * before reaching the Graph API.
+ *
+ * PASSING AFTER: dims flow from the POST body → mediaMetadata → dispatchPublish
+ * → publishToMetaGraph → validator passes → Graph REELS call goes out.
+ */
+
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { dispatchPublish } from '../backend/integrations/publish-dispatch';
+import type {
+  MetaPublishRequest,
+  MetaPublishSuccess,
+} from '../backend/integrations/meta-publishing';
+import type { PublisherProvider } from '../backend/integrations/providers/interfaces';
+import type { PublishPostInput, PublishResult } from '../backend/integrations/providers/types';
+import pool from '../lib/db';
+import { encryptOAuthSecret } from '../backend/integrations/oauth-token-crypto';
+import { POST } from '../app/api/internal/publishing/scheduled-dispatch/route';
+
+const repoRoot = process.cwd();
+
+// ── Section 1: dispatchPublish mediaMetadata threading (pure unit, no DB) ────
+//
+// These prove Slice 2 at the dispatch boundary. No DB or network needed — DI
+// injection stubs out the provider.
+
+const VIDEO_META = [{ widthPx: 1080, heightPx: 1920, durationSeconds: 30 }] as const;
+
+test('dispatchPublish: mediaMetadata with valid dims is forwarded intact to the direct provider', async () => {
+  const directCalls: MetaPublishRequest[] = [];
+  const directResult: MetaPublishSuccess = {
+    provider: 'instagram',
+    mode: 'live',
+    platformPostId: 'ig_reel_dispatch_1',
+    scheduledFor: null,
+    connectionId: 'conn_1',
+  };
+
+  await dispatchPublish(
+    {
+      tenantId: '15',
+      provider: 'instagram',
+      content: 'reel caption',
+      mediaUrls: ['https://cdn.example.com/reel.mp4'],
+      placement: 'reel',
+      mediaType: 'video',
+      mediaMetadata: [...VIDEO_META],
+    },
+    {
+      selector: () => 'direct_meta',
+      directPublish: async (r) => {
+        directCalls.push(r);
+        return directResult;
+      },
+    },
+  );
+
+  assert.equal(directCalls.length, 1, 'directPublish must be called exactly once');
+  assert.deepEqual(
+    directCalls[0]!.mediaMetadata,
+    VIDEO_META,
+    'mediaMetadata must reach directPublish intact — no mutation or stripping',
+  );
+});
+
+test('dispatchPublish: absent mediaMetadata is forwarded as undefined (no fabricated zeros)', async () => {
+  const directCalls: MetaPublishRequest[] = [];
+  const directResult: MetaPublishSuccess = {
+    provider: 'instagram',
+    mode: 'live',
+    platformPostId: 'ig_feed_dispatch_1',
+    scheduledFor: null,
+    connectionId: 'conn_2',
+  };
+
+  await dispatchPublish(
+    {
+      tenantId: '15',
+      provider: 'instagram',
+      content: 'image post',
+      mediaUrls: ['https://cdn.example.com/img.png'],
+      // no mediaMetadata — must stay absent, never be replaced with zeros
+    },
+    {
+      selector: () => 'direct_meta',
+      directPublish: async (r) => {
+        directCalls.push(r);
+        return directResult;
+      },
+    },
+  );
+
+  assert.equal(directCalls.length, 1);
+  assert.equal(
+    directCalls[0]!.mediaMetadata,
+    undefined,
+    'absent mediaMetadata must arrive at directPublish as undefined, not [{ widthPx: 0, ... }]',
+  );
+});
+
+test('dispatchPublish: mediaMetadata is forwarded to Composio provider publishPost', async () => {
+  const composioCalls: PublishPostInput[] = [];
+  const composioProvider: PublisherProvider = {
+    kind: 'composio',
+    supports: () => true,
+    publishPost: async (input: PublishPostInput): Promise<PublishResult> => {
+      composioCalls.push(input);
+      return {
+        provider: 'composio',
+        platform: 'instagram',
+        externalPostId: 'ig_composio_reel_1',
+        externalCampaignId: null,
+        externalAdId: null,
+        status: 'published',
+        url: null,
+        rawResponse: {},
+      };
+    },
+  } as unknown as PublisherProvider;
+
+  await dispatchPublish(
+    {
+      tenantId: '15',
+      provider: 'instagram',
+      content: 'composio reel',
+      mediaUrls: ['https://cdn.example.com/reel.mp4'],
+      placement: 'reel',
+      mediaType: 'video',
+      mediaMetadata: [...VIDEO_META],
+    },
+    {
+      selector: () => 'composio',
+      publisherProvider: () => composioProvider,
+    },
+  );
+
+  assert.equal(composioCalls.length, 1, 'Composio publishPost must be called');
+  assert.deepEqual(
+    composioCalls[0]!.mediaMetadata,
+    VIDEO_META,
+    'mediaMetadata must reach Composio publishPost — not stripped on the Composio leg',
+  );
+});
+
+// ── Section 2: Route handler POST — mediaMetadata derivation + end-to-end ────
+//
+// These prove Slice 2 from the HTTP boundary. The route receives dims in the
+// POST body, builds mediaMetadata, and passes it into dispatchPublish which
+// feeds publishToMetaGraph. The validator must pass (dims present) or reject
+// (dims absent) at exactly the right point.
+
+/**
+ * Pool fixture: returns an oauth token row for instagram queries; returns
+ * empty rows for every other query (status UPDATEs, recompute helpers, etc.).
+ * The pool.query overload is broad-cast with `as unknown` like existing tests.
+ */
+function installPoolFixture(accessTokenEnc: string, externalAccountId: string) {
+  const originalQuery = pool.query.bind(pool);
+  (pool as typeof pool & { query: typeof pool.query }).query = (async (
+    sql: unknown,
+    _params?: unknown,
+  ) => {
+    const upperSql = typeof sql === 'string' ? sql.toUpperCase() : '';
+    if (upperSql.includes('OAUTH_TOKENS') || upperSql.includes('OAUTH_CONNECTIONS')) {
+      return {
+        rows: [
+          {
+            access_token_enc: accessTokenEnc,
+            connection_id: 'conn_route_test',
+            external_account_id: externalAccountId,
+          },
+        ],
+        rowCount: 1,
+        command: 'SELECT',
+        oid: 0,
+        fields: [],
+      };
+    }
+    return { rows: [], rowCount: 0, command: 'SELECT', oid: 0, fields: [] };
+  }) as unknown as typeof pool.query;
+  return () => {
+    (pool as typeof pool & { query: typeof pool.query }).query = originalQuery;
+  };
+}
+
+function makeScheduledDispatchRequest(
+  body: Record<string, unknown>,
+  secret: string,
+): Request {
+  return new Request(
+    'https://aries.example.com/api/internal/publishing/scheduled-dispatch',
+    {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        authorization: `Bearer ${secret}`,
+      },
+      body: JSON.stringify(body),
+    },
+  );
+}
+
+/**
+ * Route POST: video body with width_px + height_px + duration_seconds present
+ * → mediaMetadata = [{ widthPx, heightPx, durationSeconds }]
+ * → validator passes (9:16 reel, 30s inside 3–90s window)
+ * → IG container creation goes out with media_type=REELS
+ * → response is 202 ok
+ */
+test('route POST: video + dims present → mediaMetadata built → REELS Graph call → 202', async () => {
+  const secret = 'test-secret-for-video-dispatch-wiring';
+  const prevSecret = process.env.INTERNAL_API_SECRET;
+  const prevEncKey = process.env.OAUTH_TOKEN_ENCRYPTION_KEY;
+  process.env.INTERNAL_API_SECRET = secret;
+  process.env.OAUTH_TOKEN_ENCRYPTION_KEY = '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!';
+
+  const accessTokenEnc = encryptOAuthSecret('ig-route-token');
+  const restorePool = installPoolFixture(accessTokenEnc, 'ig_acc_route_wiring');
+
+  const graphCalls: Array<{ url: string; body: string | null }> = [];
+  const origFetch = globalThis.fetch;
+  globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = String(input);
+    const body = typeof init?.body === 'string' ? init.body : null;
+    graphCalls.push({ url, body });
+    // IG media_publish (final step)
+    if (url.includes('/media_publish')) {
+      return new Response(JSON.stringify({ id: 'route_reel_post_1' }), { status: 200 });
+    }
+    // IG container creation (first step: creates REELS container)
+    if (url.includes('/media')) {
+      return new Response(JSON.stringify({ id: 'route_container_1' }), { status: 200 });
+    }
+    // Container status poll: return FINISHED immediately so no sleep is needed
+    return new Response(JSON.stringify({ status_code: 'FINISHED' }), { status: 200 });
+  }) as typeof fetch;
+
+  try {
+    const req = makeScheduledDispatchRequest(
+      {
+        tenant_id: '15',
+        platforms: ['instagram'],
+        content: 'reel video test',
+        media_urls: ['https://cdn.example.com/reel.mp4'],
+        surface: 'reel',
+        media_type: 'video',
+        width_px: 1080,
+        height_px: 1920,
+        duration_seconds: 30,
+        // post_id absent → skips DB status UPDATE + recomputePendingApprovalCount
+      },
+      secret,
+    );
+
+    const resp = await POST(req);
+    const data = (await resp.json()) as {
+      status: string;
+      results: Array<{ provider: string; ok: boolean; error?: string }>;
+    };
+
+    assert.equal(
+      resp.status,
+      202,
+      `Expected 202 ok; got ${resp.status}: ${JSON.stringify(data)}`,
+    );
+    assert.equal(data.status, 'ok', 'response body status must be ok');
+    assert.equal(data.results.length, 1);
+    assert.equal(data.results[0]!.ok, true, 'instagram platform must succeed');
+
+    // The IG container creation Graph call MUST include media_type=REELS.
+    // This confirms: (a) mediaMetadata was built from the body dims,
+    // (b) it was passed to publishToMetaGraph,
+    // (c) the validator accepted it (valid 9:16, 30s reel),
+    // (d) createInstagramContainer selected the REELS branch.
+    const containerCall = graphCalls.find(
+      (c) => c.url.includes('/media') && !c.url.includes('/media_publish'),
+    );
+    assert.ok(containerCall, 'IG container creation Graph call must have been made');
+    assert.match(
+      containerCall!.body ?? '',
+      /media_type=REELS/,
+      'REELS branch requires valid mediaMetadata — proves the end-to-end wiring works',
+    );
+  } finally {
+    globalThis.fetch = origFetch;
+    restorePool();
+    if (prevSecret === undefined) delete process.env.INTERNAL_API_SECRET;
+    else process.env.INTERNAL_API_SECRET = prevSecret;
+    if (prevEncKey === undefined) delete process.env.OAUTH_TOKEN_ENCRYPTION_KEY;
+    else process.env.OAUTH_TOKEN_ENCRYPTION_KEY = prevEncKey;
+  }
+});
+
+/**
+ * Route POST: video body WITHOUT width_px / height_px / duration_seconds
+ * → mediaMetadata is undefined (route must not fabricate zeros)
+ * → publishToMetaGraph builds null dims → validator throws missing_video_metadata
+ * → response is 422 (terminal, non-retryable)
+ * → NO Graph API calls are made (validator fires before createInstagramContainer)
+ *
+ * This is the fail-closed invariant: absent dims are rejected, never silently
+ * passed to Meta as zeros which would violate the duration/aspect constraints.
+ */
+test('route POST: video + dims absent → mediaMetadata undefined → missing_video_metadata → 422', async () => {
+  const secret = 'test-secret-for-video-dispatch-absent-dims';
+  const prevSecret = process.env.INTERNAL_API_SECRET;
+  const prevEncKey = process.env.OAUTH_TOKEN_ENCRYPTION_KEY;
+  process.env.INTERNAL_API_SECRET = secret;
+  process.env.OAUTH_TOKEN_ENCRYPTION_KEY = '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!';
+
+  const accessTokenEnc = encryptOAuthSecret('ig-route-token-absent');
+  const restorePool = installPoolFixture(accessTokenEnc, 'ig_acc_route_absent');
+
+  const graphCalls: string[] = [];
+  const origFetch = globalThis.fetch;
+  // Install a fetch that records calls. Should never be called — the validator
+  // must throw before createInstagramContainer is reached. If fetch IS called,
+  // it returns an error body so the route returns 502/422 instead of 202;
+  // the `graphCalls.length === 0` assertion then catches the bug.
+  globalThis.fetch = (async (input: RequestInfo | URL) => {
+    graphCalls.push(String(input));
+    return new Response(
+      JSON.stringify({ error: { message: 'unexpected fetch: validator should have rejected first' } }),
+      { status: 500 },
+    );
+  }) as typeof fetch;
+
+  try {
+    const req = makeScheduledDispatchRequest(
+      {
+        tenant_id: '15',
+        platforms: ['instagram'],
+        content: 'reel without dims',
+        media_urls: ['https://cdn.example.com/reel.mp4'],
+        surface: 'reel',
+        media_type: 'video',
+        // width_px / height_px / duration_seconds intentionally absent
+        // The route must NOT fabricate { widthPx: 0, ... }
+      },
+      secret,
+    );
+
+    const resp = await POST(req);
+    const data = (await resp.json()) as {
+      status: string;
+      results: Array<{ provider: string; ok: boolean; error?: string }>;
+    };
+
+    // All platforms failed terminally (missing_video_metadata is retryable:false)
+    assert.equal(
+      resp.status,
+      422,
+      `Expected 422 terminal error; got ${resp.status}: ${JSON.stringify(data)}`,
+    );
+    assert.equal(data.status, 'error');
+    assert.equal(data.results.length, 1);
+    assert.equal(data.results[0]!.ok, false, 'instagram must fail');
+
+    // The error must specifically be missing_video_metadata, not some other
+    // error like oauth_token_missing or unsupported_provider. This verifies
+    // the code reached the validator (token was found, platform is supported)
+    // and the validator correctly identified the missing dims.
+    assert.match(
+      data.results[0]!.error ?? '',
+      /missing_video_metadata/,
+      'validator must surface missing_video_metadata when dims are absent',
+    );
+
+    // No Graph API calls must have been made — validation fires before the
+    // createInstagramContainer call that would trigger the first fetch.
+    assert.equal(
+      graphCalls.length,
+      0,
+      'No Graph call must be made when dims are absent — validation is fail-closed',
+    );
+  } finally {
+    globalThis.fetch = origFetch;
+    restorePool();
+    if (prevSecret === undefined) delete process.env.INTERNAL_API_SECRET;
+    else process.env.INTERNAL_API_SECRET = prevSecret;
+    if (prevEncKey === undefined) delete process.env.OAUTH_TOKEN_ENCRYPTION_KEY;
+    else process.env.OAUTH_TOKEN_ENCRYPTION_KEY = prevEncKey;
+  }
+});
+
+// ── Section 3: DDL assertions (Slice 1) ─────────────────────────────────────
+//
+// Verify that init-db.js and the migration contain the new columns.
+// Pattern matches must be loose enough to survive whitespace but specific
+// enough to catch a missing column (e.g. it was added only as an ALTER
+// but not in the CREATE TABLE).
+
+test('init-db.js: creative_assets CREATE TABLE includes width_px, height_px, duration_seconds', () => {
+  const src = fs.readFileSync(path.join(repoRoot, 'scripts/init-db.js'), 'utf-8');
+
+  // The CREATE TABLE block for creative_assets must declare all three columns.
+  // Use a regex that spans multiple lines ([\s\S]*?) and confirms the column
+  // appears inside the same CREATE TABLE block (not in a later ALTER).
+  const createBlock = src.match(
+    /CREATE TABLE IF NOT EXISTS creative_assets\s*\(([\s\S]*?)\);/,
+  );
+  assert.ok(createBlock, 'creative_assets CREATE TABLE block must exist');
+  const block = createBlock![1];
+  assert.match(block, /width_px\s+INTEGER/, 'creative_assets CREATE TABLE must have width_px INTEGER');
+  assert.match(block, /height_px\s+INTEGER/, 'creative_assets CREATE TABLE must have height_px INTEGER');
+  assert.match(block, /duration_seconds\s+INTEGER/, 'creative_assets CREATE TABLE must have duration_seconds INTEGER');
+});
+
+test('init-db.js: ALTER backfills add video columns to posts and scheduled_posts', () => {
+  const src = fs.readFileSync(path.join(repoRoot, 'scripts/init-db.js'), 'utf-8');
+
+  // posts backfill
+  assert.match(
+    src,
+    /ALTER TABLE posts ADD COLUMN IF NOT EXISTS width_px\s+INTEGER/,
+    'posts ALTER backfill must add width_px',
+  );
+  assert.match(
+    src,
+    /ALTER TABLE posts ADD COLUMN IF NOT EXISTS height_px\s+INTEGER/,
+    'posts ALTER backfill must add height_px',
+  );
+  assert.match(
+    src,
+    /ALTER TABLE posts ADD COLUMN IF NOT EXISTS duration_seconds\s+INTEGER/,
+    'posts ALTER backfill must add duration_seconds',
+  );
+
+  // scheduled_posts backfill
+  assert.match(
+    src,
+    /ALTER TABLE scheduled_posts ADD COLUMN IF NOT EXISTS width_px\s+INTEGER/,
+    'scheduled_posts ALTER backfill must add width_px',
+  );
+  assert.match(
+    src,
+    /ALTER TABLE scheduled_posts ADD COLUMN IF NOT EXISTS height_px\s+INTEGER/,
+    'scheduled_posts ALTER backfill must add height_px',
+  );
+  assert.match(
+    src,
+    /ALTER TABLE scheduled_posts ADD COLUMN IF NOT EXISTS duration_seconds\s+INTEGER/,
+    'scheduled_posts ALTER backfill must add duration_seconds',
+  );
+});
+
+test('migration 20260623120000_video_media_metadata.sql is idempotent and covers all three tables', () => {
+  const src = fs.readFileSync(
+    path.join(repoRoot, 'migrations/20260623120000_video_media_metadata.sql'),
+    'utf-8',
+  );
+
+  // All three tables must have all three columns added idempotently.
+  for (const table of ['creative_assets', 'posts', 'scheduled_posts']) {
+    for (const col of ['width_px', 'height_px', 'duration_seconds']) {
+      const pattern = new RegExp(
+        `ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${col}`,
+        'i',
+      );
+      assert.match(
+        src,
+        pattern,
+        `migration must contain ADD COLUMN IF NOT EXISTS ${col} for ${table}`,
+      );
+    }
+  }
+});
diff --git a/tests/video-synthesize-dims.test.ts b/tests/video-synthesize-dims.test.ts
new file mode 100644
index 00000000..8b4b0311
--- /dev/null
+++ b/tests/video-synthesize-dims.test.ts
@@ -0,0 +1,208 @@
+/**
+ * Slice 2 — synthesize-publish-posts copies width_px/height_px/duration_seconds
+ * from the linked creative_asset DB row into the synthesized posts INSERT.
+ *
+ * Run:
+ *   APP_BASE_URL=https://aries.example.com \
+ *     ./node_modules/.bin/tsx --test tests/video-synthesize-dims.test.ts
+ */
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { synthesizePublishPostsFromContentPackage } from '../backend/marketing/synthesize-publish-posts';
+import type { SocialContentJobRuntimeDocument } from '../backend/marketing/runtime-state';
+
+// ---------------------------------------------------------------------------
+// Helpers — mirrored from tests/synthesize-publish-posts-surface.test.ts
+// ---------------------------------------------------------------------------
+
+function stage(name: string, primaryOutput: unknown) {
+  return {
+    stage: name, status: 'completed', started_at: null, completed_at: null,
+    failed_at: null, run_id: null, summary: null, primary_output: primaryOutput,
+    outputs: {}, artifacts: [], errors: [],
+  };
+}
+
+// Single-entry content_package so only 1 post is synthesized per test (1:1 dims check).
+function makeDoc(jobId: string, schedule: unknown[]): SocialContentJobRuntimeDocument {
+  return {
+    schema_name: 'marketing_job_state_schema', schema_version: '1.0.0', job_id: jobId,
+    tenant_id: '15', job_type: 'weekly_social_content', state: 'completed', status: 'completed',
+    current_stage: 'publish',
+    stages: {
+      research: stage('research', null),
+      strategy: stage('strategy', null),
+      production: stage('production', {
+        stage: 'production',
+        content_package: [
+          { post_number: 1, hook: 'H1', body: 'B1', cta: 'C1', hashtags: ['#a'], platforms: ['instagram'] },
+        ],
+      }),
+      publish: stage('publish', { stage: 'publish', schedule }),
+    },
+    approvals: { current: null, history: [] },
+    publish_config: { platforms: [], live_publish_platforms: [], video_render_platforms: [] },
+    brand_kit: null, inputs: { request: {}, brand_url: 'https://example.com' },
+    history: [], errors: [], last_error: null,
+  } as unknown as SocialContentJobRuntimeDocument;
+}
+
+async function withDataRoot<T>(fn: () => Promise<T>): Promise<T> {
+  const dir = await mkdtemp(path.join(tmpdir(), 'synth-dims-'));
+  const prev = process.env.DATA_ROOT;
+  process.env.DATA_ROOT = dir;
+  try {
+    return await fn();
+  } finally {
+    if (prev === undefined) delete process.env.DATA_ROOT;
+    else process.env.DATA_ROOT = prev;
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+// Pool that returns creative_assets WITH video dims for the SELECT, and
+// captures INSERT params.
+function makeDimsPool(assetRows: unknown[]) {
+  const inserts: unknown[][] = [];
+  const pool = {
+    async query(sql: string, params: unknown[] = []) {
+      if (/INSERT INTO posts/i.test(sql)) {
+        inserts.push(params);
+        return { rows: [{ id: inserts.length }], rowCount: 1 };
+      }
+      if (/FROM creative_assets/i.test(sql)) {
+        return { rows: assetRows, rowCount: assetRows.length };
+      }
+      return { rows: [], rowCount: 0 };
+    },
+  };
+  return { pool, inserts };
+}
+
+// ---------------------------------------------------------------------------
+// Slice 2 — dims thread from creative_asset → posts INSERT
+// ---------------------------------------------------------------------------
+
+test('dims: synthesized post copies width/height/duration from linked creative_asset (flag ON)', async () => {
+  // FAIL BEFORE: SELECT_CREATIVE_ASSETS_SQL didn't include width_px/height_px/duration_seconds,
+  //   so the AssetInfo had null dims and params[11..13] were always null.
+  // PASS AFTER:  SELECT includes dims; they are threaded into $12/$13/$14.
+  await withDataRoot(async () => {
+    const prevFlag = process.env.ARIES_VIDEO_PUBLISH_ENABLED;
+    process.env.ARIES_VIDEO_PUBLISH_ENABLED = '1';
+    const { pool, inserts } = makeDimsPool([
+      // post_number 1 → reel asset with dims
+      { id: 'uuid-vid1', source_asset_id: 'vid_1', width_px: 1080, height_px: 1920, duration_seconds: 15 },
+    ]);
+    const schedule = [
+      { post_number: 1, platforms: ['instagram'], placement: 'reel', media_type: 'video' },
+    ];
+    try {
+      await synthesizePublishPostsFromContentPackage({
+        jobId: 'job_dims_on', tenantId: 15, doc: makeDoc('job_dims_on', schedule), publishRunId: null, pool,
+      });
+    } finally {
+      if (prevFlag === undefined) delete process.env.ARIES_VIDEO_PUBLISH_ENABLED;
+      else process.env.ARIES_VIDEO_PUBLISH_ENABLED = prevFlag;
+    }
+
+    assert.equal(inserts.length, 1, 'one reel post inserted');
+    const p = inserts[0]!;
+    // INSERT param positions (0-based):
+    // [0]=tenantId [1]=jobId [2]=publishRunId [3]=platform [4]=caption
+    // [5]=idempotencyKey [6]=creativeAssetIds [7]=mediaType [8]=surface
+    // [9]=styleDimension [10]=styleValue [11]=widthPx [12]=heightPx [13]=durationSeconds
+    assert.equal(p[11], 1080, '$12 widthPx must be 1080 from creative_asset');
+    assert.equal(p[12], 1920, '$13 heightPx must be 1920 from creative_asset');
+    assert.equal(p[13], 15, '$14 durationSeconds must be 15 from creative_asset');
+    assert.equal(p[7], 'video', 'media_type must be video');
+    assert.equal(p[8], 'reel', 'surface must be reel');
+  });
+});
+
+test('dims: feed image post has null dims when creative_asset has no dims', async () => {
+  await withDataRoot(async () => {
+    const { pool, inserts } = makeDimsPool([
+      // feed image asset: width_px/height_px/duration_seconds are null
+      { id: 'uuid-img1', source_asset_id: 'img_1', width_px: null, height_px: null, duration_seconds: null },
+    ]);
+    const schedule = [
+      { post_number: 1, platforms: ['instagram'], placement: 'feed', media_type: 'image' },
+    ];
+    delete process.env.ARIES_VIDEO_PUBLISH_ENABLED;
+    await synthesizePublishPostsFromContentPackage({
+      jobId: 'job_null_dims', tenantId: 15, doc: makeDoc('job_null_dims', schedule), publishRunId: null, pool,
+    });
+
+    assert.equal(inserts.length, 1);
+    const p = inserts[0]!;
+    assert.equal(p[11], null, '$12 widthPx null when asset has no dims');
+    assert.equal(p[12], null, '$13 heightPx null');
+    assert.equal(p[13], null, '$14 durationSeconds null');
+  });
+});
+
+test('dims: story insert (composed story path) always has null dims in this pass', async () => {
+  // The story path passes null for dims (composed story images don't carry dims
+  // from the base asset in this slice).
+  await withDataRoot(async () => {
+    delete process.env.ARIES_VIDEO_PUBLISH_ENABLED;
+    const { pool, inserts } = makeDimsPool([
+      // Two feed assets so story promotion can link a creative.
+      { id: 'uuid-1', source_asset_id: 'img_1', width_px: 800, height_px: 1000, duration_seconds: null },
+      { id: 'uuid-2', source_asset_id: 'img_2', width_px: 800, height_px: 1000, duration_seconds: null },
+    ]);
+
+    const schedule = [
+      { post_number: 1, platforms: ['instagram'], placement: 'feed', media_type: 'image' },
+      { post_number: 2, platforms: ['instagram'], placement: 'feed', media_type: 'image' },
+    ];
+    // Use storyCount=1 so a story is promoted from the first entry.
+    const doc = makeDoc('job_story_dims', schedule) as unknown as { inputs: { request: Record<string, unknown> } };
+    (doc as unknown as { inputs: { request: Record<string, unknown> } }).inputs.request = { scope: { story_count: 1 } };
+
+    await synthesizePublishPostsFromContentPackage({
+      jobId: 'job_story_dims',
+      tenantId: 15,
+      doc: doc as unknown as SocialContentJobRuntimeDocument,
+      publishRunId: null,
+      pool,
+    });
+
+    const storyInsert = inserts.find((p) => p[8] === 'story');
+    assert.ok(storyInsert, 'story post inserted');
+    // Story posts always have null dims in this pass (composed story images).
+    assert.equal(storyInsert![11], null, 'story widthPx null');
+    assert.equal(storyInsert![12], null, 'story heightPx null');
+    assert.equal(storyInsert![13], null, 'story durationSeconds null');
+  });
+});
+
+test('dims: creative_asset with integer dims is faithfully passed through', async () => {
+  await withDataRoot(async () => {
+    process.env.ARIES_VIDEO_PUBLISH_ENABLED = '1';
+    const { pool, inserts } = makeDimsPool([
+      // Exact dims from Hermes Veo contract
+      { id: 'uuid-v', source_asset_id: 'vid_1', width_px: 720, height_px: 1280, duration_seconds: 7.5 },
+    ]);
+    const schedule = [
+      { post_number: 1, platforms: ['instagram'], placement: 'reel', media_type: 'video' },
+    ];
+    try {
+      await synthesizePublishPostsFromContentPackage({
+        jobId: 'job_exact', tenantId: 15, doc: makeDoc('job_exact', schedule), publishRunId: null, pool,
+      });
+    } finally {
+      delete process.env.ARIES_VIDEO_PUBLISH_ENABLED;
+    }
+
+    assert.equal(inserts.length, 1);
+    assert.equal(inserts[0]![11], 720);
+    assert.equal(inserts[0]![12], 1280);
+    assert.equal(inserts[0]![13], 7.5, 'fractional duration preserved');
+  });
+});