vidpipe 1.3.22 → 1.3.24

package/dist/cli.js

@@ -272,9 +272,6 @@ async function renameFile(oldPath, newPath) {
     }
   }
 }
-async function copyDirectory(src, dest) {
-  await fsp.cp(src, dest, { recursive: true });
-}
 async function writeFileRaw(filePath, data, opts) {
   await fsp.writeFile(filePath, data, opts);
 }
@@ -580,7 +577,22 @@ function resolveConfig(cliOptions = {}) {
       process.env.GITHUB_TOKEN,
       globalConfig.credentials.githubToken
     ),
-    MODEL_OVERRIDES: resolveModelOverrides()
+    MODEL_OVERRIDES: resolveModelOverrides(),
+    AZURE_STORAGE_ACCOUNT_NAME: resolveString(
+      cliOptions.azureStorageAccountName,
+      process.env.AZURE_STORAGE_ACCOUNT_NAME,
+      globalConfig.credentials.azureStorageAccountName
+    ),
+    AZURE_STORAGE_ACCOUNT_KEY: resolveString(
+      cliOptions.azureStorageAccountKey,
+      process.env.AZURE_STORAGE_ACCOUNT_KEY,
+      globalConfig.credentials.azureStorageAccountKey
+    ),
+    AZURE_CONTAINER_NAME: resolveString(
+      cliOptions.azureContainerName,
+      process.env.AZURE_CONTAINER_NAME,
+      "vidpipe"
+    )
   };
 }
 function resolveModelOverrides() {
@@ -1139,7 +1151,8 @@ var init_types2 = __esm({
       { stage: "short-posts" /* ShortPosts */, name: "Short Posts", stageNumber: 14 },
       { stage: "medium-clip-posts" /* MediumClipPosts */, name: "Medium Clip Posts", stageNumber: 15 },
       { stage: "queue-build" /* QueueBuild */, name: "Queue Build", stageNumber: 16 },
-      { stage: "blog" /* Blog */, name: "Blog", stageNumber: 17 }
+      { stage: "blog" /* Blog */, name: "Blog", stageNumber: 17 },
+      { stage: "cloud-upload" /* CloudUpload */, name: "Cloud Upload", stageNumber: 18 }
     ];
     TOTAL_STAGES = PIPELINE_STAGES.length;
     PLATFORM_CHAR_LIMITS = {
@@ -2218,7 +2231,8 @@ async function convertWithSmartLayout(inputPath, outputPath, config2, webcamOver
   const webcam = webcamOverride !== void 0 ? webcamOverride : await detectWebcamRegion(inputPath);
   if (!webcam) {
     logger_default.info(`[${label}] No webcam found, falling back to center-crop`);
-    return convertAspectRatio(inputPath, outputPath, fallbackRatio);
+    const path = await convertAspectRatio(inputPath, outputPath, fallbackRatio);
+    return { path, isSplitScreen: false };
   }
   const resolution = await getVideoResolution(inputPath);
   const margin = Math.round(resolution.width * 0.02);
@@ -2283,7 +2297,7 @@ async function convertWithSmartLayout(inputPath, outputPath, config2, webcamOver
         return;
       }
       logger_default.info(`[${label}] Complete: ${outputPath}`);
-      resolve4(outputPath);
+      resolve4({ path: outputPath, isSplitScreen: true });
     });
   });
 }
@@ -2329,21 +2343,25 @@ async function generatePlatformVariants(inputPath, outputDir, slug, platforms =
     const suffix = ratio === "9:16" ? "portrait" : ratio === "4:5" ? "feed" : "square";
     const outPath = join(outputDir, `${slug}-${suffix}.mp4`);
     try {
+      let isSplitScreen = false;
       if (ratio === "9:16") {
         if (options.useAgent) {
           logger_default.warn(`[generatePlatformVariants] LayoutAgent is disabled, falling back to ONNX pipeline`);
         }
-        await convertToPortraitSmart(inputPath, outPath, options.webcamOverride);
+        const result = await convertToPortraitSmart(inputPath, outPath, options.webcamOverride);
+        isSplitScreen = result.isSplitScreen;
       } else if (ratio === "1:1") {
-        await convertToSquareSmart(inputPath, outPath, options.webcamOverride);
+        const result = await convertToSquareSmart(inputPath, outPath, options.webcamOverride);
+        isSplitScreen = result.isSplitScreen;
       } else if (ratio === "4:5") {
-        await convertToFeedSmart(inputPath, outPath, options.webcamOverride);
+        const result = await convertToFeedSmart(inputPath, outPath, options.webcamOverride);
+        isSplitScreen = result.isSplitScreen;
       } else {
         await convertAspectRatio(inputPath, outPath, ratio);
       }
       const dims = DIMENSIONS[ratio];
       for (const p of associatedPlatforms) {
-        variants.push({ platform: p, aspectRatio: ratio, path: outPath, width: dims.width, height: dims.height });
+        variants.push({ platform: p, aspectRatio: ratio, path: outPath, width: dims.width, height: dims.height, isSplitScreen });
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -3919,7 +3937,7 @@ var require_semaphore = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Semaphore = void 0;
     var ral_1 = require_ral();
-    var Semaphore = class {
+    var Semaphore2 = class {
       constructor(capacity = 1) {
         if (capacity <= 0) {
           throw new Error("Capacity must be greater than 0");
@@ -3976,7 +3994,7 @@ var require_semaphore = __commonJS({
         }
       }
     };
-    exports.Semaphore = Semaphore;
+    exports.Semaphore = Semaphore2;
   }
 });
 
@@ -9247,9 +9265,9 @@ var init_BaseAgent = __esm({
       getUserInputHandler() {
         return void 0;
       }
-      /** Timeout for sendAndWait calls. Override in interactive agents that need longer timeouts. */
+      /** Timeout for sendAndWait calls. 0 = no timeout. Override in subclasses if needed. */
       getTimeoutMs() {
-        return 3e5;
+        return 0;
       }
       /**
        * Reset agent-specific state before a retry attempt.
@@ -9669,6 +9687,236 @@ Call the generate_thumbnail tool with a detailed, vivid prompt that will create
   }
 });
 
+// src/L3-services/postStore/postStore.ts
+function getQueueDir() {
+  const { OUTPUT_DIR } = getConfig();
+  return join(OUTPUT_DIR, "publish-queue");
+}
+function getPublishedDir() {
+  const { OUTPUT_DIR } = getConfig();
+  return join(OUTPUT_DIR, "published");
+}
+async function readQueueItem(folderPath, id) {
+  const metadataPath = join(folderPath, "metadata.json");
+  const postPath = join(folderPath, "post.md");
+  try {
+    const metadataRaw = await readTextFile(metadataPath);
+    const metadata = JSON.parse(metadataRaw);
+    let postContent = "";
+    try {
+      postContent = await readTextFile(postPath);
+    } catch {
+      logger_default.debug(`No post.md found for ${String(id).replace(/[\r\n]/g, "")}`);
+    }
+    const videoPath = join(folderPath, "media.mp4");
+    const imagePath = join(folderPath, "media.png");
+    let mediaPath = null;
+    let hasMedia = false;
+    if (await fileExists(videoPath)) {
+      mediaPath = videoPath;
+      hasMedia = true;
+    } else if (await fileExists(imagePath)) {
+      mediaPath = imagePath;
+      hasMedia = true;
+    }
+    const thumbnailPath = join(folderPath, "thumbnail.png");
+    const hasThumbnail = await fileExists(thumbnailPath);
+    return {
+      id,
+      metadata,
+      postContent,
+      hasMedia,
+      mediaPath,
+      thumbnailPath: hasThumbnail ? thumbnailPath : metadata.thumbnailPath ?? null,
+      folderPath
+    };
+  } catch (err) {
+    logger_default.debug(`Failed to read queue item ${String(id).replace(/[\r\n]/g, "")}: ${String(err).replace(/[\r\n]/g, "")}`);
+    return null;
+  }
+}
+async function getPendingItems() {
+  const queueDir = getQueueDir();
+  await ensureDirectory(queueDir);
+  let entries;
+  try {
+    const dirents = await listDirectoryWithTypes(queueDir);
+    entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const items = [];
+  for (const name of entries) {
+    const item = await readQueueItem(join(queueDir, name), name);
+    if (item) items.push(item);
+  }
+  items.sort((a, b) => {
+    if (a.hasMedia !== b.hasMedia) return a.hasMedia ? -1 : 1;
+    return a.metadata.createdAt.localeCompare(b.metadata.createdAt);
+  });
+  return items;
+}
+async function getItem(id) {
+  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
+    throw new Error(`Invalid ID format: ${id}`);
+  }
+  const folderPath = join(getQueueDir(), basename(id));
+  return readQueueItem(folderPath, id);
+}
+async function createItem(id, metadata, postContent, mediaSourcePath, thumbnailSourcePath) {
+  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
+    throw new Error(`Invalid ID format: ${id}`);
+  }
+  const folderPath = join(getQueueDir(), basename(id));
+  await ensureDirectory(folderPath);
+  await writeJsonFile(join(folderPath, "metadata.json"), metadata);
+  await writeTextFile(join(folderPath, "post.md"), postContent);
+  let hasMedia = false;
+  const ext = mediaSourcePath ? extname(mediaSourcePath) : ".mp4";
+  const mediaFilename = `media${ext}`;
+  const mediaPath = join(folderPath, mediaFilename);
+  if (mediaSourcePath) {
+    await copyFile(mediaSourcePath, mediaPath);
+    hasMedia = true;
+  }
+  let thumbnailPath = null;
+  if (thumbnailSourcePath) {
+    const thumbDest = join(folderPath, "thumbnail.png");
+    await copyFile(thumbnailSourcePath, thumbDest);
+    thumbnailPath = thumbDest;
+  }
+  logger_default.debug(`Created queue item: ${String(id).replace(/[\r\n]/g, "")}`);
+  return {
+    id,
+    metadata,
+    postContent,
+    hasMedia,
+    mediaPath: hasMedia ? mediaPath : null,
+    thumbnailPath,
+    folderPath
+  };
+}
+async function updateItem(id, updates) {
+  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
+    throw new Error(`Invalid ID format: ${id}`);
+  }
+  const existing = await getItem(id);
+  if (!existing) return null;
+  if (updates.metadata) {
+    const sanitized = {
+      id: String(existing.metadata.id),
+      platform: String(updates.metadata.platform ?? existing.metadata.platform),
+      accountId: String(updates.metadata.accountId ?? existing.metadata.accountId),
+      sourceVideo: String(existing.metadata.sourceVideo),
+      sourceClip: existing.metadata.sourceClip !== null ? String(existing.metadata.sourceClip) : null,
+      clipType: existing.metadata.clipType,
+      sourceMediaPath: existing.metadata.sourceMediaPath !== null ? String(existing.metadata.sourceMediaPath) : null,
+      hashtags: Array.isArray(updates.metadata.hashtags) ? updates.metadata.hashtags.map(String) : Array.isArray(existing.metadata.hashtags) ? existing.metadata.hashtags.map(String) : [],
+      links: Array.isArray(updates.metadata.links) ? updates.metadata.links : Array.isArray(existing.metadata.links) ? existing.metadata.links : [],
+      characterCount: updates.metadata.characterCount !== void 0 ? Number(updates.metadata.characterCount) || 0 : Number(existing.metadata.characterCount) || 0,
+      platformCharLimit: updates.metadata.platformCharLimit !== void 0 ? Number(updates.metadata.platformCharLimit) || 0 : Number(existing.metadata.platformCharLimit) || 0,
+      suggestedSlot: updates.metadata.suggestedSlot !== void 0 ? updates.metadata.suggestedSlot !== null ? String(updates.metadata.suggestedSlot) : null : existing.metadata.suggestedSlot !== null ? String(existing.metadata.suggestedSlot) : null,
+      scheduledFor: updates.metadata.scheduledFor !== void 0 ? updates.metadata.scheduledFor !== null ? String(updates.metadata.scheduledFor) : null : existing.metadata.scheduledFor !== null ? String(existing.metadata.scheduledFor) : null,
+      status: updates.metadata.status ?? existing.metadata.status,
+      latePostId: updates.metadata.latePostId !== void 0 ? updates.metadata.latePostId !== null ? String(updates.metadata.latePostId) : null : existing.metadata.latePostId !== null ? String(existing.metadata.latePostId) : null,
+      publishedUrl: updates.metadata.publishedUrl !== void 0 ? updates.metadata.publishedUrl !== null ? String(updates.metadata.publishedUrl) : null : existing.metadata.publishedUrl !== null ? String(existing.metadata.publishedUrl) : null,
+      createdAt: String(existing.metadata.createdAt),
+      reviewedAt: updates.metadata.reviewedAt !== void 0 ? updates.metadata.reviewedAt !== null ? String(updates.metadata.reviewedAt) : null : existing.metadata.reviewedAt !== null ? String(existing.metadata.reviewedAt) : null,
+      publishedAt: updates.metadata.publishedAt !== void 0 ? updates.metadata.publishedAt !== null ? String(updates.metadata.publishedAt) : null : existing.metadata.publishedAt !== null ? String(existing.metadata.publishedAt) : null,
+      textOnly: updates.metadata.textOnly ?? existing.metadata.textOnly,
+      mediaType: updates.metadata.mediaType ?? existing.metadata.mediaType,
+      ideaIds: Array.isArray(updates.metadata.ideaIds) ? updates.metadata.ideaIds.map(String) : Array.isArray(existing.metadata.ideaIds) ? existing.metadata.ideaIds.map(String) : void 0,
+      platformSpecificData: updates.metadata.platformSpecificData ?? existing.metadata.platformSpecificData
+    };
+    existing.metadata = sanitized;
+    const metadataWritePath = resolve(join(existing.folderPath, "metadata.json"));
+    if (!metadataWritePath.startsWith(resolve(getQueueDir()) + sep)) {
+      throw new Error("Write target outside queue directory");
+    }
+    await writeTextFile(
+      metadataWritePath,
+      JSON.stringify(existing.metadata, null, 2)
+    );
+  }
+  if (updates.postContent !== void 0) {
+    const sanitizedContent = String(updates.postContent);
+    existing.postContent = sanitizedContent;
+    const postWritePath = resolve(join(existing.folderPath, "post.md"));
+    if (!postWritePath.startsWith(resolve(getQueueDir()) + sep)) {
+      throw new Error("Write target outside queue directory");
+    }
+    await writeTextFile(postWritePath, sanitizedContent);
+  }
+  logger_default.debug(`Updated queue item: ${String(id).replace(/[\r\n]/g, "")}`);
+  return existing;
+}
+async function getPublishedItems() {
+  const publishedDir = getPublishedDir();
+  await ensureDirectory(publishedDir);
+  let entries;
+  try {
+    const dirents = await listDirectoryWithTypes(publishedDir);
+    entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const items = [];
+  for (const name of entries) {
+    const item = await readQueueItem(join(publishedDir, name), name);
+    if (item) items.push(item);
+  }
+  items.sort((a, b) => a.metadata.createdAt.localeCompare(b.metadata.createdAt));
+  return items;
+}
+async function getScheduledItemsByIdeaIds(ideaIds) {
+  if (ideaIds.length === 0) return [];
+  const ideaIdSet = new Set(ideaIds);
+  const [pendingItems, publishedItems] = await Promise.all([
+    getPendingItems(),
+    getPublishedItems()
+  ]);
+  return [...pendingItems, ...publishedItems].filter(
+    (item) => item.metadata.ideaIds?.some((id) => ideaIdSet.has(id)) ?? false
+  );
+}
+async function updatePublishedItemSchedule(id, scheduledFor) {
+  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
+    throw new Error(`Invalid ID format: ${id}`);
+  }
+  const publishedDir = getPublishedDir();
+  const folderPath = join(publishedDir, basename(id));
+  const metadataPath = join(folderPath, "metadata.json");
+  if (!resolve(metadataPath).startsWith(resolve(publishedDir) + sep)) {
+    throw new Error("Write target outside published directory");
+  }
+  const raw = await readTextFile(metadataPath);
+  const metadata = JSON.parse(raw);
+  metadata.scheduledFor = String(scheduledFor);
+  await writeTextFile(metadataPath, JSON.stringify(metadata, null, 2));
+}
+async function itemExists(id) {
+  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
+    throw new Error(`Invalid ID format: ${id}`);
+  }
+  if (await fileExists(join(getQueueDir(), basename(id)))) {
+    return "pending";
+  }
+  if (await fileExists(join(getPublishedDir(), basename(id)))) {
+    return "published";
+  }
+  return null;
+}
+var init_postStore = __esm({
+  "src/L3-services/postStore/postStore.ts"() {
+    "use strict";
+    init_types2();
+    init_environment();
+    init_configLogger();
+    init_fileSystem();
+    init_paths();
+  }
+});
+
 // src/L2-clients/github/githubClient.ts
 import { Octokit } from "octokit";
 function getErrorStatus(error) {
@@ -9678,9 +9926,7 @@ function getErrorStatus(error) {
   return void 0;
 }
 function getErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
+  if (error instanceof Error) return error.message;
   if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
     return error.message ?? "Unknown GitHub API error";
   }
@@ -9689,8 +9935,8 @@ function getErrorMessage(error) {
 function normalizeLabels(labels) {
   return Array.from(new Set(labels.map((label) => label.trim()).filter((label) => label.length > 0)));
 }
-function isIssueResponse(value) {
-  return !("pull_request" in value);
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function getGitHubClient() {
   const config2 = getConfig();
@@ -9701,13 +9947,32 @@ function getGitHubClient() {
   }
   return clientInstance;
 }
-var DEFAULT_PER_PAGE, GitHubClientError, GitHubClient, clientInstance, clientKey;
+var CACHE_TTL_MS, MAX_CONCURRENT, THROTTLE_WARN_REMAINING, THROTTLE_SLOW_REMAINING, THROTTLE_CRITICAL_REMAINING, MAX_RETRIES2, ISSUE_WITH_COMMENTS_FRAGMENT, GitHubClientError, Semaphore, GitHubClient, clientInstance, clientKey;
 var init_githubClient = __esm({
   "src/L2-clients/github/githubClient.ts"() {
     "use strict";
     init_environment();
     init_configLogger();
-    DEFAULT_PER_PAGE = 100;
+    CACHE_TTL_MS = 5 * 60 * 1e3;
+    MAX_CONCURRENT = 4;
+    THROTTLE_WARN_REMAINING = 200;
+    THROTTLE_SLOW_REMAINING = 100;
+    THROTTLE_CRITICAL_REMAINING = 50;
+    MAX_RETRIES2 = 3;
+    ISSUE_WITH_COMMENTS_FRAGMENT = `
+  number
+  title
+  body
+  state
+  labels(first: 50) { nodes { name } }
+  comments(first: 100) {
+    nodes { databaseId body createdAt updatedAt url }
+    pageInfo { hasNextPage endCursor }
+  }
+  createdAt
+  updatedAt
+  url
+`;
     GitHubClientError = class extends Error {
       constructor(message, status) {
         super(message);
@@ -9715,10 +9980,40 @@ var init_githubClient = __esm({
         this.name = "GitHubClientError";
       }
     };
+    Semaphore = class {
+      constructor(limit) {
+        this.limit = limit;
+      }
+      queue = [];
+      running = 0;
+      async acquire() {
+        if (this.running < this.limit) {
+          this.running++;
+          return;
+        }
+        return new Promise((resolve4) => {
+          this.queue.push(() => {
+            this.running++;
+            resolve4();
+          });
+        });
+      }
+      release() {
+        this.running--;
+        const next = this.queue.shift();
+        if (next) next();
+      }
+    };
     GitHubClient = class {
       octokit;
       owner;
       repo;
+      // Rate limiting
+      rateLimitRemaining = 5e3;
+      rateLimitReset = 0;
+      semaphore = new Semaphore(MAX_CONCURRENT);
+      // Response cache — keyed by "type:identifier"
+      cache = /* @__PURE__ */ new Map();
       constructor(token, repoFullName) {
         const config2 = getConfig();
         const authToken = token || config2.GITHUB_TOKEN;
@@ -9734,87 +10029,184 @@ var init_githubClient = __esm({
         this.repo = repo;
         this.octokit = new Octokit({ auth: authToken });
       }
-      async createIssue(input) {
-        logger_default.debug(`[GitHubClient] Creating issue in ${this.owner}/${this.repo}: ${input.title}`);
-        try {
-          const response = await this.octokit.rest.issues.create({
-            owner: this.owner,
-            repo: this.repo,
-            title: input.title,
-            body: input.body,
-            labels: input.labels ? normalizeLabels(input.labels) : void 0
-          });
-          const issue = this.mapIssue(response.data);
-          logger_default.info(`[GitHubClient] Created issue #${issue.number}: ${input.title}`);
-          return issue;
-        } catch (error) {
-          this.logError("create issue", error);
-          throw new GitHubClientError(`Failed to create GitHub issue: ${getErrorMessage(error)}`, getErrorStatus(error));
+      // ── Cache helpers ────────────────────────────────────────────────────
+      getCached(key) {
+        const entry = this.cache.get(key);
+        if (!entry) return void 0;
+        if (Date.now() - entry.cachedAt > CACHE_TTL_MS) {
+          this.cache.delete(key);
+          return void 0;
         }
+        return entry.data;
       }
-      async updateIssue(issueNumber, input) {
-        logger_default.debug(`[GitHubClient] Updating issue #${issueNumber} in ${this.owner}/${this.repo}`);
+      setCache(key, data) {
+        this.cache.set(key, { data, cachedAt: Date.now() });
+      }
+      invalidateIssue(issueNumber) {
+        this.cache.delete(`issue:${issueNumber}`);
+        this.cache.delete(`comments:${issueNumber}`);
+        for (const key of this.cache.keys()) {
+          if (key.startsWith("issues:") || key.startsWith("search:")) {
+            this.cache.delete(key);
+          }
+        }
+      }
+      /** Clear all cached data. Useful after bulk writes. */
+      clearCache() {
+        this.cache.clear();
+      }
+      // ── Throttle / rate limit ────────────────────────────────────────────
+      async throttle() {
+        if (this.rateLimitRemaining < THROTTLE_CRITICAL_REMAINING) {
+          const waitMs = Math.max(0, this.rateLimitReset * 1e3 - Date.now()) + 1e3;
+          logger_default.warn(`[GitHubClient] Rate limit critical (${this.rateLimitRemaining} remaining) \u2014 waiting ${Math.round(waitMs / 1e3)}s`);
+          await sleep(Math.min(waitMs, 6e4));
+        } else if (this.rateLimitRemaining < THROTTLE_SLOW_REMAINING) {
+          await sleep(500);
+        } else if (this.rateLimitRemaining < THROTTLE_WARN_REMAINING) {
+          await sleep(100);
+        }
+      }
+      updateRateLimit(headers) {
+        const remaining = headers["x-ratelimit-remaining"];
+        const reset = headers["x-ratelimit-reset"];
+        if (remaining !== void 0) this.rateLimitRemaining = parseInt(remaining, 10) || 0;
+        if (reset !== void 0) this.rateLimitReset = parseInt(reset, 10) || 0;
+      }
+      // ── GraphQL transport ────────────────────────────────────────────────
+      async graphql(query, variables = {}) {
+        await this.semaphore.acquire();
         try {
-          const response = await this.octokit.rest.issues.update({
-            owner: this.owner,
-            repo: this.repo,
-            issue_number: issueNumber,
-            title: input.title,
-            body: input.body,
-            state: input.state,
-            labels: input.labels ? normalizeLabels(input.labels) : void 0
-          });
-          return this.mapIssue(response.data);
-        } catch (error) {
-          this.logError(`update issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to update GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
+          await this.throttle();
+          let lastError;
+          for (let attempt = 0; attempt < MAX_RETRIES2; attempt++) {
+            try {
+              const response = await this.octokit.request("POST /graphql", { query, variables });
+              this.updateRateLimit(response.headers);
+              const body = response.data;
+              if (body.errors?.length) {
+                const rateLimited = body.errors.some((e) => e.type === "RATE_LIMITED");
+                if (rateLimited && attempt < MAX_RETRIES2 - 1) {
+                  const waitMs = Math.max(0, this.rateLimitReset * 1e3 - Date.now()) + 1e3;
+                  logger_default.warn(`[GitHubClient] GraphQL rate limited \u2014 retrying in ${Math.round(waitMs / 1e3)}s`);
+                  await sleep(Math.min(waitMs, 6e4));
+                  continue;
+                }
+                throw new GitHubClientError(`GraphQL error: ${body.errors.map((e) => e.message).join("; ")}`);
+              }
+              if (!body.data) throw new GitHubClientError("GraphQL returned no data");
+              return body.data;
+            } catch (error) {
+              lastError = error;
+              if (error instanceof GitHubClientError) throw error;
+              const status = getErrorStatus(error);
+              if (status === 403 && attempt < MAX_RETRIES2 - 1) {
+                const backoff = Math.pow(2, attempt) * 1e3;
+                logger_default.warn(`[GitHubClient] 403 \u2014 retrying in ${backoff}ms (attempt ${attempt + 1}/${MAX_RETRIES2})`);
+                await sleep(backoff);
+                continue;
+              }
+              throw error;
+            }
+          }
+          throw lastError;
+        } finally {
+          this.semaphore.release();
         }
       }
+      // ── GraphQL mappers ──────────────────────────────────────────────────
+      mapGqlIssue(node) {
+        return {
+          number: node.number,
+          title: node.title,
+          body: node.body ?? "",
+          state: node.state === "OPEN" ? "open" : "closed",
+          labels: node.labels.nodes.map((l) => l.name).filter(Boolean),
+          created_at: node.createdAt,
+          updated_at: node.updatedAt,
+          html_url: node.url
+        };
+      }
+      mapGqlComment(node) {
+        return {
+          id: node.databaseId,
+          body: node.body ?? "",
+          created_at: node.createdAt,
+          updated_at: node.updatedAt,
+          html_url: node.url
+        };
+      }
+      mapGqlComments(node) {
+        return node.comments.nodes.map((c) => this.mapGqlComment(c));
+      }
+      // ── Read operations (GraphQL) ────────────────────────────────────────
       async getIssue(issueNumber) {
+        const cached = this.getCached(`issue:${issueNumber}`);
+        if (cached) return cached;
         logger_default.debug(`[GitHubClient] Fetching issue #${issueNumber} from ${this.owner}/${this.repo}`);
         try {
-          const response = await this.octokit.rest.issues.get({
-            owner: this.owner,
-            repo: this.repo,
-            issue_number: issueNumber
-          });
-          return this.mapIssue(response.data);
+          const data = await this.graphql(
+            `query($owner: String!, $repo: String!, $number: Int!) {
+          repository(owner: $owner, name: $repo) {
+            issue(number: $number) { ${ISSUE_WITH_COMMENTS_FRAGMENT} }
+          }
+        }`,
+            { owner: this.owner, repo: this.repo, number: issueNumber }
+          );
+          if (!data.repository.issue) {
+            throw new GitHubClientError(`Issue #${issueNumber} not found`, 404);
+          }
+          const issue = this.mapGqlIssue(data.repository.issue);
+          const comments = this.mapGqlComments(data.repository.issue);
+          this.setCache(`issue:${issueNumber}`, issue);
+          this.setCache(`comments:${issueNumber}`, comments);
+          return issue;
         } catch (error) {
           this.logError(`get issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to fetch GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
+          throw error instanceof GitHubClientError ? error : new GitHubClientError(`Failed to fetch GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
       }
       async listIssues(options = {}) {
+        const labels = options.labels && options.labels.length > 0 ? normalizeLabels(options.labels) : [];
+        const stateFilter = options.state ?? "all";
+        const cacheKey = `issues:${labels.sort().join(",")}:${stateFilter}`;
+        const cached = this.getCached(cacheKey);
+        if (cached) return options.maxResults ? cached.slice(0, options.maxResults) : cached;
         logger_default.debug(`[GitHubClient] Listing issues for ${this.owner}/${this.repo}`);
-        const issues = [];
-        let page;
         const maxResults = options.maxResults ?? Number.POSITIVE_INFINITY;
+        const gqlStates = stateFilter === "all" ? "[OPEN, CLOSED]" : stateFilter === "open" ? "[OPEN]" : "[CLOSED]";
+        const labelsArg = labels.length > 0 ? `, labels: ${JSON.stringify(labels)}` : "";
         try {
-          while (issues.length < maxResults) {
-            const response = await this.octokit.rest.issues.listForRepo({
-              owner: this.owner,
-              repo: this.repo,
-              state: options.state ?? "all",
-              labels: options.labels && options.labels.length > 0 ? normalizeLabels(options.labels).join(",") : void 0,
-              sort: void 0,
-              direction: void 0,
-              per_page: DEFAULT_PER_PAGE,
-              page
-            });
-            const pageItems = response.data.filter(isIssueResponse).map((issue) => this.mapIssue(issue));
-            issues.push(...pageItems);
-            if (pageItems.length < DEFAULT_PER_PAGE) {
-              break;
+          const allIssues = [];
+          let cursor = null;
+          let hasNext = true;
+          while (hasNext && allIssues.length < maxResults) {
+            const afterArg = cursor ? `, after: "${cursor}"` : "";
+            const data = await this.graphql(
+              `query($owner: String!, $repo: String!) {
+            repository(owner: $owner, name: $repo) {
+              issues(first: 100, states: ${gqlStates}${labelsArg}${afterArg}, orderBy: {field: UPDATED_AT, direction: DESC}) {
+                nodes { ${ISSUE_WITH_COMMENTS_FRAGMENT} }
+                pageInfo { hasNextPage endCursor }
+              }
+            }
+          }`,
+              { owner: this.owner, repo: this.repo }
+            );
+            const pageData = data.repository.issues;
+            for (const node of pageData.nodes) {
+              const issue = this.mapGqlIssue(node);
+              const comments = this.mapGqlComments(node);
+              allIssues.push(issue);
+              this.setCache(`issue:${issue.number}`, issue);
+              this.setCache(`comments:${issue.number}`, comments);
             }
-            page = (page ?? 1) + 1;
+            hasNext = pageData.pageInfo.hasNextPage;
+            cursor = pageData.pageInfo.endCursor;
           }
-          return issues.slice(0, maxResults);
+          const result = allIssues.slice(0, maxResults);
+          this.setCache(cacheKey, result);
+          return result;
         } catch (error) {
           this.logError("list issues", error);
           throw new GitHubClientError(`Failed to list GitHub issues: ${getErrorMessage(error)}`, getErrorStatus(error));
@@ -9822,22 +10214,89 @@ var init_githubClient = __esm({
       }
       async searchIssues(query, options = {}) {
         const searchQuery = `repo:${this.owner}/${this.repo} is:issue ${query}`.trim();
+        const cacheKey = `search:${searchQuery}`;
+        const cached = this.getCached(cacheKey);
+        if (cached) return options.maxResults ? cached.slice(0, options.maxResults) : cached;
         logger_default.debug(`[GitHubClient] Searching issues in ${this.owner}/${this.repo}: ${query}`);
         try {
-          const items = await this.octokit.paginate(this.octokit.rest.search.issuesAndPullRequests, {
-            q: searchQuery,
-            per_page: DEFAULT_PER_PAGE
+          const data = await this.graphql(
+            `query($q: String!) {
+          search(query: $q, type: ISSUE, first: 100) {
+            nodes {
+              ... on Issue { __typename ${ISSUE_WITH_COMMENTS_FRAGMENT} }
+            }
+          }
+        }`,
+            { q: searchQuery }
+          );
+          const issues = data.search.nodes.filter((n) => n.__typename === "Issue").map((node) => {
+            const issue = this.mapGqlIssue(node);
+            const comments = this.mapGqlComments(node);
+            this.setCache(`issue:${issue.number}`, issue);
+            this.setCache(`comments:${issue.number}`, comments);
+            return issue;
           });
-          return items.filter(isIssueResponse).map((issue) => this.mapIssue(issue)).slice(0, options.maxResults ?? Number.POSITIVE_INFINITY);
+          const result = issues.slice(0, options.maxResults ?? Number.POSITIVE_INFINITY);
+          this.setCache(cacheKey, result);
+          return result;
         } catch (error) {
           this.logError("search issues", error);
           throw new GitHubClientError(`Failed to search GitHub issues: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
       }
-      async addLabels(issueNumber, labels) {
-        if (labels.length === 0) {
-          return;
+      async listComments(issueNumber) {
+        const cached = this.getCached(`comments:${issueNumber}`);
+        if (cached) return cached;
+        logger_default.debug(`[GitHubClient] Listing comments for issue #${issueNumber} in ${this.owner}/${this.repo}`);
+        try {
+          await this.getIssue(issueNumber);
+          return this.getCached(`comments:${issueNumber}`) ?? [];
+        } catch (error) {
+          this.logError(`list comments for issue #${issueNumber}`, error);
+          throw error instanceof GitHubClientError ? error : new GitHubClientError(`Failed to list comments for GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
+        }
+      }
+      // ── Write operations (REST — infrequent, keep on separate quota) ─────
+      async createIssue(input) {
+        logger_default.debug(`[GitHubClient] Creating issue in ${this.owner}/${this.repo}: ${input.title}`);
+        try {
+          const response = await this.octokit.rest.issues.create({
+            owner: this.owner,
+            repo: this.repo,
+            title: input.title,
+            body: input.body,
+            labels: input.labels ? normalizeLabels(input.labels) : void 0
+          });
+          const issue = this.mapRestIssue(response.data);
+          logger_default.info(`[GitHubClient] Created issue #${issue.number}: ${input.title}`);
+          return issue;
+        } catch (error) {
+          this.logError("create issue", error);
+          throw new GitHubClientError(`Failed to create GitHub issue: ${getErrorMessage(error)}`, getErrorStatus(error));
+        }
+      }
+      async updateIssue(issueNumber, input) {
+        logger_default.debug(`[GitHubClient] Updating issue #${issueNumber} in ${this.owner}/${this.repo}`);
+        try {
+          const response = await this.octokit.rest.issues.update({
+            owner: this.owner,
+            repo: this.repo,
+            issue_number: issueNumber,
+            title: input.title,
+            body: input.body,
+            state: input.state,
+            labels: input.labels ? normalizeLabels(input.labels) : void 0
+          });
+          const issue = this.mapRestIssue(response.data);
+          this.invalidateIssue(issueNumber);
+          return issue;
+        } catch (error) {
+          this.logError(`update issue #${issueNumber}`, error);
+          throw new GitHubClientError(`Failed to update GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
+      }
+      async addLabels(issueNumber, labels) {
+        if (labels.length === 0) return;
         logger_default.debug(`[GitHubClient] Adding labels to issue #${issueNumber} in ${this.owner}/${this.repo}`);
         try {
           await this.octokit.rest.issues.addLabels({
@@ -9846,12 +10305,10 @@ var init_githubClient = __esm({
             issue_number: issueNumber,
             labels
           });
+          this.invalidateIssue(issueNumber);
         } catch (error) {
           this.logError(`add labels to issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to add labels to GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
+          throw new GitHubClientError(`Failed to add labels to GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
       }
       async removeLabel(issueNumber, label) {
@@ -9863,15 +10320,11 @@ var init_githubClient = __esm({
             issue_number: issueNumber,
             name: label
           });
+          this.invalidateIssue(issueNumber);
         } catch (error) {
-          if (getErrorStatus(error) === 404) {
-            return;
-          }
+          if (getErrorStatus(error) === 404) return;
           this.logError(`remove label from issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to remove label from GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
+          throw new GitHubClientError(`Failed to remove label from GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
       }
       async setLabels(issueNumber, labels) {
@@ -9883,12 +10336,10 @@ var init_githubClient = __esm({
             issue_number: issueNumber,
             labels
           });
+          this.invalidateIssue(issueNumber);
         } catch (error) {
           this.logError(`set labels on issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to set labels on GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
+          throw new GitHubClientError(`Failed to set labels on GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
       }
       async addComment(issueNumber, body) {
@@ -9900,52 +10351,34 @@ var init_githubClient = __esm({
             issue_number: issueNumber,
             body
           });
-          return this.mapComment(response.data);
+          this.invalidateIssue(issueNumber);
+          return this.mapRestComment(response.data);
         } catch (error) {
           this.logError(`add comment to issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to add comment to GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
-        }
-      }
-      async listComments(issueNumber) {
-        logger_default.debug(`[GitHubClient] Listing comments for issue #${issueNumber} in ${this.owner}/${this.repo}`);
-        try {
-          const comments = await this.octokit.paginate(this.octokit.rest.issues.listComments, {
-            owner: this.owner,
-            repo: this.repo,
-            issue_number: issueNumber,
-            per_page: DEFAULT_PER_PAGE
-          });
-          return comments.map((comment) => this.mapComment(comment));
-        } catch (error) {
-          this.logError(`list comments for issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to list comments for GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
+          throw new GitHubClientError(`Failed to add comment to GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
       }
-      mapIssue(issue) {
+      // ── REST mappers (for write operations) ──────────────────────────────
+      mapRestIssue(data) {
+        const labels = Array.isArray(data.labels) ? data.labels : [];
         return {
-          number: issue.number,
-          title: issue.title,
-          body: issue.body ?? "",
-          state: issue.state,
-          labels: issue.labels.map((label) => typeof label === "string" ? label : label.name ?? "").map((label) => label.trim()).filter((label) => label.length > 0),
-          created_at: issue.created_at,
-          updated_at: issue.updated_at,
-          html_url: issue.html_url
+          number: data.number,
+          title: data.title,
+          body: data.body ?? "",
+          state: data.state,
+          labels: labels.map((l) => typeof l === "string" ? l : l?.name ?? "").map((l) => l.trim()).filter((l) => l.length > 0),
+          created_at: data.created_at,
+          updated_at: data.updated_at,
+          html_url: data.html_url
         };
       }
-      mapComment(comment) {
+      mapRestComment(data) {
         return {
-          id: comment.id,
-          body: comment.body ?? "",
-          created_at: comment.created_at,
-          updated_at: comment.updated_at,
-          html_url: comment.html_url
+          id: data.id,
+          body: data.body ?? "",
+          created_at: data.created_at,
+          updated_at: data.updated_at,
+          html_url: data.html_url
         };
       }
       logError(action, error) {
@@ -10466,430 +10899,11 @@ var init_ideaService = __esm({
   }
 });
 
-// src/L3-services/postStore/postStore.ts
-function getQueueDir() {
-  const { OUTPUT_DIR } = getConfig();
-  return join(OUTPUT_DIR, "publish-queue");
-}
-function getPublishedDir() {
-  const { OUTPUT_DIR } = getConfig();
-  return join(OUTPUT_DIR, "published");
-}
-async function readQueueItem(folderPath, id) {
-  const metadataPath = join(folderPath, "metadata.json");
-  const postPath = join(folderPath, "post.md");
-  try {
-    const metadataRaw = await readTextFile(metadataPath);
-    const metadata = JSON.parse(metadataRaw);
-    let postContent = "";
-    try {
-      postContent = await readTextFile(postPath);
-    } catch {
-      logger_default.debug(`No post.md found for ${String(id).replace(/[\r\n]/g, "")}`);
-    }
-    const videoPath = join(folderPath, "media.mp4");
-    const imagePath = join(folderPath, "media.png");
-    let mediaPath = null;
-    let hasMedia = false;
-    if (await fileExists(videoPath)) {
-      mediaPath = videoPath;
-      hasMedia = true;
-    } else if (await fileExists(imagePath)) {
-      mediaPath = imagePath;
-      hasMedia = true;
-    }
-    const thumbnailPath = join(folderPath, "thumbnail.png");
-    const hasThumbnail = await fileExists(thumbnailPath);
-    return {
-      id,
-      metadata,
-      postContent,
-      hasMedia,
-      mediaPath,
-      thumbnailPath: hasThumbnail ? thumbnailPath : metadata.thumbnailPath ?? null,
-      folderPath
-    };
-  } catch (err) {
-    logger_default.debug(`Failed to read queue item ${String(id).replace(/[\r\n]/g, "")}: ${String(err).replace(/[\r\n]/g, "")}`);
-    return null;
-  }
-}
-async function getPendingItems() {
-  const queueDir = getQueueDir();
-  await ensureDirectory(queueDir);
-  let entries;
-  try {
-    const dirents = await listDirectoryWithTypes(queueDir);
-    entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
-  } catch {
-    return [];
-  }
-  const items = [];
-  for (const name of entries) {
-    const item = await readQueueItem(join(queueDir, name), name);
-    if (item) items.push(item);
-  }
-  items.sort((a, b) => {
-    if (a.hasMedia !== b.hasMedia) return a.hasMedia ? -1 : 1;
-    return a.metadata.createdAt.localeCompare(b.metadata.createdAt);
-  });
-  return items;
-}
-async function getGroupedPendingItems() {
-  const items = await getPendingItems();
-  const groups = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const platform = item.metadata.platform.toLowerCase();
-    const clipSlug = item.id.endsWith(`-${platform}`) ? item.id.slice(0, -(platform.length + 1)) : item.id;
-    const groupKey = `${item.metadata.sourceVideo}::${clipSlug}`;
-    if (!groups.has(groupKey)) {
-      groups.set(groupKey, []);
-    }
-    groups.get(groupKey).push(item);
-  }
-  const result = [];
-  for (const [groupKey, groupItems] of groups) {
-    if (groupItems.length === 0) continue;
-    const first = groupItems[0];
-    result.push({
-      groupKey,
-      sourceVideo: first.metadata.sourceVideo,
-      sourceClip: first.metadata.sourceClip,
-      clipType: first.metadata.clipType,
-      hasMedia: first.hasMedia,
-      mediaType: first.metadata.mediaType,
-      items: groupItems
-    });
-  }
-  result.sort((a, b) => {
-    if (a.hasMedia !== b.hasMedia) return a.hasMedia ? -1 : 1;
-    const aDate = Math.min(...a.items.map((i) => new Date(i.metadata.createdAt).getTime()));
-    const bDate = Math.min(...b.items.map((i) => new Date(i.metadata.createdAt).getTime()));
-    return aDate - bDate;
-  });
-  return result;
-}
-async function getItem(id) {
-  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
-    throw new Error(`Invalid ID format: ${id}`);
-  }
-  const folderPath = join(getQueueDir(), basename(id));
-  return readQueueItem(folderPath, id);
-}
-async function createItem(id, metadata, postContent, mediaSourcePath, thumbnailSourcePath) {
-  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
-    throw new Error(`Invalid ID format: ${id}`);
-  }
-  const folderPath = join(getQueueDir(), basename(id));
-  await ensureDirectory(folderPath);
-  await writeJsonFile(join(folderPath, "metadata.json"), metadata);
-  await writeTextFile(join(folderPath, "post.md"), postContent);
-  let hasMedia = false;
-  const ext = mediaSourcePath ? extname(mediaSourcePath) : ".mp4";
-  const mediaFilename = `media${ext}`;
-  const mediaPath = join(folderPath, mediaFilename);
-  if (mediaSourcePath) {
-    await copyFile(mediaSourcePath, mediaPath);
-    hasMedia = true;
-  }
-  let thumbnailPath = null;
-  if (thumbnailSourcePath) {
-    const thumbDest = join(folderPath, "thumbnail.png");
-    await copyFile(thumbnailSourcePath, thumbDest);
-    thumbnailPath = thumbDest;
-  }
-  logger_default.debug(`Created queue item: ${String(id).replace(/[\r\n]/g, "")}`);
-  return {
-    id,
-    metadata,
-    postContent,
-    hasMedia,
-    mediaPath: hasMedia ? mediaPath : null,
-    thumbnailPath,
-    folderPath
-  };
-}
-async function updateItem(id, updates) {
-  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
-    throw new Error(`Invalid ID format: ${id}`);
-  }
-  const existing = await getItem(id);
-  if (!existing) return null;
-  if (updates.metadata) {
-    const sanitized = {
-      id: String(existing.metadata.id),
-      platform: String(updates.metadata.platform ?? existing.metadata.platform),
-      accountId: String(updates.metadata.accountId ?? existing.metadata.accountId),
-      sourceVideo: String(existing.metadata.sourceVideo),
-      sourceClip: existing.metadata.sourceClip !== null ? String(existing.metadata.sourceClip) : null,
-      clipType: existing.metadata.clipType,
-      sourceMediaPath: existing.metadata.sourceMediaPath !== null ? String(existing.metadata.sourceMediaPath) : null,
-      hashtags: Array.isArray(updates.metadata.hashtags) ? updates.metadata.hashtags.map(String) : Array.isArray(existing.metadata.hashtags) ? existing.metadata.hashtags.map(String) : [],
-      links: Array.isArray(updates.metadata.links) ? updates.metadata.links : Array.isArray(existing.metadata.links) ? existing.metadata.links : [],
-      characterCount: updates.metadata.characterCount !== void 0 ? Number(updates.metadata.characterCount) || 0 : Number(existing.metadata.characterCount) || 0,
-      platformCharLimit: updates.metadata.platformCharLimit !== void 0 ? Number(updates.metadata.platformCharLimit) || 0 : Number(existing.metadata.platformCharLimit) || 0,
-      suggestedSlot: updates.metadata.suggestedSlot !== void 0 ? updates.metadata.suggestedSlot !== null ? String(updates.metadata.suggestedSlot) : null : existing.metadata.suggestedSlot !== null ? String(existing.metadata.suggestedSlot) : null,
-      scheduledFor: updates.metadata.scheduledFor !== void 0 ? updates.metadata.scheduledFor !== null ? String(updates.metadata.scheduledFor) : null : existing.metadata.scheduledFor !== null ? String(existing.metadata.scheduledFor) : null,
-      status: updates.metadata.status ?? existing.metadata.status,
-      latePostId: updates.metadata.latePostId !== void 0 ? updates.metadata.latePostId !== null ? String(updates.metadata.latePostId) : null : existing.metadata.latePostId !== null ? String(existing.metadata.latePostId) : null,
-      publishedUrl: updates.metadata.publishedUrl !== void 0 ? updates.metadata.publishedUrl !== null ? String(updates.metadata.publishedUrl) : null : existing.metadata.publishedUrl !== null ? String(existing.metadata.publishedUrl) : null,
-      createdAt: String(existing.metadata.createdAt),
-      reviewedAt: updates.metadata.reviewedAt !== void 0 ? updates.metadata.reviewedAt !== null ? String(updates.metadata.reviewedAt) : null : existing.metadata.reviewedAt !== null ? String(existing.metadata.reviewedAt) : null,
-      publishedAt: updates.metadata.publishedAt !== void 0 ? updates.metadata.publishedAt !== null ? String(updates.metadata.publishedAt) : null : existing.metadata.publishedAt !== null ? String(existing.metadata.publishedAt) : null,
-      textOnly: updates.metadata.textOnly ?? existing.metadata.textOnly,
-      mediaType: updates.metadata.mediaType ?? existing.metadata.mediaType,
-      ideaIds: Array.isArray(updates.metadata.ideaIds) ? updates.metadata.ideaIds.map(String) : Array.isArray(existing.metadata.ideaIds) ? existing.metadata.ideaIds.map(String) : void 0,
-      platformSpecificData: updates.metadata.platformSpecificData ?? existing.metadata.platformSpecificData
-    };
-    existing.metadata = sanitized;
-    const metadataWritePath = resolve(join(existing.folderPath, "metadata.json"));
-    if (!metadataWritePath.startsWith(resolve(getQueueDir()) + sep)) {
-      throw new Error("Write target outside queue directory");
-    }
-    await writeTextFile(
-      metadataWritePath,
-      JSON.stringify(existing.metadata, null, 2)
-    );
-  }
-  if (updates.postContent !== void 0) {
-    const sanitizedContent = String(updates.postContent);
-    existing.postContent = sanitizedContent;
-    const postWritePath = resolve(join(existing.folderPath, "post.md"));
-    if (!postWritePath.startsWith(resolve(getQueueDir()) + sep)) {
-      throw new Error("Write target outside queue directory");
-    }
-    await writeTextFile(postWritePath, sanitizedContent);
-  }
-  logger_default.debug(`Updated queue item: ${String(id).replace(/[\r\n]/g, "")}`);
-  return existing;
-}
-async function approveItem(id, publishData) {
-  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
-    throw new Error(`Invalid ID format: ${id}`);
-  }
-  const item = await getItem(id);
-  if (!item) return;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  if (publishData.accountId) {
-    item.metadata.accountId = String(publishData.accountId);
-  }
-  item.metadata.status = "published";
-  item.metadata.latePostId = String(publishData.latePostId);
-  item.metadata.scheduledFor = String(publishData.scheduledFor);
-  item.metadata.publishedUrl = publishData.publishedUrl ? String(publishData.publishedUrl) : null;
-  item.metadata.publishedAt = now;
-  item.metadata.reviewedAt = now;
-  if (item.metadata.ideaIds && item.metadata.ideaIds.length > 0) {
-    try {
-      const { getIdea: getIdea2, listIdeas: listIdeas2, markPublished: markPublished3 } = await Promise.resolve().then(() => (init_ideaService(), ideaService_exports));
-      let cachedIdeas;
-      for (const rawIdeaId of item.metadata.ideaIds) {
-        const normalizedIdeaId = String(rawIdeaId).trim();
-        if (!normalizedIdeaId) {
-          continue;
-        }
-        const parsedIssueNumber = Number.parseInt(normalizedIdeaId, 10);
-        let issueNumber;
-        if (Number.isInteger(parsedIssueNumber)) {
-          issueNumber = parsedIssueNumber;
-        } else {
-          if (!cachedIdeas) {
-            const ideas = await listIdeas2();
-            cachedIdeas = new Map(ideas.flatMap((idea2) => [[idea2.id, idea2.issueNumber], [String(idea2.issueNumber), idea2.issueNumber]]));
-          }
-          issueNumber = cachedIdeas.get(normalizedIdeaId);
-        }
-        if (!issueNumber) {
-          logger_default.warn(`Skipping publish record for unknown idea identifier: ${normalizedIdeaId}`);
-          continue;
-        }
-        const idea = await getIdea2(issueNumber);
-        if (!idea) {
-          logger_default.warn(`Skipping publish record for missing idea #${issueNumber}`);
-          continue;
-        }
-        await markPublished3(issueNumber, {
-          clipType: item.metadata.clipType,
-          platform: fromLatePlatform(item.metadata.platform),
-          queueItemId: id,
-          publishedAt: now,
-          latePostId: item.metadata.latePostId ?? "",
-          lateUrl: item.metadata.publishedUrl || (item.metadata.latePostId ? `https://app.late.co/dashboard/post/${item.metadata.latePostId}` : "")
-        });
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      logger_default.warn(`Failed to update idea status for ${id}: ${msg}`);
-    }
-  }
-  const sanitizedMetadata = {
-    id: String(item.metadata.id),
-    platform: String(item.metadata.platform),
-    accountId: String(item.metadata.accountId),
-    sourceVideo: String(item.metadata.sourceVideo),
-    sourceClip: item.metadata.sourceClip !== null ? String(item.metadata.sourceClip) : null,
-    clipType: item.metadata.clipType,
-    sourceMediaPath: item.metadata.sourceMediaPath !== null ? String(item.metadata.sourceMediaPath) : null,
-    hashtags: Array.isArray(item.metadata.hashtags) ? item.metadata.hashtags.map(String) : [],
-    links: Array.isArray(item.metadata.links) ? item.metadata.links : [],
-    characterCount: Number(item.metadata.characterCount) || 0,
-    platformCharLimit: Number(item.metadata.platformCharLimit) || 0,
-    suggestedSlot: item.metadata.suggestedSlot !== null ? String(item.metadata.suggestedSlot) : null,
-    scheduledFor: item.metadata.scheduledFor !== null ? String(item.metadata.scheduledFor) : null,
-    status: item.metadata.status,
-    latePostId: item.metadata.latePostId !== null ? String(item.metadata.latePostId) : null,
-    publishedUrl: item.metadata.publishedUrl !== null ? String(item.metadata.publishedUrl) : null,
-    createdAt: String(item.metadata.createdAt),
-    reviewedAt: item.metadata.reviewedAt !== null ? String(item.metadata.reviewedAt) : null,
-    publishedAt: item.metadata.publishedAt !== null ? String(item.metadata.publishedAt) : null,
-    textOnly: item.metadata.textOnly,
-    mediaType: item.metadata.mediaType,
-    ideaIds: Array.isArray(item.metadata.ideaIds) ? item.metadata.ideaIds.map(String) : void 0,
-    platformSpecificData: item.metadata.platformSpecificData
-  };
-  const approveMetadataPath = resolve(join(item.folderPath, "metadata.json"));
-  if (!approveMetadataPath.startsWith(resolve(getQueueDir()) + sep)) {
-    throw new Error("Write target outside queue directory");
-  }
-  await writeTextFile(
-    approveMetadataPath,
-    JSON.stringify(sanitizedMetadata, null, 2)
-  );
-  const publishedDir = getPublishedDir();
-  await ensureDirectory(publishedDir);
-  const destPath = join(publishedDir, basename(id));
-  const resolvedDest = resolve(destPath);
-  const resolvedPublishedDir = resolve(publishedDir);
-  if (!resolvedDest.startsWith(resolvedPublishedDir + sep) && resolvedDest !== resolvedPublishedDir) {
-    throw new Error(`Invalid destination path for item ${id}`);
-  }
-  try {
-    await renameFile(item.folderPath, destPath);
-  } catch (renameErr) {
-    const errCode = renameErr?.code;
-    if (errCode === "EPERM") {
-      logger_default.warn(`rename failed (EPERM) for ${String(id).replace(/[\r\n]/g, "")}, falling back to copy+delete`);
-      await copyDirectory(item.folderPath, destPath);
-      await removeDirectory(item.folderPath, { recursive: true, force: true });
-    } else {
-      throw renameErr;
-    }
-  }
-  logger_default.debug(`Approved and moved queue item: ${String(id).replace(/[\r\n]/g, "")}`);
-}
-async function approveBulk(itemIds, publishDataMap) {
-  const results = [];
-  const errors = [];
-  for (const id of itemIds) {
-    try {
-      const publishData = publishDataMap.get(id);
-      if (!publishData) {
-        errors.push({ itemId: id, error: "No publish data provided" });
-        continue;
-      }
-      await approveItem(id, publishData);
-      results.push({
-        itemId: id,
-        platform: id.split("-").pop() || "unknown",
-        latePostId: publishData.latePostId,
-        scheduledFor: publishData.scheduledFor,
-        publishedUrl: publishData.publishedUrl
-      });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      errors.push({ itemId: id, error: msg });
-      logger_default.error(`Bulk approve failed for ${String(id).replace(/[\r\n]/g, "")}: ${msg}`);
-    }
-  }
-  if (errors.length > 0) {
-    logger_default.warn(`Bulk approval completed with ${errors.length} errors`);
-  }
-  return results;
-}
-async function rejectItem(id) {
-  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
-    throw new Error(`Invalid ID format: ${id}`);
-  }
-  const folderPath = join(getQueueDir(), basename(id));
-  try {
-    await removeDirectory(folderPath, { recursive: true });
-    logger_default.debug(`Rejected and deleted queue item: ${String(id).replace(/[\r\n]/g, "")}`);
-  } catch (err) {
-    logger_default.debug(`Failed to reject queue item ${String(id).replace(/[\r\n]/g, "")}: ${String(err).replace(/[\r\n]/g, "")}`);
-  }
-}
-async function getPublishedItems() {
-  const publishedDir = getPublishedDir();
-  await ensureDirectory(publishedDir);
-  let entries;
-  try {
-    const dirents = await listDirectoryWithTypes(publishedDir);
-    entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
-  } catch {
-    return [];
-  }
-  const items = [];
-  for (const name of entries) {
-    const item = await readQueueItem(join(publishedDir, name), name);
-    if (item) items.push(item);
-  }
-  items.sort((a, b) => a.metadata.createdAt.localeCompare(b.metadata.createdAt));
-  return items;
-}
-async function getScheduledItemsByIdeaIds(ideaIds) {
-  if (ideaIds.length === 0) return [];
-  const ideaIdSet = new Set(ideaIds);
-  const [pendingItems, publishedItems] = await Promise.all([
-    getPendingItems(),
-    getPublishedItems()
-  ]);
-  return [...pendingItems, ...publishedItems].filter(
-    (item) => item.metadata.ideaIds?.some((id) => ideaIdSet.has(id)) ?? false
-  );
-}
-async function updatePublishedItemSchedule(id, scheduledFor) {
-  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
-    throw new Error(`Invalid ID format: ${id}`);
-  }
-  const publishedDir = getPublishedDir();
-  const folderPath = join(publishedDir, basename(id));
-  const metadataPath = join(folderPath, "metadata.json");
-  if (!resolve(metadataPath).startsWith(resolve(publishedDir) + sep)) {
-    throw new Error("Write target outside published directory");
-  }
-  const raw = await readTextFile(metadataPath);
-  const metadata = JSON.parse(raw);
-  metadata.scheduledFor = String(scheduledFor);
-  await writeTextFile(metadataPath, JSON.stringify(metadata, null, 2));
-}
-async function itemExists(id) {
-  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
-    throw new Error(`Invalid ID format: ${id}`);
-  }
-  if (await fileExists(join(getQueueDir(), basename(id)))) {
-    return "pending";
-  }
-  if (await fileExists(join(getPublishedDir(), basename(id)))) {
-    return "published";
-  }
-  return null;
-}
-var init_postStore = __esm({
-  "src/L3-services/postStore/postStore.ts"() {
-    "use strict";
-    init_types2();
-    init_environment();
-    init_configLogger();
-    init_fileSystem();
-    init_paths();
-  }
-});
-
-// src/L1-infra/http/network.ts
-import { Readable } from "stream";
-var init_network = __esm({
-  "src/L1-infra/http/network.ts"() {
-    "use strict";
+// src/L1-infra/http/network.ts
+import { Readable } from "stream";
+var init_network = __esm({
+  "src/L1-infra/http/network.ts"() {
+    "use strict";
   }
 });
 
@@ -11086,6 +11100,333 @@ var init_lateApi = __esm({
   }
 });
 
+// src/L3-services/queueMapping/queueMapping.ts
+var queueMapping_exports = {};
+__export(queueMapping_exports, {
+  clearQueueCache: () => clearQueueCache,
+  getAllQueueMappings: () => getAllQueueMappings,
+  getProfileId: () => getProfileId,
+  getQueueId: () => getQueueId,
+  refreshQueueMappings: () => refreshQueueMappings
+});
+function cachePath() {
+  return join(process.cwd(), CACHE_FILE);
+}
+function isCacheValid(cache2) {
+  const fetchedAtTime = new Date(cache2.fetchedAt).getTime();
+  if (Number.isNaN(fetchedAtTime)) {
+    logger_default.warn("Invalid fetchedAt in queue cache; treating as stale", {
+      fetchedAt: cache2.fetchedAt
+    });
+    return false;
+  }
+  const age = Date.now() - fetchedAtTime;
+  return age < CACHE_TTL_MS2;
+}
+async function readFileCache() {
+  try {
+    const raw = await readTextFile(cachePath());
+    const cache2 = JSON.parse(raw);
+    if (cache2.mappings && cache2.profileId && cache2.fetchedAt && isCacheValid(cache2)) {
+      return cache2;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function writeFileCache(cache2) {
+  try {
+    if (!cache2 || typeof cache2 !== "object" || !cache2.mappings || !cache2.profileId || !cache2.fetchedAt) {
+      logger_default.warn("Invalid queue cache structure, skipping write");
+      return;
+    }
+    const sanitized = {
+      mappings: typeof cache2.mappings === "object" ? { ...cache2.mappings } : {},
+      profileId: String(cache2.profileId),
+      fetchedAt: String(cache2.fetchedAt)
+    };
+    for (const [name, id] of Object.entries(sanitized.mappings)) {
+      if (typeof name !== "string" || typeof id !== "string" || /[\x00-\x1f]/.test(name) || /[\x00-\x1f]/.test(id)) {
+        logger_default.warn("Invalid queue mapping data from API, skipping cache write");
+        return;
+      }
+    }
+    const resolvedCachePath = resolve(cachePath());
+    if (!resolvedCachePath.startsWith(resolve(process.cwd()) + sep)) {
+      throw new Error("Cache path outside working directory");
+    }
+    await writeTextFile(resolvedCachePath, JSON.stringify(sanitized, null, 2));
+  } catch (err) {
+    logger_default.warn("Failed to write queue cache file", { error: err });
+  }
+}
+async function fetchAndCache() {
+  const client = new LateApiClient();
+  const profiles = await client.listProfiles();
+  if (profiles.length === 0) {
+    logger_default.warn("No Late API profiles found \u2014 queue mappings will be empty");
+    const emptyCache = {
+      mappings: {},
+      profileId: "",
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    memoryCache = emptyCache;
+    return emptyCache;
+  }
+  const profileId = profiles[0]._id;
+  const { queues } = await client.listQueues(profileId, true);
+  if (queues.length === 0) {
+    logger_default.warn(
+      "No queues found in Late API \u2014 run `vidpipe sync-queues` to create platform queues"
+    );
+  }
+  const mappings = {};
+  for (const queue2 of queues) {
+    mappings[queue2.name] = queue2._id;
+  }
+  const cache2 = {
+    mappings,
+    profileId,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  memoryCache = cache2;
+  await writeFileCache(cache2);
+  logger_default.info("Refreshed Late queue mappings", {
+    queueCount: queues.length,
+    queues: Object.keys(mappings)
+  });
+  return cache2;
+}
+async function ensureMappings() {
+  if (memoryCache && isCacheValid(memoryCache)) {
+    return memoryCache;
+  }
+  const fileCache = await readFileCache();
+  if (fileCache) {
+    memoryCache = fileCache;
+    return fileCache;
+  }
+  try {
+    return await fetchAndCache();
+  } catch (err) {
+    logger_default.error("Failed to fetch Late queue mappings", { error: err });
+    return { mappings: {}, profileId: "", fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function getQueueId(platform, clipType) {
+  const cache2 = await ensureMappings();
+  const normalizedPlatform = platform === "twitter" ? "x" : platform;
+  const normalizedClipType = clipType === "medium-clip" ? "medium" : clipType;
+  const queueName = `${normalizedPlatform}-${normalizedClipType}`;
+  return cache2.mappings[queueName] ?? null;
+}
+async function getProfileId() {
+  const cache2 = await ensureMappings();
+  return cache2.profileId;
+}
+async function getAllQueueMappings() {
+  const cache2 = await ensureMappings();
+  return { ...cache2.mappings };
+}
+async function refreshQueueMappings() {
+  memoryCache = null;
+  const cache2 = await fetchAndCache();
+  return { ...cache2.mappings };
+}
+async function clearQueueCache() {
+  memoryCache = null;
+  try {
+    await removeFile(cachePath());
+  } catch {
+  }
+}
+var CACHE_FILE, CACHE_TTL_MS2, memoryCache;
+var init_queueMapping = __esm({
+  "src/L3-services/queueMapping/queueMapping.ts"() {
+    "use strict";
+    init_lateApi();
+    init_configLogger();
+    init_fileSystem();
+    init_paths();
+    CACHE_FILE = ".vidpipe-queue-cache.json";
+    CACHE_TTL_MS2 = 24 * 60 * 60 * 1e3;
+    memoryCache = null;
+  }
+});
+
+// src/L3-services/lateApi/lateApiService.ts
+var lateApiService_exports = {};
+__export(lateApiService_exports, {
+  createLateApiClient: () => createLateApiClient,
+  priorityShiftQueue: () => priorityShiftQueue,
+  reorderAllQueues: () => reorderAllQueues,
+  reorderQueue: () => reorderQueue
+});
+function createLateApiClient(...args) {
+  return new LateApiClient(...args);
+}
+async function reorderQueue(platform, clipType, options) {
+  const client = createLateApiClient();
+  const queueId = await getQueueId(platform, clipType);
+  const profileId = await getProfileId();
+  if (!queueId) {
+    logger_default.warn(`No queue found for ${platform}/${clipType}`);
+    return { moved: 0, errors: 0, order: [] };
+  }
+  const allPosts = await client.getScheduledPosts(platform);
+  const queuePosts = allPosts.filter((p) => p.queueId === queueId && p.scheduledFor);
+  if (queuePosts.length === 0) {
+    logger_default.info(`No posts in ${platform}/${clipType} queue \u2014 nothing to reorder`);
+    return { moved: 0, errors: 0, order: [] };
+  }
+  const sorted = [...queuePosts].sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+  logger_default.info(`Reordering ${platform}/${clipType}: ${sorted.length} posts (newest-first)`);
+  if (options?.dryRun) {
+    const slots = queuePosts.map((p) => p.scheduledFor).sort();
+    const order2 = sorted.map((p, i) => ({
+      id: p._id,
+      createdAt: p.createdAt,
+      newSlot: slots[i]
+    }));
+    for (const entry of order2) {
+      logger_default.info(`  ${entry.createdAt.slice(0, 10)} \u2192 ${entry.newSlot?.slice(0, 10)}  [${entry.id.slice(-8)}]`);
+    }
+    return { moved: sorted.length, errors: 0, order: order2 };
+  }
+  const tempResult = await client.createQueue({
+    profileId,
+    name: `temp-${platform}-${clipType}`,
+    timezone: "America/Chicago",
+    slots: [{ dayOfWeek: 0, time: "04:00" }],
+    active: true
+  });
+  const tempQueueId = tempResult.schedule?._id;
+  if (!tempQueueId) {
+    logger_default.error("Failed to create temp queue");
+    return { moved: 0, errors: queuePosts.length, order: [] };
+  }
+  let errors = 0;
+  logger_default.info(`  Moving ${sorted.length} posts to temp queue...`);
+  for (const p of queuePosts) {
+    try {
+      await client.updatePost(p._id, { queuedFromProfile: profileId, queueId: tempQueueId });
+    } catch {
+      errors++;
+    }
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  await new Promise((r) => setTimeout(r, 500));
+  logger_default.info(`  Re-queuing newest-first...`);
+  const order = [];
+  for (const p of sorted) {
+    try {
+      const result = await client.updatePost(p._id, {
+        queuedFromProfile: profileId,
+        queueId,
+        isDraft: false
+      });
+      order.push({ id: p._id, createdAt: p.createdAt, newSlot: result.scheduledFor });
+    } catch {
+      errors++;
+      order.push({ id: p._id, createdAt: p.createdAt });
+    }
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  try {
+    await client.deleteQueue(profileId, tempQueueId);
+  } catch {
+    logger_default.warn("Failed to delete temp queue \u2014 clean up manually");
+  }
+  logger_default.info(`\u2705 Reordered ${platform}/${clipType}: ${sorted.length} posts, ${errors} errors`);
+  return { moved: sorted.length, errors, order };
+}
+async function reorderAllQueues(options) {
+  const { getAllQueueMappings: getAllQueueMappings2 } = await Promise.resolve().then(() => (init_queueMapping(), queueMapping_exports));
+  const mappings = await getAllQueueMappings2();
+  let total = 0;
+  let errors = 0;
+  for (const queueName of Object.keys(mappings)) {
+    const parts = queueName.split("-");
+    const platform = parts[0];
+    const clipType = parts.slice(1).join("-") || "short";
+    const fullClipType = clipType === "medium" ? "medium-clip" : clipType;
+    logger_default.info(`
+\u2500\u2500 ${queueName} \u2500\u2500`);
+    const result = await reorderQueue(platform, fullClipType, options);
+    total += result.moved;
+    errors += result.errors;
+  }
+  logger_default.info(`
+\u2705 All queues reordered: ${total} posts, ${errors} errors`);
+  return { total, errors };
+}
+async function priorityShiftQueue(platform, clipType) {
+  const client = createLateApiClient();
+  const queueId = await getQueueId(platform, clipType);
+  const profileId = await getProfileId();
+  if (!queueId) {
+    logger_default.warn(`No queue found for ${platform}/${clipType} \u2014 cannot priority shift`);
+    return null;
+  }
+  const allPosts = await client.getScheduledPosts(platform);
+  const preview = await client.previewQueue(profileId, queueId, 100);
+  const utcTimePatterns = new Set(
+    (preview.slots ?? []).map((s) => s.slice(11, 16))
+    // Extract HH:MM from UTC ISO strings
+  );
+  const sorted = allPosts.filter((p) => {
+    if (!p.scheduledFor) return false;
+    const postTime = p.scheduledFor.slice(11, 16);
+    return utcTimePatterns.has(postTime);
+  }).sort((a, b) => a.scheduledFor.localeCompare(b.scheduledFor));
+  if (sorted.length === 0) {
+    logger_default.info(`No scheduled posts in ${platform}/${clipType} queue \u2014 no shift needed`);
+    return null;
+  }
+  const freedSlot = sorted[0].scheduledFor;
+  const lastPostDate = sorted[sorted.length - 1].scheduledFor;
+  const nextSlotForLast = preview.slots?.find((s) => s > lastPostDate);
+  if (!nextSlotForLast) {
+    logger_default.warn(`No queue slot found after ${lastPostDate} \u2014 shifting all except last post`);
+    if (sorted.length < 2) {
+      logger_default.info(`Only 1 post in queue \u2014 cannot shift`);
+      return null;
+    }
+    logger_default.info(`Priority shift: freeing ${freedSlot} for ${platform}/${clipType}`);
+    logger_default.info(`  Shifting ${sorted.length - 1} posts (last post stays at ${lastPostDate})`);
+    for (let i = sorted.length - 2; i >= 0; i--) {
+      const post = sorted[i];
+      const newDate = sorted[i + 1].scheduledFor;
+      if (post.scheduledFor === newDate) continue;
+      logger_default.info(`  Rescheduling [${post._id.slice(-8)}]: ${post.scheduledFor} \u2192 ${newDate}`);
+      await client.schedulePost(post._id, newDate);
+    }
+    logger_default.info(`\u2705 Priority shift complete: freed ${freedSlot}, shifted ${sorted.length - 1} posts`);
+    return { freedSlot, shiftedCount: sorted.length - 1 };
+  }
+  logger_default.info(`Priority shift: freeing ${freedSlot} for ${platform}/${clipType}`);
+  logger_default.info(`  Shifting ${sorted.length} posts, last post \u2192 ${nextSlotForLast}`);
+  for (let i = sorted.length - 1; i >= 0; i--) {
+    const post = sorted[i];
+    const newDate = i < sorted.length - 1 ? sorted[i + 1].scheduledFor : nextSlotForLast;
+    const oldDate = post.scheduledFor;
+    if (oldDate === newDate) continue;
+    logger_default.info(`  Rescheduling [${post._id.slice(-8)}]: ${oldDate} \u2192 ${newDate}`);
+    await client.schedulePost(post._id, newDate);
+  }
+  logger_default.info(`\u2705 Priority shift complete: freed ${freedSlot}, shifted ${sorted.length} posts`);
+  return { freedSlot, shiftedCount: sorted.length };
+}
+var init_lateApiService = __esm({
+  "src/L3-services/lateApi/lateApiService.ts"() {
+    "use strict";
+    init_lateApi();
+    init_configLogger();
+    init_queueMapping();
+  }
+});
+
 // src/L2-clients/scheduleStore/scheduleStore.ts
 async function readScheduleFile(filePath) {
   return readTextFile(filePath);
@@ -12005,138 +12346,561 @@ var init_scheduler = __esm({
   }
 });
 
-// src/L3-services/queueMapping/queueMapping.ts
-function cachePath() {
-  return join(process.cwd(), CACHE_FILE);
+// src/L2-clients/azure/blobClient.ts
+import { BlobServiceClient, StorageSharedKeyCredential } from "@azure/storage-blob";
+import { Readable as Readable2 } from "stream";
+import { createReadStream as createReadStream2 } from "fs";
+import { stat } from "fs/promises";
+function getClient() {
+  const config2 = getConfig();
+  const accountName = config2.AZURE_STORAGE_ACCOUNT_NAME;
+  const accountKey = config2.AZURE_STORAGE_ACCOUNT_KEY;
+  const containerName = config2.AZURE_CONTAINER_NAME;
+  if (!accountName || !accountKey) {
+    throw new Error("Azure Storage credentials not configured. Set AZURE_STORAGE_ACCOUNT_NAME and AZURE_STORAGE_ACCOUNT_KEY.");
+  }
+  const credential = new StorageSharedKeyCredential(accountName, accountKey);
+  const blobService = new BlobServiceClient(`https://${accountName}.blob.core.windows.net`, credential);
+  const container = blobService.getContainerClient(containerName);
+  return { blobService, container };
+}
+async function uploadBuffer(blobPath, data, contentType) {
+  const { container } = getClient();
+  const blockBlob = container.getBlockBlobClient(blobPath);
+  await blockBlob.upload(data, data.length, {
+    blobHTTPHeaders: contentType ? { blobContentType: contentType } : void 0
+  });
+  logger_default.debug(`Uploaded blob: ${blobPath} (${data.length} bytes)`);
+  return blockBlob.url;
+}
+async function uploadFile(blobPath, localFilePath, contentType) {
+  const { container } = getClient();
+  const blockBlob = container.getBlockBlobClient(blobPath);
+  const fileStat2 = await stat(localFilePath);
+  await blockBlob.uploadStream(
+    createReadStream2(localFilePath),
+    4 * 1024 * 1024,
+    // 4MB buffer size
+    5,
+    // max concurrency
+    {
+      blobHTTPHeaders: contentType ? { blobContentType: contentType } : void 0
+    }
+  );
+  logger_default.debug(`Uploaded file to blob: ${blobPath} (${fileStat2.size} bytes)`);
+  return blockBlob.url;
 }
-function isCacheValid(cache2) {
-  const fetchedAtTime = new Date(cache2.fetchedAt).getTime();
-  if (Number.isNaN(fetchedAtTime)) {
-    logger_default.warn("Invalid fetchedAt in queue cache; treating as stale", {
-      fetchedAt: cache2.fetchedAt
-    });
-    return false;
+async function downloadToFile(blobPath, localPath) {
+  const { container } = getClient();
+  const blockBlob = container.getBlockBlobClient(blobPath);
+  await blockBlob.downloadToFile(localPath);
+  logger_default.debug(`Downloaded blob to file: ${blobPath} \u2192 ${localPath}`);
+}
+async function downloadStream(blobPath) {
+  const { container } = getClient();
+  const blockBlob = container.getBlockBlobClient(blobPath);
+  const response = await blockBlob.download(0);
+  if (!response.readableStreamBody) {
+    throw new Error(`Failed to get readable stream for blob: ${blobPath}`);
   }
-  const age = Date.now() - fetchedAtTime;
-  return age < CACHE_TTL_MS;
+  return Readable2.from(response.readableStreamBody);
 }
-async function readFileCache() {
+async function listBlobs(prefix) {
+  const { container } = getClient();
+  const blobs = [];
+  for await (const blob of container.listBlobsFlat({ prefix })) {
+    blobs.push(blob.name);
+  }
+  return blobs;
+}
+function isAzureConfigured() {
+  const config2 = getConfig();
+  return Boolean(config2.AZURE_STORAGE_ACCOUNT_NAME && config2.AZURE_STORAGE_ACCOUNT_KEY);
+}
+var init_blobClient = __esm({
+  "src/L2-clients/azure/blobClient.ts"() {
+    "use strict";
+    init_configLogger();
+    init_environment();
+  }
+});
+
+// src/L2-clients/azure/tableClient.ts
+import { TableClient as AzureTableClient, AzureNamedKeyCredential } from "@azure/data-tables";
+function getTableClient(tableName) {
+  const config2 = getConfig();
+  const accountName = config2.AZURE_STORAGE_ACCOUNT_NAME;
+  const accountKey = config2.AZURE_STORAGE_ACCOUNT_KEY;
+  if (!accountName || !accountKey) {
+    throw new Error("Azure Storage credentials not configured. Set AZURE_STORAGE_ACCOUNT_NAME and AZURE_STORAGE_ACCOUNT_KEY.");
+  }
+  const credential = new AzureNamedKeyCredential(accountName, accountKey);
+  const url = `https://${accountName}.table.core.windows.net`;
+  return new AzureTableClient(url, tableName, credential);
+}
+async function upsertEntity(tableName, partitionKey, rowKey, properties) {
+  const client = getTableClient(tableName);
+  const entity = { partitionKey, rowKey, ...properties };
+  await client.upsertEntity(entity, "Merge");
+  logger_default.debug(`Upserted entity: ${tableName}/${partitionKey}/${rowKey}`);
+}
+async function getEntity(tableName, partitionKey, rowKey) {
+  const client = getTableClient(tableName);
   try {
-    const raw = await readTextFile(cachePath());
-    const cache2 = JSON.parse(raw);
-    if (cache2.mappings && cache2.profileId && cache2.fetchedAt && isCacheValid(cache2)) {
-      return cache2;
+    return await client.getEntity(partitionKey, rowKey);
+  } catch (error) {
+    if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+      return null;
     }
-    return null;
+    throw error;
+  }
+}
+async function queryEntities(tableName, filter) {
+  const client = getTableClient(tableName);
+  const entities = [];
+  for await (const entity of client.listEntities({ queryOptions: { filter } })) {
+    entities.push(entity);
+  }
+  return entities;
+}
+async function updateEntity(tableName, partitionKey, rowKey, properties) {
+  const client = getTableClient(tableName);
+  const entity = { partitionKey, rowKey, ...properties };
+  await client.updateEntity(entity, "Merge");
+  logger_default.debug(`Updated entity: ${tableName}/${partitionKey}/${rowKey}`);
+}
+var init_tableClient = __esm({
+  "src/L2-clients/azure/tableClient.ts"() {
+    "use strict";
+    init_configLogger();
+    init_environment();
+  }
+});
+
+// src/L3-services/azureStorage/azureStorageService.ts
+var azureStorageService_exports = {};
+__export(azureStorageService_exports, {
+  downloadBlobToFile: () => downloadBlobToFile,
+  downloadContentMedia: () => downloadContentMedia,
+  findContentItemByRowKey: () => findContentItemByRowKey,
+  getContentItem: () => getContentItem,
+  getContentItems: () => getContentItems,
+  getRunId: () => getRunId,
+  getVideoRecord: () => getVideoRecord,
+  isAzureConfigured: () => isAzureConfigured2,
+  listVideos: () => listVideos,
+  migrateLocalContent: () => migrateLocalContent,
+  updateContentStatus: () => updateContentStatus,
+  uploadContentItem: () => uploadContentItem,
+  uploadPublishQueue: () => uploadPublishQueue,
+  uploadRawVideo: () => uploadRawVideo,
+  uploadVideoFile: () => uploadVideoFile
+});
+import { readdir, readFile } from "fs/promises";
+import { join as join8 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+async function uploadVideoFile(localPath, blobPath) {
+  logger_default.info(`Uploading video to Azure blob: ${blobPath}`);
+  return uploadFile(blobPath, localPath, "video/mp4");
+}
+async function downloadBlobToFile(blobPath, localPath) {
+  return downloadToFile(blobPath, localPath);
+}
+function isAzureConfigured2() {
+  return isAzureConfigured();
+}
+function getRunId() {
+  return process.env.GITHUB_RUN_ID || randomUUID2();
+}
+async function uploadRawVideo(localPath, runId, metadata) {
+  const blobPath = `raw/${runId}-${metadata.originalFilename}`;
+  logger_default.info(`Uploading raw video to Azure: ${blobPath}`);
+  await uploadFile(blobPath, localPath, "video/mp4");
+  await upsertEntity(VIDEOS_TABLE, "video", runId, {
+    originalFilename: metadata.originalFilename,
+    slug: metadata.slug,
+    blobPath,
+    sourceUrl: metadata.sourceUrl || "",
+    duration: metadata.duration || 0,
+    size: metadata.size,
+    status: "completed",
+    contentCount: 0,
+    processedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  logger_default.info(`Created video record: ${runId}`);
+  return blobPath;
+}
+async function uploadContentItem(localItemDir, itemId, videoSlug, runId, metadata) {
+  const blobBasePath = `content/${itemId}/`;
+  const files = await readdir(localItemDir);
+  for (const file of files) {
+    const localFilePath = join8(localItemDir, file);
+    const blobPath = `${blobBasePath}${file}`;
+    const contentType = getContentType(file);
+    await uploadFile(blobPath, localFilePath, contentType);
+  }
+  let itemMetadata = {};
+  const metadataPath = join8(localItemDir, "metadata.json");
+  try {
+    const metadataContent = await readFile(metadataPath, "utf8");
+    itemMetadata = JSON.parse(metadataContent);
+  } catch {
+  }
+  let postContent = "";
+  const postPath = join8(localItemDir, "post.md");
+  try {
+    postContent = await readFile(postPath, "utf8");
   } catch {
-    return null;
   }
+  const mediaFilename = files.find((f) => f.startsWith("media.")) || "";
+  const thumbnailFilename = files.find((f) => f.startsWith("thumbnail.")) || "";
+  const record = {
+    platform: String(itemMetadata.platform || metadata?.platform || ""),
+    clipType: String(itemMetadata.clipType || metadata?.clipType || ""),
+    status: metadata?.status || "pending_review",
+    blobBasePath,
+    mediaType: String(itemMetadata.mediaType || metadata?.mediaType || "video"),
+    mediaFilename,
+    postContent,
+    hashtags: Array.isArray(itemMetadata.hashtags) ? itemMetadata.hashtags.join(",") : metadata?.hashtags || "",
+    characterCount: Number(itemMetadata.characterCount || metadata?.characterCount || postContent.length),
+    scheduledFor: String(itemMetadata.scheduledFor || metadata?.scheduledFor || ""),
+    latePostId: String(itemMetadata.latePostId || metadata?.latePostId || ""),
+    publishedUrl: String(itemMetadata.publishedUrl || metadata?.publishedUrl || ""),
+    sourceVideoRunId: runId,
+    thumbnailFilename,
+    ideaIds: Array.isArray(itemMetadata.ideaIds) ? itemMetadata.ideaIds.join(",") : metadata?.ideaIds || "",
+    createdAt: String(itemMetadata.createdAt || (/* @__PURE__ */ new Date()).toISOString()),
+    reviewedAt: String(itemMetadata.reviewedAt || metadata?.reviewedAt || ""),
+    publishedAt: String(itemMetadata.publishedAt || metadata?.publishedAt || "")
+  };
+  await upsertEntity(CONTENT_TABLE, videoSlug, itemId, record);
+  logger_default.info(`Uploaded content item: ${itemId} (${record.platform}/${record.clipType}) \u2014 blob + table record created`);
+  return blobBasePath;
 }
-async function writeFileCache(cache2) {
+async function uploadPublishQueue(publishQueueDir, videoSlug, runId) {
+  const errors = [];
+  let uploaded = 0;
+  let items;
   try {
-    if (!cache2 || typeof cache2 !== "object" || !cache2.mappings || !cache2.profileId || !cache2.fetchedAt) {
-      logger_default.warn("Invalid queue cache structure, skipping write");
-      return;
-    }
-    const sanitized = {
-      mappings: typeof cache2.mappings === "object" ? { ...cache2.mappings } : {},
-      profileId: String(cache2.profileId),
-      fetchedAt: String(cache2.fetchedAt)
-    };
-    for (const [name, id] of Object.entries(sanitized.mappings)) {
-      if (typeof name !== "string" || typeof id !== "string" || /[\x00-\x1f]/.test(name) || /[\x00-\x1f]/.test(id)) {
-        logger_default.warn("Invalid queue mapping data from API, skipping cache write");
-        return;
+    items = await readdir(publishQueueDir);
+  } catch {
+    logger_default.warn(`Publish queue directory not found: ${publishQueueDir}`);
+    return { uploaded: 0, errors: ["Publish queue directory not found"] };
+  }
+  for (const itemId of items) {
+    const itemDir = join8(publishQueueDir, itemId);
+    try {
+      const metaPath = join8(itemDir, "metadata.json");
+      const metaContent = await readFile(metaPath, "utf8");
+      const meta = JSON.parse(metaContent);
+      const sourceVideo = String(meta.sourceVideo || "");
+      if (sourceVideo && !sourceVideo.endsWith(videoSlug)) {
+        continue;
       }
+    } catch {
+      continue;
     }
-    const resolvedCachePath = resolve(cachePath());
-    if (!resolvedCachePath.startsWith(resolve(process.cwd()) + sep)) {
-      throw new Error("Cache path outside working directory");
+    try {
+      await uploadContentItem(itemDir, itemId, videoSlug, runId);
+      uploaded++;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      errors.push(`${itemId}: ${msg}`);
+      logger_default.error(`Failed to upload content item ${itemId}: ${msg}`);
     }
-    await writeTextFile(resolvedCachePath, JSON.stringify(sanitized, null, 2));
-  } catch (err) {
-    logger_default.warn("Failed to write queue cache file", { error: err });
   }
+  await updateEntity(VIDEOS_TABLE, "video", runId, {
+    contentCount: uploaded
+  });
+  logger_default.info(`Uploaded ${uploaded} content items to Azure (${errors.length} errors)`);
+  return { uploaded, errors };
 }
-async function fetchAndCache() {
-  const client = new LateApiClient();
-  const profiles = await client.listProfiles();
-  if (profiles.length === 0) {
-    logger_default.warn("No Late API profiles found \u2014 queue mappings will be empty");
-    const emptyCache = {
-      mappings: {},
-      profileId: "",
-      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    memoryCache = emptyCache;
-    return emptyCache;
+async function migrateLocalContent(outputDir) {
+  const errors = [];
+  let uploaded = 0;
+  const runId = `migration-${Date.now()}`;
+  const publishQueueDir = join8(outputDir, "publish-queue");
+  try {
+    const items = await readdir(publishQueueDir);
+    for (const itemId of items) {
+      try {
+        const videoSlug = extractVideoSlug(itemId);
+        await uploadContentItem(
+          join8(publishQueueDir, itemId),
+          itemId,
+          videoSlug,
+          runId,
+          { status: "pending_review" }
+        );
+        uploaded++;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        errors.push(`publish-queue/${itemId}: ${msg}`);
+      }
+    }
+  } catch {
+    logger_default.info("No publish-queue directory found for migration");
   }
-  const profileId = profiles[0]._id;
-  const { queues } = await client.listQueues(profileId, true);
-  if (queues.length === 0) {
-    logger_default.warn(
-      "No queues found in Late API \u2014 run `vidpipe sync-queues` to create platform queues"
-    );
+  const publishedDir = join8(outputDir, "published");
+  try {
+    const items = await readdir(publishedDir);
+    for (const itemId of items) {
+      try {
+        const videoSlug = extractVideoSlug(itemId);
+        await uploadContentItem(
+          join8(publishedDir, itemId),
+          itemId,
+          videoSlug,
+          runId,
+          { status: "published" }
+        );
+        uploaded++;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        errors.push(`published/${itemId}: ${msg}`);
+      }
+    }
+  } catch {
+    logger_default.info("No published directory found for migration");
   }
-  const mappings = {};
-  for (const queue2 of queues) {
-    mappings[queue2.name] = queue2._id;
+  logger_default.info(`Migration complete: ${uploaded} items uploaded, ${errors.length} errors`);
+  return { uploaded, errors };
+}
+async function getContentItems(filters) {
+  const parts = [];
+  if (filters?.videoSlug) {
+    parts.push(`PartitionKey eq '${filters.videoSlug}'`);
   }
-  const cache2 = {
-    mappings,
-    profileId,
-    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  memoryCache = cache2;
-  await writeFileCache(cache2);
-  logger_default.info("Refreshed Late queue mappings", {
-    queueCount: queues.length,
-    queues: Object.keys(mappings)
+  if (filters?.status) {
+    parts.push(`status eq '${filters.status}'`);
+  }
+  const filter = parts.length > 0 ? parts.join(" and ") : "";
+  const entities = await queryEntities(
+    CONTENT_TABLE,
+    filter
+  );
+  return entities;
+}
+async function getContentItem(videoSlug, itemId) {
+  const entity = await getEntity(
+    CONTENT_TABLE,
+    videoSlug,
+    itemId
+  );
+  return entity;
+}
+async function findContentItemByRowKey(itemId) {
+  const results = await queryEntities(
+    CONTENT_TABLE,
+    `RowKey eq '${itemId}'`
+  );
+  return results[0] ?? null;
+}
+async function updateContentStatus(videoSlug, itemId, status, extraFields) {
+  await updateEntity(CONTENT_TABLE, videoSlug, itemId, {
+    status,
+    ...extraFields
   });
-  return cache2;
+  logger_default.info(`Updated content status: ${itemId} \u2192 ${status}`);
 }
-async function ensureMappings() {
-  if (memoryCache && isCacheValid(memoryCache)) {
-    return memoryCache;
+async function getVideoRecord(runId) {
+  return getEntity(
+    VIDEOS_TABLE,
+    "video",
+    runId
+  );
+}
+async function listVideos(status) {
+  const filter = status ? `PartitionKey eq 'video' and status eq '${status}'` : "PartitionKey eq 'video'";
+  return queryEntities(
+    VIDEOS_TABLE,
+    filter
+  );
+}
+async function downloadContentMedia(blobPath) {
+  return downloadStream(blobPath);
+}
+function getContentType(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "mp4":
+      return "video/mp4";
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "json":
+      return "application/json";
+    case "md":
+      return "text/markdown";
+    case "srt":
+    case "vtt":
+    case "ass":
+      return "text/plain";
+    default:
+      return "application/octet-stream";
   }
-  const fileCache = await readFileCache();
-  if (fileCache) {
-    memoryCache = fileCache;
-    return fileCache;
+}
+function extractVideoSlug(itemId) {
+  const platforms = ["youtube-shorts", "instagram-reels", "instagram-feed", "twitter", "youtube", "tiktok", "instagram", "linkedin", "x"];
+  for (const platform of platforms) {
+    if (itemId.endsWith(`-${platform}`)) {
+      return itemId.slice(0, -(platform.length + 1));
+    }
+  }
+  return itemId;
+}
+var VIDEOS_TABLE, CONTENT_TABLE;
+var init_azureStorageService = __esm({
+  "src/L3-services/azureStorage/azureStorageService.ts"() {
+    "use strict";
+    init_configLogger();
+    init_blobClient();
+    init_tableClient();
+    VIDEOS_TABLE = "Videos";
+    CONTENT_TABLE = "Content";
+  }
+});
+
+// src/L3-services/azureStorage/azureConfigService.ts
+var azureConfigService_exports = {};
+__export(azureConfigService_exports, {
+  listConfigFiles: () => listConfigFiles,
+  pullConfig: () => pullConfig,
+  pushConfig: () => pushConfig
+});
+import { readdir as readdir2, stat as stat2, mkdir } from "fs/promises";
+import { join as join9 } from "path";
+async function pushConfig(vidpipeDir) {
+  let uploaded = 0;
+  for (const file of CONFIG_FILES) {
+    const fullPath = join9(vidpipeDir, file);
+    try {
+      await stat2(fullPath);
+      const blobPath = `${CONFIG_PREFIX}${file}`;
+      logger_default.info(`Uploading ${file}...`);
+      await uploadFile(blobPath, fullPath);
+      uploaded++;
+      logger_default.info(`  \u2705 ${blobPath}`);
+    } catch {
+      logger_default.debug(`Config file not found, skipping: ${file}`);
+    }
+  }
+  for (const dir of CONFIG_DIRS) {
+    const fullPath = join9(vidpipeDir, dir);
+    try {
+      await stat2(fullPath);
+      logger_default.info(`Uploading ${dir}/...`);
+      const count = await uploadDirectory(fullPath, `${CONFIG_PREFIX}${dir}`);
+      uploaded += count;
+      logger_default.info(`  \u2705 ${dir}/ (${count} files)`);
+    } catch {
+      logger_default.debug(`Config directory not found, skipping: ${dir}/`);
+    }
+  }
+  logger_default.info(`Pushed ${uploaded} config files to Azure`);
+  return { uploaded };
+}
+async function uploadDirectory(localDir, blobPrefix) {
+  let count = 0;
+  const entries = await readdir2(localDir);
+  for (const entry of entries) {
+    const fullPath = join9(localDir, entry);
+    const entryStat = await stat2(fullPath);
+    if (entryStat.isDirectory()) {
+      count += await uploadDirectory(fullPath, `${blobPrefix}/${entry}`);
+    } else if (entryStat.isFile()) {
+      const blobPath = `${blobPrefix}/${entry}`;
+      await uploadFile(blobPath, fullPath);
+      count++;
+    }
+  }
+  return count;
+}
+async function pullConfig(targetDir) {
+  let downloaded = 0;
+  const blobs = await listBlobs(CONFIG_PREFIX);
+  for (const blobPath of blobs) {
+    const relativePath = blobPath.slice(CONFIG_PREFIX.length);
+    const localPath = join9(targetDir, relativePath);
+    const parentDir = join9(localPath, "..");
+    await mkdir(parentDir, { recursive: true });
+    await downloadToFile(blobPath, localPath);
+    downloaded++;
+    logger_default.debug(`Downloaded config: ${blobPath} \u2192 ${localPath}`);
+  }
+  logger_default.info(`Pulled ${downloaded} config files from Azure`);
+  return { downloaded };
+}
+async function listConfigFiles() {
+  const blobs = await listBlobs(CONFIG_PREFIX);
+  return blobs.map((b) => b.slice(CONFIG_PREFIX.length));
+}
+var CONFIG_PREFIX, CONFIG_FILES, CONFIG_DIRS;
+var init_azureConfigService = __esm({
+  "src/L3-services/azureStorage/azureConfigService.ts"() {
+    "use strict";
+    init_configLogger();
+    init_blobClient();
+    CONFIG_PREFIX = "config/";
+    CONFIG_FILES = ["schedule.json", "brand.json"];
+    CONFIG_DIRS = ["assets"];
   }
+});
+
+// src/L4-agents/cloudStorage/cloudStorageOperations.ts
+var cloudStorageOperations_exports = {};
+__export(cloudStorageOperations_exports, {
+  isCloudEnabled: () => isCloudEnabled,
+  migrateLocalContent: () => migrateLocalContent2,
+  pullConfig: () => pullConfig2,
+  pushConfig: () => pushConfig2,
+  uploadPipelineResults: () => uploadPipelineResults
+});
+function isCloudEnabled() {
+  return isAzureConfigured2();
+}
+async function uploadPipelineResults(inputVideoPath, publishQueueDir, videoSlug, metadata) {
+  const runId = getRunId();
+  logger_default.info(`Cloud upload starting (runId: ${runId})`);
+  let videoUploaded = false;
   try {
-    return await fetchAndCache();
-  } catch (err) {
-    logger_default.error("Failed to fetch Late queue mappings", { error: err });
-    return { mappings: {}, profileId: "", fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await uploadRawVideo(inputVideoPath, runId, {
+      ...metadata,
+      slug: videoSlug
+    });
+    videoUploaded = true;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    logger_default.error(`Failed to upload raw video: ${msg}`);
   }
+  const result = await uploadPublishQueue(publishQueueDir, videoSlug, runId);
+  logger_default.info(`Cloud upload complete: video=${videoUploaded}, content=${result.uploaded}, errors=${result.errors.length}`);
+  return {
+    runId,
+    videoUploaded,
+    contentUploaded: result.uploaded,
+    errors: result.errors
+  };
 }
-async function getQueueId(platform, clipType) {
-  const cache2 = await ensureMappings();
-  const normalizedPlatform = platform === "twitter" ? "x" : platform;
-  const queueName = `${normalizedPlatform}-${clipType}`;
-  return cache2.mappings[queueName] ?? null;
+async function pullConfig2(targetDir) {
+  return pullConfig(targetDir);
 }
-async function getProfileId() {
-  const cache2 = await ensureMappings();
-  return cache2.profileId;
+async function pushConfig2(sourceDir) {
+  return pushConfig(sourceDir);
 }
-async function refreshQueueMappings() {
-  memoryCache = null;
-  const cache2 = await fetchAndCache();
-  return { ...cache2.mappings };
+async function migrateLocalContent2(outputDir) {
+  return migrateLocalContent(outputDir);
 }
-var CACHE_FILE, CACHE_TTL_MS, memoryCache;
-var init_queueMapping = __esm({
-  "src/L3-services/queueMapping/queueMapping.ts"() {
+var init_cloudStorageOperations = __esm({
+  "src/L4-agents/cloudStorage/cloudStorageOperations.ts"() {
     "use strict";
-    init_lateApi();
     init_configLogger();
-    init_fileSystem();
-    init_paths();
-    CACHE_FILE = ".vidpipe-queue-cache.json";
-    CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-    memoryCache = null;
+    init_azureStorageService();
+    init_azureConfigService();
   }
 });
 
@@ -12163,7 +12927,8 @@ function buildDesiredQueues(config2) {
     const normalizedPlatform = normalizePlatformName(platformKey);
     if (!platformSchedule.byClipType) continue;
     for (const [clipType, clipTypeSchedule] of Object.entries(platformSchedule.byClipType)) {
-      const queueName = `${normalizedPlatform}-${clipType}`;
+      const normalizedClipType = clipType === "medium-clip" ? "medium" : clipType;
+      const queueName = `${normalizedPlatform}-${normalizedClipType}`;
       const slots = [];
       for (const timeSlot of clipTypeSchedule.slots) {
         for (const day of timeSlot.days) {
@@ -12598,8 +13363,8 @@ var specLoader_exports = {};
 __export(specLoader_exports, {
   loadSpec: () => loadSpec
 });
-import { readFile, readdir } from "fs/promises";
-import { join as join8, extname as extname2 } from "path";
+import { readFile as readFile2, readdir as readdir3 } from "fs/promises";
+import { join as join11, extname as extname2 } from "path";
 import { parse as parseYaml } from "yaml";
 function isFilePath(nameOrPath) {
   return nameOrPath.includes("/") || nameOrPath.includes("\\") || nameOrPath.endsWith(".yaml") || nameOrPath.endsWith(".yml") || nameOrPath.endsWith(".json");
@@ -12613,7 +13378,7 @@ function parseFileContent(raw, filePath) {
 }
 async function fileExists4(filePath) {
   try {
-    await readFile(filePath);
+    await readFile2(filePath);
     return true;
   } catch {
     return false;
@@ -12621,7 +13386,7 @@ async function fileExists4(filePath) {
 }
 async function listSpecFiles(specsDir) {
   try {
-    const entries = await readdir(specsDir);
+    const entries = await readdir3(specsDir);
     return entries.filter((e) => e.endsWith(".yaml") || e.endsWith(".yml") || e.endsWith(".json"));
   } catch {
     return [];
@@ -12640,7 +13405,7 @@ async function loadSpec(nameOrPath, repoRoot) {
   if (isFilePath(nameOrPath)) {
     let raw;
     try {
-      raw = await readFile(nameOrPath, "utf-8");
+      raw = await readFile2(nameOrPath, "utf-8");
     } catch (err) {
       throw new Error(`Failed to read spec file '${nameOrPath}': ${err.message}`);
     }
@@ -12650,10 +13415,10 @@ async function loadSpec(nameOrPath, repoRoot) {
   if (isPresetName(nameOrPath)) {
     return getPreset(nameOrPath);
   }
-  const specsDir = join8(repoRoot, "pipeline-specs");
-  const conventionPath = join8(specsDir, `${nameOrPath}.yaml`);
+  const specsDir = join11(repoRoot, "pipeline-specs");
+  const conventionPath = join11(specsDir, `${nameOrPath}.yaml`);
   if (await fileExists4(conventionPath)) {
-    const raw = await readFile(conventionPath, "utf-8");
+    const raw = await readFile2(conventionPath, "utf-8");
     const parsed = parseFileContent(raw, conventionPath);
     return validateAndMerge(parsed, conventionPath);
   }
@@ -13307,18 +14072,33 @@ ${cues}
 var ASS_HEADER = `[Script Info]
 Title: Auto-generated captions
 ScriptType: v4.00+
-PlayResX: 1920
-PlayResY: 1080
+PlayResX: 1920
+PlayResY: 1080
+WrapStyle: 0
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Default,Montserrat,58,&H00FFFFFF,&H0000FFFF,&H00000000,&H80000000,1,0,0,0,100,100,0,0,1,3,1,2,20,20,40,1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+`;
+var ASS_HEADER_PORTRAIT = `[Script Info]
+Title: Auto-generated captions
+ScriptType: v4.00+
+PlayResX: 1080
+PlayResY: 1920
 WrapStyle: 0
 
 [V4+ Styles]
 Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Montserrat,58,&H00FFFFFF,&H0000FFFF,&H00000000,&H80000000,1,0,0,0,100,100,0,0,1,3,1,2,20,20,40,1
+Style: Default,Montserrat,120,&H00FFFFFF,&H0000FFFF,&H00000000,&H80000000,1,0,0,0,100,100,0,0,1,3,1,2,30,30,770,1
+Style: Hook,Montserrat,56,&H00333333,&H00333333,&H60D0D0D0,&H60E0E0E0,1,0,0,0,100,100,2,0,3,18,2,8,80,80,250,1
 
 [Events]
 Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
 `;
-var ASS_HEADER_PORTRAIT = `[Script Info]
+var ASS_HEADER_PORTRAIT_LOWER = `[Script Info]
 Title: Auto-generated captions
 ScriptType: v4.00+
 PlayResX: 1080
@@ -13327,7 +14107,7 @@ WrapStyle: 0
 
 [V4+ Styles]
 Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Montserrat,120,&H00FFFFFF,&H0000FFFF,&H00000000,&H80000000,1,0,0,0,100,100,0,0,1,3,1,2,30,30,770,1
+Style: Default,Montserrat,120,&H00FFFFFF,&H0000FFFF,&H00000000,&H80000000,1,0,0,0,100,100,0,0,1,3,1,2,30,30,280,1
 Style: Hook,Montserrat,56,&H00333333,&H00333333,&H60D0D0D0,&H60E0E0E0,1,0,0,0,100,100,2,0,3,18,2,8,80,80,250,1
 
 [Events]
@@ -13406,14 +14186,26 @@ function buildPremiumDialogueLines(words, style = "shorts") {
   }
   return dialogues;
 }
+function getASSHeader(style) {
+  switch (style) {
+    case "portrait":
+      return ASS_HEADER_PORTRAIT;
+    case "portrait-lower":
+      return ASS_HEADER_PORTRAIT_LOWER;
+    case "medium":
+      return ASS_HEADER_MEDIUM;
+    default:
+      return ASS_HEADER;
+  }
+}
 function generateStyledASS(transcript, style = "shorts") {
-  const header = style === "portrait" ? ASS_HEADER_PORTRAIT : style === "medium" ? ASS_HEADER_MEDIUM : ASS_HEADER;
+  const header = getASSHeader(style);
   const allWords = transcript.words;
   if (allWords.length === 0) return header;
   return header + buildPremiumDialogueLines(allWords, style).join("\n") + "\n";
 }
 function generateStyledASSForSegment(transcript, startTime, endTime, buffer = 1, style = "shorts") {
-  const header = style === "portrait" ? ASS_HEADER_PORTRAIT : style === "medium" ? ASS_HEADER_MEDIUM : ASS_HEADER;
+  const header = getASSHeader(style);
   const bufferedStart = Math.max(0, startTime - buffer);
   const bufferedEnd = endTime + buffer;
   const words = transcript.words.filter(
@@ -13428,7 +14220,7 @@ function generateStyledASSForSegment(transcript, startTime, endTime, buffer = 1,
   return header + buildPremiumDialogueLines(adjusted, style).join("\n") + "\n";
 }
 function generateStyledASSForComposite(transcript, segments, buffer = 1, style = "shorts") {
-  const header = style === "portrait" ? ASS_HEADER_PORTRAIT : style === "medium" ? ASS_HEADER_MEDIUM : ASS_HEADER;
+  const header = getASSHeader(style);
   const allAdjusted = [];
   let runningOffset = 0;
   for (const seg of segments) {
@@ -13455,14 +14247,16 @@ function generateHookOverlay(hookText, displayDuration = 4, _style = "portrait")
   const text = hookText.length > HOOK_TEXT_MAX_LENGTH ? hookText.slice(0, HOOK_TEXT_MAX_LENGTH - 3) + "..." : hookText;
   return `Dialogue: 1,${toASS(0)},${toASS(displayDuration)},Hook,,0,0,0,,{\\fad(300,500)}${text}`;
 }
-function generatePortraitASSWithHook(transcript, hookText, startTime, endTime, buffer) {
-  const baseASS = generateStyledASSForSegment(transcript, startTime, endTime, buffer, "portrait");
-  const hookLine = generateHookOverlay(hookText, 4, "portrait");
+function generatePortraitASSWithHook(transcript, hookText, startTime, endTime, buffer, isSplitScreen = true) {
+  const style = isSplitScreen ? "portrait" : "portrait-lower";
+  const baseASS = generateStyledASSForSegment(transcript, startTime, endTime, buffer, style);
+  const hookLine = generateHookOverlay(hookText, 4, style);
   return baseASS + hookLine + "\n";
 }
-function generatePortraitASSWithHookComposite(transcript, segments, hookText, buffer) {
-  const baseASS = generateStyledASSForComposite(transcript, segments, buffer, "portrait");
-  const hookLine = generateHookOverlay(hookText, 4, "portrait");
+function generatePortraitASSWithHookComposite(transcript, segments, hookText, buffer, isSplitScreen = true) {
+  const style = isSplitScreen ? "portrait" : "portrait-lower";
+  const baseASS = generateStyledASSForComposite(transcript, segments, buffer, style);
+  const hookLine = generateHookOverlay(hookText, 4, style);
   return baseASS + hookLine + "\n";
 }
 
@@ -15052,6 +15846,19 @@ init_videoOperations();
 init_fileSystem();
 init_paths();
 init_configLogger();
+function mapVariantResults(results) {
+  return results.map((v) => ({
+    path: v.path,
+    aspectRatio: v.aspectRatio,
+    platform: v.platform,
+    width: v.width,
+    height: v.height,
+    isSplitScreen: v.isSplitScreen
+  }));
+}
+function buildPortraitCaptionASS(transcript, segments, hookText, isSplitScreen) {
+  return segments.length === 1 ? generatePortraitASSWithHook(transcript, hookText, segments[0].start, segments[0].end, void 0, isSplitScreen) : generatePortraitASSWithHookComposite(transcript, segments, hookText, void 0, isSplitScreen);
+}
 function buildShortsSystemPrompt(clipConfig) {
   const minDuration = clipConfig?.duration?.min ?? 15;
   const maxDuration = clipConfig?.duration?.max ?? 60;
@@ -15449,13 +16256,7 @@ Words: ${words}`;
           const defaultPlatforms = ["tiktok", "youtube-shorts", "instagram-reels", "instagram-feed", "linkedin"];
           const results = await generatePlatformVariants2(outputPath, shortsDir, shortSlug, defaultPlatforms, { webcamOverride });
           if (results.length > 0) {
-            clipVariants = results.map((v) => ({
-              path: v.path,
-              aspectRatio: v.aspectRatio,
-              platform: v.platform,
-              width: v.width,
-              height: v.height
-            }));
+            clipVariants = mapVariantResults(results);
             logger_default.info(`[ShortsAgent] Generated ${clipVariants.length} platform variants for: ${plan.title}`);
           }
         } catch (err) {
@@ -15483,7 +16284,8 @@ Words: ${words}`;
         if (portraitVariants.length > 0) {
           try {
             const hookText = plan.hook ?? plan.title;
-            const portraitAssContent = segments.length === 1 ? generatePortraitASSWithHook(transcript, hookText, segments[0].start, segments[0].end) : generatePortraitASSWithHookComposite(transcript, segments, hookText);
+            const isSplitScreen = portraitVariants[0].isSplitScreen ?? false;
+            const portraitAssContent = buildPortraitCaptionASS(transcript, segments, hookText, isSplitScreen);
             const portraitAssPath = join(shortsDir, `${shortSlug}-portrait.ass`);
             await writeTextFile(portraitAssPath, portraitAssContent);
             const portraitCaptionedPath = portraitVariants[0].path.replace(".mp4", "-captioned.mp4");
@@ -19206,14 +20008,7 @@ var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
 
 // src/L4-agents/ScheduleAgent.ts
 init_BaseAgent();
-
-// src/L3-services/lateApi/lateApiService.ts
-init_lateApi();
-function createLateApiClient(...args) {
-  return new LateApiClient(...args);
-}
-
-// src/L4-agents/ScheduleAgent.ts
+init_lateApiService();
 init_scheduler();
 init_scheduleConfig();
 
@@ -21316,6 +22111,16 @@ function createIdeaDiscoveryAgent(...args) {
   return new IdeaDiscoveryAgent(...args);
 }
 
+// src/L5-assets/bridges/cloudStorageBridge.ts
+async function uploadToCloud(inputVideoPath, publishQueueDir, videoSlug, metadata) {
+  const { uploadPipelineResults: uploadPipelineResults2 } = await Promise.resolve().then(() => (init_cloudStorageOperations(), cloudStorageOperations_exports));
+  return uploadPipelineResults2(inputVideoPath, publishQueueDir, videoSlug, metadata);
+}
+async function isCloudEnabled2() {
+  const { isCloudEnabled: check } = await Promise.resolve().then(() => (init_cloudStorageOperations(), cloudStorageOperations_exports));
+  return check();
+}
+
 // src/L6-pipeline/pipeline.ts
 init_types2();
 async function runStage(stageName, fn, stageResults) {
@@ -21596,6 +22401,23 @@ async function processVideo(videoPath, ideas, publishBy, spec) {
       skipStage("queue-build" /* QueueBuild */, "NO_SOCIAL_POSTS");
     }
     const blogPost = await trackStage("blog" /* Blog */, () => asset.getBlog());
+    await trackStage("cloud-upload" /* CloudUpload */, async () => {
+      const cloudEnabled = await isCloudEnabled2();
+      if (!cloudEnabled) {
+        logger_default.info("Cloud upload skipped \u2014 Azure storage not configured");
+        return;
+      }
+      const publishQueueDir = join(cfg.OUTPUT_DIR, "publish-queue");
+      const result = await uploadToCloud(videoPath, publishQueueDir, video.slug, {
+        originalFilename: video.filename,
+        duration: video.duration,
+        size: video.size
+      });
+      logger_default.info(`Cloud upload complete \u2014 runId: ${result.runId}, items uploaded: ${result.contentUploaded}, video: ${result.videoUploaded}`);
+      if (result.errors.length > 0) {
+        logger_default.warn(`Cloud upload had ${result.errors.length} error(s): ${result.errors.join("; ")}`);
+      }
+    });
     const totalDuration = Date.now() - pipelineStart;
     const report = costTracker3.getReport();
     if (report.records.length > 0) {
@@ -21708,6 +22530,7 @@ init_process();
 init_fileSystem();
 init_paths();
 init_environment();
+init_lateApiService();
 init_scheduleConfig();
 var require3 = createModuleRequire(import.meta.url);
 function normalizeProviderName(raw) {
@@ -21992,6 +22815,7 @@ function getFFprobePath3(...args) {
 }
 
 // src/L7-app/commands/init.ts
+init_lateApiService();
 init_scheduleConfig();
 var rl = createReadlineInterface({ input: process.stdin, output: process.stdout });
 function ask(question) {
@@ -23160,7 +23984,9 @@ var credentialKeys = [
   "perplexityApiKey",
   "lateApiKey",
   "githubToken",
-  "geminiApiKey"
+  "geminiApiKey",
+  "azureStorageAccountName",
+  "azureStorageAccountKey"
 ];
 var defaultKeys = [
   "llmProvider",
@@ -24152,6 +24978,248 @@ async function runIdeaSearch(query, options) {
   }
 }
 
+// src/L7-app/commands/cloud.ts
+init_environment();
+init_configLogger();
+import { basename as basename3, dirname as dirname6, join as join10 } from "path";
+import { stat as fileStat } from "fs/promises";
+import { execFile } from "child_process";
+var BLOB_PREFIX = "blob://";
+function getVidpipeDir() {
+  const config2 = getConfig();
+  return dirname6(config2.OUTPUT_DIR);
+}
+function createCloudCommand() {
+  const cloud = new Command("cloud").description("Manage cloud storage \u2014 sync config, migrate content, check status");
+  cloud.command("push-config").description("Upload config files (schedule.json, brand.json, assets/) to Azure Storage").action(async () => {
+    initConfig({});
+    const sourceDir = getVidpipeDir();
+    logger_default.info(`Pushing config from ${sourceDir} to Azure Storage...`);
+    try {
+      const { pushConfig: pushConfig3 } = await Promise.resolve().then(() => (init_azureConfigService(), azureConfigService_exports));
+      const result = await pushConfig3(sourceDir);
+      logger_default.info(`\u2705 Pushed ${result.uploaded} config file(s) to Azure Storage`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger_default.error(`Failed to push config: ${msg}`);
+      process.exitCode = 1;
+    }
+    process.exit(process.exitCode ?? 0);
+  });
+  cloud.command("pull-config").description("Download config files from Azure Storage to local directory").action(async () => {
+    initConfig({});
+    const targetDir = getVidpipeDir();
+    logger_default.info(`Pulling config from Azure Storage to ${targetDir}...`);
+    try {
+      const { pullConfig: pullConfig3 } = await Promise.resolve().then(() => (init_azureConfigService(), azureConfigService_exports));
+      const result = await pullConfig3(targetDir);
+      logger_default.info(`\u2705 Pulled ${result.downloaded} config file(s) from Azure Storage`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger_default.error(`Failed to pull config: ${msg}`);
+      process.exitCode = 1;
+    }
+    process.exit(process.exitCode ?? 0);
+  });
+  cloud.command("upload <recording-folder>").description("Upload a recording folder (video + publish-queue) to Azure Storage").option("--slug <slug>", "Video slug (auto-derived from folder name if omitted)").action(async (recordingFolder, opts) => {
+    initConfig({});
+    const config2 = getConfig();
+    try {
+      const { uploadVideoFile: uploadVideoFile2, uploadPublishQueue: uploadPublishQueue2, isAzureConfigured: isAzureConfigured3, getRunId: getRunId2 } = await Promise.resolve().then(() => (init_azureStorageService(), azureStorageService_exports));
+      const { readdir: readdir4, stat: getFileStat } = await import("fs/promises");
+      if (!isAzureConfigured3()) {
+        logger_default.error("Azure Storage not configured");
+        process.exit(1);
+        return;
+      }
+      const files = await readdir4(recordingFolder);
+      const mp4File = files.find((f) => f.endsWith(".mp4"));
+      if (!mp4File) {
+        logger_default.error(`No .mp4 file found in ${recordingFolder}`);
+        process.exit(1);
+        return;
+      }
+      const videoPath = join10(recordingFolder, mp4File);
+      const folderName = basename3(recordingFolder);
+      const slug = opts.slug || folderName.replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+      const runId = getRunId2();
+      const blobPath = `raw/${runId}-${mp4File}`;
+      const stats = await getFileStat(videoPath);
+      logger_default.info(`Uploading ${mp4File} (${(stats.size / 1024 / 1024).toFixed(1)} MB) to Azure...`);
+      await uploadVideoFile2(videoPath, blobPath);
+      logger_default.info(`\u2705 Raw video uploaded: ${blobPath}`);
+      const publishQueueDir = join10(config2.OUTPUT_DIR, "publish-queue");
+      logger_default.info(`Scanning publish-queue for items from ${folderName}...`);
+      let uploaded = 0;
+      const errors = [];
+      try {
+        const queueItems = await readdir4(publishQueueDir);
+        const { readFile: readFile3 } = await import("fs/promises");
+        const { uploadContentItem: uploadContentItem2 } = await Promise.resolve().then(() => (init_azureStorageService(), azureStorageService_exports));
+        for (const itemId of queueItems) {
+          const itemDir = join10(publishQueueDir, itemId);
+          const metadataPath = join10(itemDir, "metadata.json");
+          try {
+            const meta = JSON.parse(await readFile3(metadataPath, "utf8"));
+            const sourceVideo = String(meta.sourceVideo || "");
+            if (!sourceVideo.endsWith(folderName)) continue;
+            await uploadContentItem2(itemDir, itemId, slug, runId);
+            uploaded++;
+            logger_default.info(`  \u2705 ${itemId}`);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            errors.push(`${itemId}: ${msg}`);
+          }
+        }
+      } catch {
+        logger_default.warn("No publish-queue directory found");
+      }
+      logger_default.info(`\u2705 Content uploaded: ${uploaded} item(s)`);
+      if (errors.length > 0) {
+        logger_default.warn(`   ${errors.length} error(s):`);
+        for (const err of errors) {
+          logger_default.warn(`     \u26A0 ${err}`);
+        }
+      }
+      logger_default.info(`Cloud upload complete (runId: ${runId})`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger_default.error(`Failed to upload: ${msg}`);
+      process.exitCode = 1;
+    }
+    process.exit(process.exitCode ?? 0);
+  });
+  cloud.command("migrate").description("Upload existing local publish-queue/ and published/ content to Azure Storage").action(async () => {
+    initConfig({});
+    const config2 = getConfig();
+    const outputDir = config2.OUTPUT_DIR;
+    logger_default.info(`Migrating local content from ${outputDir} to Azure Storage...`);
+    try {
+      const { migrateLocalContent: migrateLocalContent3 } = await Promise.resolve().then(() => (init_azureStorageService(), azureStorageService_exports));
+      const result = await migrateLocalContent3(outputDir);
+      logger_default.info(`\u2705 Migration complete: ${result.uploaded} file(s) uploaded`);
+      if (result.errors.length > 0) {
+        logger_default.warn(`   ${result.errors.length} error(s):`);
+        for (const err of result.errors) {
+          logger_default.warn(`     \u26A0 ${err}`);
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger_default.error(`Failed to migrate content: ${msg}`);
+      process.exitCode = 1;
+    }
+    process.exit(process.exitCode ?? 0);
+  });
+  cloud.command("status").description("Show Azure connection status, stored config files, and content counts").action(async () => {
+    initConfig({});
+    try {
+      const { isAzureConfigured: isAzureConfigured3, getContentItems: getContentItems2, listVideos: listVideos2 } = await Promise.resolve().then(() => (init_azureStorageService(), azureStorageService_exports));
+      const { listConfigFiles: listConfigFiles2 } = await Promise.resolve().then(() => (init_azureConfigService(), azureConfigService_exports));
+      const configured = isAzureConfigured3();
+      console.log(`
+\u2601\uFE0F  Azure Storage Status
+`);
+      console.log(`  Connection: ${configured ? "\u2705 Configured" : "\u274C Not configured"}`);
+      if (!configured) {
+        console.log("\n  Run `vidpipe configure set credentials.azureStorageAccountName <name>` and\n  `vidpipe configure set credentials.azureStorageAccountKey <key>` to configure.\n");
+        process.exit(0);
+        return;
+      }
+      const [configFiles, contentItems, videos] = await Promise.all([
+        listConfigFiles2(),
+        getContentItems2(),
+        listVideos2()
+      ]);
+      console.log(`
+  Config files:    ${configFiles.length}`);
+      for (const file of configFiles) {
+        console.log(`    \u2022 ${file}`);
+      }
+      console.log(`
+  Content items:   ${contentItems.length}`);
+      console.log(`  Videos stored:   ${videos.length}`);
+      console.log();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger_default.error(`Failed to check Azure status: ${msg}`);
+      process.exitCode = 1;
+    }
+    process.exit(process.exitCode ?? 0);
+  });
+  cloud.command("process <video>").description("Upload video to Azure Storage and trigger GitHub Actions pipeline").option("--spec <spec>", "Pipeline spec preset").option("--ideas <ids>", "Comma-separated idea IDs").option("--publish-by <date>", "Publish-by date (ISO or +Nd)").option("--repo <owner/repo>", "GitHub repository", "htekdev/vidpipe").action(async (videoPath, opts) => {
+    initConfig({});
+    try {
+      const { uploadVideoFile: uploadVideoFile2, isAzureConfigured: isAzureConfigured3, getRunId: getRunId2 } = await Promise.resolve().then(() => (init_azureStorageService(), azureStorageService_exports));
+      if (!isAzureConfigured3()) {
+        logger_default.error("Azure Storage not configured. Run `vidpipe configure set credentials.azureStorageAccountName <name>`");
+        process.exit(1);
+        return;
+      }
+      const filename = basename3(videoPath);
+      const runId = getRunId2();
+      const blobPath = `raw/${runId}-${filename}`;
+      const stats = await fileStat(videoPath);
+      logger_default.info(`Uploading ${filename} (${(stats.size / 1024 / 1024).toFixed(1)} MB) to Azure...`);
+      await uploadVideoFile2(videoPath, blobPath);
+      logger_default.info(`\u2705 Uploaded to ${blobPath}`);
+      const videoUrl = `${BLOB_PREFIX}${blobPath}`;
+      const args = ["workflow", "run", "process-video.yml", "--repo", opts.repo, "-f", `video_url=${videoUrl}`];
+      if (opts.spec) args.push("-f", `spec=${opts.spec}`);
+      if (opts.ideas) args.push("-f", `ideas=${opts.ideas}`);
+      if (opts.publishBy) args.push("-f", `publish_by=${opts.publishBy}`);
+      logger_default.info("Triggering GitHub Actions workflow...");
+      await new Promise((resolve4, reject) => {
+        execFile("gh", args, (err, stdout, stderr) => {
+          if (err) {
+            reject(new Error(stderr || err.message));
+            return;
+          }
+          if (stdout.trim()) logger_default.info(stdout.trim());
+          resolve4();
+        });
+      });
+      logger_default.info(`\u2705 Workflow triggered. Video: ${videoUrl}`);
+      logger_default.info(`   Monitor at: https://github.com/${opts.repo}/actions`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger_default.error(`Failed: ${msg}`);
+      process.exitCode = 1;
+    }
+    process.exit(process.exitCode ?? 0);
+  });
+  cloud.command("download <video-url> <output-path>").description("Download a video from Azure blob (blob://) or HTTP URL").action(async (videoUrl, outputPath) => {
+    initConfig({});
+    try {
+      if (videoUrl.startsWith(BLOB_PREFIX)) {
+        const blobPath = videoUrl.slice(BLOB_PREFIX.length);
+        logger_default.info(`Downloading from Azure blob: ${blobPath}`);
+        const { downloadBlobToFile: downloadBlobToFile2 } = await Promise.resolve().then(() => (init_azureStorageService(), azureStorageService_exports));
+        await downloadBlobToFile2(blobPath, outputPath);
+      } else {
+        logger_default.info(`Downloading from URL: ${videoUrl}`);
+        await new Promise((resolve4, reject) => {
+          execFile("curl", ["-L", "--fail", "-o", outputPath, videoUrl], (err, _stdout, stderr) => {
+            if (err) {
+              reject(new Error(stderr || err.message));
+              return;
+            }
+            resolve4();
+          });
+        });
+      }
+      const stats = await fileStat(outputPath);
+      logger_default.info(`\u2705 Downloaded: ${outputPath} (${(stats.size / 1024 / 1024).toFixed(1)} MB)`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger_default.error(`Download failed: ${msg}`);
+      process.exitCode = 1;
+    }
+    process.exit(process.exitCode ?? 0);
+  });
+  return cloud;
+}
+
 // src/L1-infra/http/http.ts
 import { default as default8 } from "express";
 import { Router } from "express";
@@ -24159,17 +25227,182 @@ import { Router } from "express";
 // src/L7-app/review/server.ts
 init_paths();
 
+// src/L3-services/azureStorage/azureReviewDataSource.ts
+init_configLogger();
+init_azureStorageService();
+init_blobClient();
+function mapContentRecordToReviewItem(record) {
+  const itemId = record.rowKey;
+  const mediaFilename = record.mediaFilename || "";
+  const thumbnailFilename = record.thumbnailFilename || "";
+  return {
+    id: itemId,
+    videoSlug: record.partitionKey,
+    platform: record.platform,
+    clipType: record.clipType,
+    status: record.status,
+    mediaType: record.mediaType || "video",
+    mediaUrl: mediaFilename ? `/api/media/${itemId}/${mediaFilename}` : "",
+    postContent: record.postContent || "",
+    hashtags: record.hashtags ? record.hashtags.split(",").filter(Boolean) : [],
+    scheduledFor: record.scheduledFor || null,
+    latePostId: record.latePostId || null,
+    publishedUrl: record.publishedUrl || null,
+    createdAt: record.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+    thumbnailUrl: thumbnailFilename ? `/api/media/${itemId}/${thumbnailFilename}` : null,
+    ideaIds: record.ideaIds ? record.ideaIds.split(",").filter(Boolean) : [],
+    mediaFilename,
+    thumbnailFilename,
+    blobBasePath: record.blobBasePath || `content/${itemId}/`
+  };
+}
+function getContentTypeForFilename(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "mp4":
+      return "video/mp4";
+    case "webm":
+      return "video/webm";
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "gif":
+      return "image/gif";
+    case "webp":
+      return "image/webp";
+    case "md":
+      return "text/markdown";
+    case "json":
+      return "application/json";
+    default:
+      return "application/octet-stream";
+  }
+}
+async function listPendingItems() {
+  const records = await getContentItems({ status: "pending_review" });
+  return records.map(mapContentRecordToReviewItem);
+}
+async function getGroupedItems() {
+  const items = await listPendingItems();
+  const platformSuffixes = [
+    "youtube-shorts",
+    "instagram-reels",
+    "instagram-feed",
+    "twitter",
+    "youtube",
+    "tiktok",
+    "instagram",
+    "linkedin",
+    "x"
+  ];
+  const deduped = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const existing = deduped.get(item.id);
+    if (!existing || item.createdAt > existing.createdAt) {
+      deduped.set(item.id, item);
+    }
+  }
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const item of deduped.values()) {
+    let clipSlug = item.id;
+    for (const suffix of platformSuffixes) {
+      if (item.id.endsWith(`-${suffix}`)) {
+        clipSlug = item.id.slice(0, -(suffix.length + 1));
+        break;
+      }
+    }
+    if (!groupMap.has(clipSlug)) {
+      groupMap.set(clipSlug, []);
+    }
+    groupMap.get(clipSlug).push(item);
+  }
+  const groups = [];
+  for (const [clipSlug, groupItems] of groupMap) {
+    const first = groupItems[0];
+    groups.push({
+      videoSlug: clipSlug,
+      clipType: first.clipType,
+      items: groupItems
+    });
+  }
+  groups.sort((a, b) => {
+    const aHasMedia = a.items.some((i) => Boolean(i.mediaFilename));
+    const bHasMedia = b.items.some((i) => Boolean(i.mediaFilename));
+    if (aHasMedia !== bHasMedia) return aHasMedia ? -1 : 1;
+    return a.items[0].createdAt.localeCompare(b.items[0].createdAt);
+  });
+  return groups;
+}
+async function getItemById(videoSlug, itemId) {
+  const record = await getContentItem(videoSlug, itemId);
+  if (!record) return null;
+  return mapContentRecordToReviewItem(record);
+}
+async function getMediaStream(itemId, filename) {
+  const blobPath = `content/${itemId}/${filename}`;
+  const stream = await downloadStream(blobPath);
+  const contentType = getContentTypeForFilename(filename);
+  return { stream, contentType };
+}
+async function approveItem(videoSlug, itemId) {
+  await updateContentStatus(videoSlug, itemId, "approved", {
+    reviewedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  logger_default.info(`Approved content item: ${itemId}`);
+}
+async function markPublished3(videoSlug, itemId, publishData) {
+  await updateContentStatus(videoSlug, itemId, "published", {
+    latePostId: publishData.latePostId,
+    scheduledFor: publishData.scheduledFor,
+    publishedUrl: publishData.publishedUrl || "",
+    publishedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  logger_default.info(`Marked content item as published: ${itemId} \u2192 ${publishData.latePostId}`);
+}
+async function rejectItem(videoSlug, itemId) {
+  await updateContentStatus(videoSlug, itemId, "rejected");
+  logger_default.info(`Rejected content item: ${itemId}`);
+}
+async function updateItem2(videoSlug, itemId, changes) {
+  const record = await getContentItem(videoSlug, itemId);
+  if (!record) return null;
+  const updateFields = {};
+  if (changes.postContent !== void 0) {
+    updateFields.postContent = changes.postContent;
+    updateFields.characterCount = changes.postContent.length;
+    const blobPath = `content/${itemId}/post.md`;
+    const buffer = Buffer.from(changes.postContent, "utf8");
+    await uploadBuffer(blobPath, buffer, "text/markdown");
+    logger_default.debug(`Updated post.md blob for ${itemId}`);
+  }
+  if (Object.keys(updateFields).length > 0) {
+    await updateContentStatus(videoSlug, itemId, record.status, updateFields);
+  }
+  const updated = await getContentItem(videoSlug, itemId);
+  if (!updated) return null;
+  return mapContentRecordToReviewItem(updated);
+}
+async function downloadMediaToFile(itemId, filename, localPath) {
+  const blobPath = `content/${itemId}/${filename}`;
+  await downloadToFile(blobPath, localPath);
+}
+
 // src/L7-app/review/routes.ts
-init_postStore();
+init_azureStorageService();
 init_ideaService2();
 init_scheduler();
+init_lateApiService();
 init_types2();
 init_configLogger();
 init_queueMapping();
 
 // src/L7-app/review/approvalQueue.ts
+init_paths();
 init_fileSystem();
-init_postStore();
+init_environment();
+init_azureStorageService();
 init_ideaService2();
 init_scheduler();
 init_scheduleConfig();
@@ -24181,7 +25414,7 @@ init_configLogger();
 init_fileSystem();
 init_paths();
 var CACHE_FILE2 = ".vidpipe-cache.json";
-var CACHE_TTL_MS2 = 24 * 60 * 60 * 1e3;
+var CACHE_TTL_MS3 = 24 * 60 * 60 * 1e3;
 var memoryCache2 = null;
 function toLatePlatform2(platform) {
   return platform === "x" /* X */ ? "twitter" : platform;
@@ -24198,7 +25431,7 @@ function isCacheValid2(cache2) {
     return false;
   }
   const age = Date.now() - fetchedAtTime;
-  return age < CACHE_TTL_MS2;
+  return age < CACHE_TTL_MS3;
 }
 async function readFileCache2() {
   try {
@@ -24280,14 +25513,15 @@ async function getAccountId(platform) {
 }
 
 // src/L7-app/review/approvalQueue.ts
+init_lateApiService();
 init_queueMapping();
 init_types2();
 init_configLogger();
 var queue = [];
 var processing = false;
-function enqueueApproval(itemIds) {
+function enqueueApproval(itemIds, options) {
   return new Promise((resolve4) => {
-    queue.push({ itemIds, resolve: resolve4 });
+    queue.push({ itemIds, priority: options?.priority ?? false, resolve: resolve4 });
     if (!processing) drain();
   });
 }
@@ -24296,7 +25530,7 @@ async function drain() {
   while (queue.length > 0) {
     const job = queue.shift();
     try {
-      const result = await processApprovalBatch(job.itemIds);
+      const result = await processApprovalBatch(job.itemIds, job.priority);
       job.resolve(result);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -24311,24 +25545,35 @@ async function drain() {
   }
   processing = false;
 }
-async function processApprovalBatch(itemIds) {
+async function processApprovalBatch(itemIds, priority) {
   const client = createLateApiClient();
   const schedConfig = await loadScheduleConfig();
-  const publishDataMap = /* @__PURE__ */ new Map();
   const results = [];
   const rateLimitedPlatforms = /* @__PURE__ */ new Set();
-  const loadedItems = await Promise.all(
-    itemIds.map(async (id) => ({ id, item: await getItem(id) }))
-  );
-  const itemMap = new Map(loadedItems.map(({ id, item }) => [id, item]));
-  const allIdeaIds = /* @__PURE__ */ new Set();
-  for (const { item } of loadedItems) {
-    if (item?.metadata.ideaIds?.length) {
-      for (const ideaId of item.metadata.ideaIds) {
-        allIdeaIds.add(ideaId);
+  const allPending = await getContentItems({ status: "pending_review" });
+  const itemMap = /* @__PURE__ */ new Map();
+  for (const record of allPending) {
+    if (itemIds.includes(record.rowKey)) {
+      itemMap.set(record.rowKey, { record, videoSlug: record.partitionKey });
+    }
+  }
+  const missingIds = itemIds.filter((id) => !itemMap.has(id));
+  if (missingIds.length > 0) {
+    const allItems = await getContentItems();
+    const missingIdSet = new Set(missingIds);
+    for (const record of allItems) {
+      if (missingIdSet.has(record.rowKey)) {
+        itemMap.set(record.rowKey, { record, videoSlug: record.partitionKey });
       }
     }
   }
+  const allIdeaIds = /* @__PURE__ */ new Set();
+  for (const { record } of itemMap.values()) {
+    const ideas = record.ideaIds ? record.ideaIds.split(",").filter(Boolean) : [];
+    for (const ideaId of ideas) {
+      allIdeaIds.add(ideaId);
+    }
+  }
   let ideaMap = /* @__PURE__ */ new Map();
   if (allIdeaIds.size > 0) {
     try {
@@ -24340,13 +25585,17 @@ async function processApprovalBatch(itemIds) {
     } catch {
     }
   }
-  const enriched = loadedItems.map(({ id, item }) => {
-    const createdAt = item?.metadata.createdAt ?? null;
-    if (!item?.metadata.ideaIds?.length) {
-      return { id, publishBy: null, hasIdeas: false, createdAt };
+  const enriched = itemIds.map((id) => {
+    const entry = itemMap.get(id);
+    if (!entry) return { id, videoSlug: "", publishBy: null, hasIdeas: false, createdAt: null };
+    const { record, videoSlug } = entry;
+    const createdAt = record.createdAt || null;
+    const ideas = record.ideaIds ? record.ideaIds.split(",").filter(Boolean) : [];
+    if (ideas.length === 0) {
+      return { id, videoSlug, publishBy: null, hasIdeas: false, createdAt };
     }
-    const dates = item.metadata.ideaIds.map((ideaId) => ideaMap.get(ideaId)?.publishBy).filter((publishBy) => Boolean(publishBy)).sort();
-    return { id, publishBy: dates[0] ?? null, hasIdeas: true, createdAt };
+    const dates = ideas.map((ideaId) => ideaMap.get(ideaId)?.publishBy).filter((publishBy) => Boolean(publishBy)).sort();
+    return { id, videoSlug, publishBy: dates[0] ?? null, hasIdeas: true, createdAt };
   });
   enriched.sort((a, b) => {
     if (a.hasIdeas && !b.hasIdeas) return -1;
@@ -24367,124 +25616,142 @@ async function processApprovalBatch(itemIds) {
   const publishByMap = new Map(
     enriched.flatMap((entry) => entry.publishBy ? [[entry.id, entry.publishBy]] : [])
   );
-  for (const itemId of sortedIds) {
-    const item = itemMap.get(itemId) ?? null;
-    try {
-      if (!item) {
-        results.push({ itemId, success: false, error: "Item not found" });
-        continue;
-      }
-      const latePlatform = normalizePlatformString(item.metadata.platform);
-      if (rateLimitedPlatforms.has(latePlatform)) {
-        results.push({ itemId, success: false, error: `${latePlatform} rate-limited` });
-        continue;
-      }
-      const ideaIds = item.metadata.ideaIds;
-      const publishBy = publishByMap.get(itemId);
-      const clipType = item.metadata.clipType || "short";
-      const queueId = await getQueueId(latePlatform, clipType);
-      let slot;
-      let useQueue = false;
-      if (queueId) {
-        useQueue = true;
-        logger_default.debug(`Using Late queue ${queueId} for ${latePlatform}/${clipType} (idea priority via batch order)`);
-      } else {
-        logger_default.debug(`No queue for ${latePlatform}/${clipType}, using local slot calculation`);
-        const foundSlot = ideaIds?.length ? await findNextSlot(latePlatform, clipType, { ideaIds, publishBy }) : await findNextSlot(latePlatform, clipType);
-        slot = foundSlot ?? void 0;
-        if (!slot) {
-          results.push({ itemId, success: false, error: `No available slot for ${latePlatform}` });
+  const videoSlugMap = new Map(enriched.map((entry) => [entry.id, entry.videoSlug]));
+  const config2 = getConfig();
+  const tempDir = join(config2.OUTPUT_DIR, ".azure-media-temp");
+  await ensureDirectory(tempDir);
+  try {
+    for (const itemId of sortedIds) {
+      const entry = itemMap.get(itemId);
+      try {
+        if (!entry) {
+          results.push({ itemId, success: false, error: "Item not found" });
           continue;
         }
-      }
-      const platform = fromLatePlatform(latePlatform);
-      const accountId = item.metadata.accountId || await getAccountId(platform);
-      if (!accountId) {
-        results.push({ itemId, success: false, error: `No account for ${latePlatform}` });
-        continue;
-      }
-      let mediaItems;
-      let platformSpecificData = item.metadata.platformSpecificData;
-      const effectiveMediaPath = item.mediaPath ?? item.metadata.sourceMediaPath;
-      if (effectiveMediaPath) {
-        const mediaExists = await fileExists(effectiveMediaPath);
-        if (mediaExists) {
-          if (!item.mediaPath && item.metadata.sourceMediaPath) {
-            logger_default.info(`Using source media fallback for ${String(item.id).replace(/[\r\n]/g, "")}: ${String(item.metadata.sourceMediaPath).replace(/[\r\n]/g, "")}`);
+        const { record, videoSlug } = entry;
+        const latePlatform = normalizePlatformString(record.platform);
+        if (rateLimitedPlatforms.has(latePlatform)) {
+          results.push({ itemId, success: false, error: `${latePlatform} rate-limited` });
+          continue;
+        }
+        const ideaIds = record.ideaIds ? record.ideaIds.split(",").filter(Boolean) : [];
+        const publishBy = publishByMap.get(itemId);
+        const clipType = record.clipType || "short";
+        const queueId = await getQueueId(latePlatform, clipType);
+        let slot;
+        let useQueue = false;
+        if (priority && queueId) {
+          logger_default.info(`\u26A1 Priority scheduling for ${latePlatform}/${clipType}`);
+          const { priorityShiftQueue: priorityShiftQueue2 } = await Promise.resolve().then(() => (init_lateApiService(), lateApiService_exports));
+          const shiftResult = await priorityShiftQueue2(latePlatform, clipType);
+          if (shiftResult) {
+            slot = shiftResult.freedSlot;
+            useQueue = false;
+            logger_default.info(`\u26A1 Freed slot: ${slot} (shifted ${shiftResult.shiftedCount} posts)`);
+          } else {
+            useQueue = true;
+            logger_default.info(`\u26A1 No posts to shift \u2014 using queue normally`);
           }
-          const upload = await client.uploadMedia(effectiveMediaPath);
-          const mediaItem = { type: upload.type, url: upload.url };
-          const effectiveThumbnailPath = item.thumbnailPath ?? item.metadata.thumbnailPath;
-          if (effectiveThumbnailPath && await fileExists(effectiveThumbnailPath)) {
-            try {
-              const thumbUpload = await client.uploadMedia(effectiveThumbnailPath);
-              const thumbUrl = thumbUpload.url;
-              mediaItem.thumbnail = thumbUrl;
-              if (latePlatform === "instagram") {
-                platformSpecificData = { ...platformSpecificData, instagramThumbnail: thumbUrl };
+        } else if (queueId) {
+          useQueue = true;
+          logger_default.debug(`Using Late queue ${queueId} for ${latePlatform}/${clipType} (idea priority via batch order)`);
+        } else {
+          logger_default.debug(`No queue for ${latePlatform}/${clipType}, using local slot calculation`);
+          const foundSlot = ideaIds.length > 0 ? await findNextSlot(latePlatform, clipType, { ideaIds, publishBy }) : await findNextSlot(latePlatform, clipType);
+          slot = foundSlot ?? void 0;
+          if (!slot) {
+            results.push({ itemId, success: false, error: `No available slot for ${latePlatform}` });
+            continue;
+          }
+        }
+        const platform = fromLatePlatform(latePlatform);
+        const accountId = await getAccountId(platform);
+        if (!accountId) {
+          results.push({ itemId, success: false, error: `No account for ${latePlatform}` });
+          continue;
+        }
+        let mediaItems;
+        let platformSpecificData;
+        if (record.mediaFilename) {
+          try {
+            const localMediaPath = join(tempDir, `${itemId}-${record.mediaFilename}`);
+            await downloadMediaToFile(itemId, record.mediaFilename, localMediaPath);
+            const upload = await client.uploadMedia(localMediaPath);
+            const mediaItem = { type: upload.type, url: upload.url };
+            if (record.thumbnailFilename) {
+              try {
+                const localThumbPath = join(tempDir, `${itemId}-${record.thumbnailFilename}`);
+                await downloadMediaToFile(itemId, record.thumbnailFilename, localThumbPath);
+                const thumbUpload = await client.uploadMedia(localThumbPath);
+                const thumbUrl = thumbUpload.url;
+                mediaItem.thumbnail = thumbUrl;
+                if (latePlatform === "instagram") {
+                  platformSpecificData = { ...platformSpecificData, instagramThumbnail: thumbUrl };
+                }
+                logger_default.info(`Uploaded thumbnail for ${String(itemId).replace(/[\r\n]/g, "")}`);
+              } catch (thumbErr) {
+                logger_default.warn(`Failed to upload thumbnail for ${String(itemId).replace(/[\r\n]/g, "")}: ${thumbErr instanceof Error ? thumbErr.message : String(thumbErr)}`);
               }
-              logger_default.info(`Uploaded thumbnail for ${String(item.id).replace(/[\r\n]/g, "")}`);
-            } catch (thumbErr) {
-              logger_default.warn(`Failed to upload thumbnail for ${String(item.id).replace(/[\r\n]/g, "")}: ${thumbErr instanceof Error ? thumbErr.message : String(thumbErr)}`);
             }
+            mediaItems = [mediaItem];
+          } catch (mediaErr) {
+            logger_default.warn(`Failed to download/upload media for ${String(itemId).replace(/[\r\n]/g, "")}: ${mediaErr instanceof Error ? mediaErr.message : String(mediaErr)}`);
           }
-          mediaItems = [mediaItem];
-        }
-      }
-      const isTikTok = latePlatform === "tiktok";
-      const tiktokSettings = isTikTok ? {
-        privacy_level: "PUBLIC_TO_EVERYONE",
-        allow_comment: true,
-        allow_duet: true,
-        allow_stitch: true,
-        content_preview_confirmed: true,
-        express_consent_given: true
-      } : void 0;
-      const profileId = useQueue ? await getProfileId() : void 0;
-      const createParams = {
-        content: item.postContent,
-        platforms: [{ platform: latePlatform, accountId }],
-        timezone: schedConfig.timezone,
-        isDraft: false,
-        mediaItems,
-        platformSpecificData,
-        tiktokSettings
-      };
-      if (useQueue) {
-        createParams.queuedFromProfile = profileId;
-        createParams.queueId = queueId ?? void 0;
-      } else {
-        createParams.scheduledFor = slot;
-      }
-      const latePost = await client.createPost(createParams);
-      publishDataMap.set(itemId, {
-        latePostId: latePost._id,
-        scheduledFor: latePost.scheduledFor ?? slot ?? "",
-        publishedUrl: void 0,
-        accountId
-      });
-      results.push({ itemId, success: true, scheduledFor: latePost.scheduledFor ?? slot, latePostId: latePost._id });
-    } catch (itemErr) {
-      const itemMsg = itemErr instanceof Error ? itemErr.message : String(itemErr);
-      if (itemMsg.includes("429") || itemMsg.includes("Daily post limit")) {
-        const latePlatform = normalizePlatformString(item?.metadata.platform ?? "");
-        rateLimitedPlatforms.add(latePlatform);
-        logger_default.warn(`Approval queue: ${latePlatform} hit daily post limit, skipping remaining ${latePlatform} items`);
-        results.push({ itemId, success: false, error: `${latePlatform} rate-limited` });
-      } else {
-        logger_default.error(`Approval queue: failed for ${String(itemId).replace(/[\r\n]/g, "")}: ${String(itemMsg).replace(/[\r\n]/g, "")}`);
-        results.push({ itemId, success: false, error: itemMsg });
+        }
+        const isTikTok = latePlatform === "tiktok";
+        const tiktokSettings = isTikTok ? {
+          privacy_level: "PUBLIC_TO_EVERYONE",
+          allow_comment: true,
+          allow_duet: true,
+          allow_stitch: true,
+          content_preview_confirmed: true,
+          express_consent_given: true
+        } : void 0;
+        const profileId = useQueue ? await getProfileId() : void 0;
+        const createParams = {
+          content: record.postContent,
+          platforms: [{ platform: latePlatform, accountId }],
+          timezone: schedConfig.timezone,
+          isDraft: false,
+          mediaItems,
+          platformSpecificData,
+          tiktokSettings
+        };
+        if (useQueue) {
+          createParams.queuedFromProfile = profileId;
+          createParams.queueId = queueId ?? void 0;
+        } else {
+          createParams.scheduledFor = slot;
+        }
+        const latePost = await client.createPost(createParams);
+        await approveItem(videoSlug, itemId);
+        await markPublished3(videoSlug, itemId, {
+          latePostId: latePost._id,
+          scheduledFor: latePost.scheduledFor ?? slot ?? "",
+          publishedUrl: void 0
+        });
+        results.push({ itemId, success: true, scheduledFor: latePost.scheduledFor ?? slot, latePostId: latePost._id });
+      } catch (itemErr) {
+        const itemMsg = itemErr instanceof Error ? itemErr.message : String(itemErr);
+        if (itemMsg.includes("429") || itemMsg.includes("Daily post limit")) {
+          const entry2 = itemMap.get(itemId);
+          const latePlatform = normalizePlatformString(entry2?.record.platform ?? "");
+          rateLimitedPlatforms.add(latePlatform);
+          logger_default.warn(`Approval queue: ${latePlatform} hit daily post limit, skipping remaining ${latePlatform} items`);
+          results.push({ itemId, success: false, error: `${latePlatform} rate-limited` });
+        } else {
+          logger_default.error(`Approval queue: failed for ${String(itemId).replace(/[\r\n]/g, "")}: ${String(itemMsg).replace(/[\r\n]/g, "")}`);
+          results.push({ itemId, success: false, error: itemMsg });
+        }
       }
     }
+  } finally {
+    try {
+      await removeDirectory(tempDir);
+    } catch {
+    }
   }
-  const successIds = itemIds.filter((id) => publishDataMap.has(id));
-  if (successIds.length === 1) {
-    const id = successIds[0];
-    await approveItem(id, publishDataMap.get(id));
-  } else if (successIds.length > 1) {
-    await approveBulk(successIds, publishDataMap);
-  }
-  const scheduled = successIds.length;
+  const scheduled = results.filter((r) => r.success).length;
   const failed = itemIds.length - scheduled;
   if (scheduled > 0) {
     logger_default.info(`Approval queue: ${scheduled} of ${itemIds.length} scheduled${rateLimitedPlatforms.size > 0 ? ` (rate-limited: ${[...rateLimitedPlatforms].join(", ")})` : ""}`);
@@ -24493,7 +25760,7 @@ async function processApprovalBatch(itemIds) {
 }
 
 // src/L7-app/review/routes.ts
-var CACHE_TTL_MS3 = 5 * 60 * 1e3;
+var CACHE_TTL_MS4 = 5 * 60 * 1e3;
 var cache = /* @__PURE__ */ new Map();
 function getCached(key) {
   const entry = cache.get(key);
@@ -24501,7 +25768,7 @@ function getCached(key) {
   cache.delete(key);
   return void 0;
 }
-function setCache(key, data, ttl = CACHE_TTL_MS3) {
+function setCache(key, data, ttl = CACHE_TTL_MS4) {
   cache.set(key, { data, expiry: Date.now() + ttl });
 }
 async function getEarliestPublishBy(ideaIds) {
@@ -24513,59 +25780,58 @@ async function getEarliestPublishBy(ideaIds) {
     return void 0;
   }
 }
-async function enrichQueueItem(item) {
-  const ideaPublishBy = item.metadata.ideaIds?.length ? await getEarliestPublishBy(item.metadata.ideaIds) : void 0;
+async function enrichReviewItem(item) {
+  const ideaPublishBy = item.ideaIds?.length ? await getEarliestPublishBy(item.ideaIds) : void 0;
   return {
     ...item,
     ...ideaPublishBy ? { ideaPublishBy } : {}
   };
 }
-async function enrichQueueItems(items) {
-  const allIdeaIds = /* @__PURE__ */ new Set();
-  for (const item of items) {
-    if (item.metadata.ideaIds?.length) {
-      for (const ideaId of item.metadata.ideaIds) {
-        allIdeaIds.add(ideaId);
-      }
-    }
-  }
-  let publishByMap = /* @__PURE__ */ new Map();
-  if (allIdeaIds.size > 0) {
-    try {
-      const ideas = await getIdeasByIds([...allIdeaIds]);
-      for (const idea of ideas) {
-        publishByMap.set(idea.id, idea.publishBy);
-        publishByMap.set(String(idea.issueNumber), idea.publishBy);
-      }
-    } catch {
-    }
-  }
-  return items.map((item) => {
-    if (!item.metadata.ideaIds?.length) return { ...item };
-    const dates = item.metadata.ideaIds.map((id) => publishByMap.get(id)).filter((publishBy) => Boolean(publishBy)).sort();
-    const ideaPublishBy = dates[0];
-    return ideaPublishBy ? { ...item, ideaPublishBy } : { ...item };
+function enrichGroupedItems(groups) {
+  return groups.map((group) => {
+    const firstItem = group.items[0];
+    const hasMedia = group.items.some((item) => Boolean(item.mediaFilename));
+    return {
+      ...group,
+      groupKey: group.videoSlug,
+      hasMedia,
+      mediaType: firstItem?.mediaType || "video",
+      items: group.items.map((item) => ({ ...item }))
+    };
   });
 }
-async function enrichGroupedQueueItems(groups) {
-  return Promise.all(groups.map(async (group) => ({
-    ...group,
-    items: await enrichQueueItems(group.items)
-  })));
-}
 function createRouter() {
   const router = Router();
+  router.get("/api/media/:itemId/:filename", async (req, res) => {
+    try {
+      const { itemId, filename } = req.params;
+      const { stream, contentType } = await getMediaStream(itemId, filename);
+      res.setHeader("Content-Type", contentType);
+      res.setHeader("Cache-Control", "public, max-age=3600");
+      stream.pipe(res);
+      stream.on("error", () => {
+        if (!res.headersSent) {
+          res.status(500).json({ error: "Stream error" });
+        }
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!res.headersSent) {
+        res.status(404).json({ error: msg });
+      }
+    }
+  });
   router.get("/api/posts/pending", async (req, res) => {
-    const items = await enrichQueueItems(await getPendingItems());
+    const items = await listPendingItems();
     res.json({ items, total: items.length });
   });
   router.get("/api/posts/grouped", async (req, res) => {
-    const groups = await enrichGroupedQueueItems(await getGroupedPendingItems());
+    const groups = enrichGroupedItems(await getGroupedItems());
     res.json({ groups, total: groups.length });
   });
   router.get("/api/init", async (req, res) => {
     const [groupsResult, accountsResult, profileResult] = await Promise.allSettled([
-      (async () => enrichGroupedQueueItems(await getGroupedPendingItems()))(),
+      (async () => enrichGroupedItems(await getGroupedItems()))(),
       (async () => {
         const cached = getCached("accounts");
         if (cached) return cached;
@@ -24590,14 +25856,24 @@ function createRouter() {
     res.json({ groups, total: groups.length, accounts, profile });
   });
   router.get("/api/posts/:id", async (req, res) => {
-    const item = await getItem(req.params.id);
+    const match = await findContentItemByRowKey(req.params.id);
+    if (!match) return res.status(404).json({ error: "Item not found" });
+    const item = await getItemById(match.partitionKey, match.rowKey);
     if (!item) return res.status(404).json({ error: "Item not found" });
-    res.json(await enrichQueueItem(item));
+    res.json(await enrichReviewItem(item));
   });
-  router.post("/api/posts/:id/approve", (req, res) => {
+  router.post("/api/posts/:id/approve", async (req, res) => {
     const itemId = req.params.id;
+    const priority = req.query.priority === "true" || req.body?.priority === true;
+    try {
+      const match = await findContentItemByRowKey(itemId);
+      if (match) {
+        await approveItem(match.partitionKey, match.rowKey);
+      }
+    } catch {
+    }
     res.status(202).json({ accepted: true });
-    enqueueApproval([itemId]).then((result) => {
+    enqueueApproval([itemId], { priority }).then((result) => {
       if (result.scheduled > 0) {
         logger_default.info(`Single approve completed: ${String(itemId).replace(/[\r\n]/g, "")} \u2192 ${result.results[0]?.scheduledFor}`);
       } else {
@@ -24606,20 +25882,31 @@ function createRouter() {
     }).catch(() => {
     });
   });
-  router.post("/api/posts/bulk-approve", (req, res) => {
-    const { itemIds } = req.body;
+  router.post("/api/posts/bulk-approve", async (req, res) => {
+    const { itemIds, priority } = req.body;
     if (!Array.isArray(itemIds) || itemIds.length === 0) {
       return res.status(400).json({ error: "itemIds must be a non-empty array" });
     }
+    for (const itemId of itemIds) {
+      try {
+        const match = await findContentItemByRowKey(itemId);
+        if (match) {
+          await approveItem(match.partitionKey, match.rowKey);
+        }
+      } catch {
+      }
+    }
     res.status(202).json({ accepted: true, count: itemIds.length });
-    enqueueApproval(itemIds).catch((err) => {
+    enqueueApproval(itemIds, { priority: priority === true }).catch((err) => {
       const msg = err instanceof Error ? err.message : String(err);
       logger_default.error(`Bulk approve background failed: ${String(msg).replace(/[\r\n]/g, "")}`);
     });
   });
   router.post("/api/posts/:id/reject", async (req, res) => {
     try {
-      await rejectItem(req.params.id);
+      const match = await findContentItemByRowKey(req.params.id);
+      if (!match) return res.status(404).json({ error: "Item not found" });
+      await rejectItem(match.partitionKey, match.rowKey);
       res.json({ success: true });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -24633,23 +25920,32 @@ function createRouter() {
     }
     res.status(202).json({ accepted: true, count: itemIds.length });
     (async () => {
+      const allItems = await getContentItems();
+      const itemLookup = new Map(allItems.map((r) => [r.rowKey, r.partitionKey]));
       let succeeded = 0;
       for (const itemId of itemIds) {
         try {
-          await rejectItem(itemId);
+          const videoSlug = itemLookup.get(itemId);
+          if (!videoSlug) {
+            logger_default.error(`Bulk reject: item not found: ${String(itemId).replace(/[\r\n]/g, "")}`);
+            continue;
+          }
+          await rejectItem(videoSlug, itemId);
           succeeded++;
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           logger_default.error(`Bulk reject failed for ${String(itemId).replace(/[\r\n]/g, "")}: ${String(msg).replace(/[\r\n]/g, "")}`);
         }
       }
-      logger_default.info(`Bulk reject completed: ${succeeded} of ${itemIds.length} removed`);
+      logger_default.info(`Bulk reject completed: ${succeeded} of ${itemIds.length} rejected`);
     })();
   });
   router.put("/api/posts/:id", async (req, res) => {
     try {
-      const { postContent, metadata } = req.body;
-      const updated = await updateItem(req.params.id, { postContent, metadata });
+      const { postContent } = req.body;
+      const match = await findContentItemByRowKey(req.params.id);
+      if (!match) return res.status(404).json({ error: "Item not found" });
+      const updated = await updateItem2(match.partitionKey, match.rowKey, { postContent });
       if (!updated) return res.status(404).json({ error: "Item not found" });
       res.json(updated);
     } catch (err) {
@@ -24718,23 +26014,23 @@ function createRouter() {
 }
 
 // src/L7-app/review/server.ts
-init_environment();
+init_azureStorageService();
 init_configLogger();
 var __dirname3 = dirname(fileURLToPath(import.meta.url));
 async function startReviewServer(options = {}) {
+  if (!isAzureConfigured2()) {
+    const msg = "Review server requires Azure Storage. Set AZURE_STORAGE_ACCOUNT_NAME and AZURE_STORAGE_ACCOUNT_KEY environment variables.";
+    logger_default.error(msg);
+    throw new Error(msg);
+  }
   const app = default8();
   const port = options.port || 3847;
   app.use(default8.json());
   app.use(createRouter());
-  const cfg = getConfig();
-  const queueDir = join(cfg.OUTPUT_DIR, "publish-queue");
-  const publishedDir = join(cfg.OUTPUT_DIR, "published");
-  app.use("/media/queue", default8.static(queueDir));
-  app.use("/media/published", default8.static(publishedDir));
   const publicDir = join(__dirname3, "public");
   app.use(default8.static(publicDir));
   app.get("/{*splat}", (req, res) => {
-    if (!req.path.startsWith("/api/") && !req.path.startsWith("/media/")) {
+    if (!req.path.startsWith("/api/")) {
       res.sendFile(join(publicDir, "index.html"));
     }
   });
@@ -24857,6 +26153,23 @@ program.command("realign").description("Realign all Late scheduled, cancelled, a
   await runRealign({ platform: opts.platform, dryRun: opts.dryRun, queue: opts.queue });
   process.exit(0);
 });
+program.command("reorder-queue").description("Reorder Late queue so newest content gets earliest slots (temp queue swap)").option("--platform <name>", "Filter to a single platform (tiktok, youtube, instagram, linkedin, x)").option("--clip-type <type>", "Filter to a clip type (short, medium-clip, video)").option("--dry-run", "Preview the reorder plan without making changes").option("--all", "Reorder all queues").action(async (opts) => {
+  initConfig({});
+  const { reorderQueue: reorderQueue2, reorderAllQueues: reorderAllQueues2 } = await Promise.resolve().then(() => (init_lateApiService(), lateApiService_exports));
+  if (opts.all) {
+    logger_default.info("Reordering ALL queues (newest-first)...");
+    const result = await reorderAllQueues2({ dryRun: opts.dryRun });
+    logger_default.info(`
+Total: ${result.total} posts reordered, ${result.errors} errors`);
+  } else if (opts.platform && opts.clipType) {
+    const result = await reorderQueue2(opts.platform, opts.clipType, { dryRun: opts.dryRun });
+    logger_default.info(`Reordered: ${result.moved} posts, ${result.errors} errors`);
+  } else {
+    logger_default.error("Specify --platform + --clip-type, or use --all to reorder everything");
+    process.exit(1);
+  }
+  process.exit(0);
+});
 program.command("reschedule").description("Reschedule idea-linked posts for optimal slot placement, displacing non-idea content").option("--dry-run", "Preview changes without updating posts").option("--queue", "Use Late API queue reshuffle instead of per-post reschedule").action(async (opts) => {
   const { runReschedule: runReschedule2 } = await Promise.resolve().then(() => (init_reschedule(), reschedule_exports));
   await runReschedule2({ dryRun: opts.dryRun, queue: opts.queue });
@@ -24966,6 +26279,7 @@ program.command("specs").description("List available pipeline spec presets and c
   console.log("\nUsage: vidpipe process --spec <name-or-path> video.mp4\n");
   process.exit(0);
 });
+program.addCommand(createCloudCommand());
 var defaultCmd = program.command("process", { isDefault: true }).argument("[video-path]", "Path to a video file to process (implies --once)").option("--watch-dir <path>", "Folder to watch for new recordings (default: env WATCH_FOLDER)").option("--output-dir <path>", "Output directory for processed videos (default: ./recordings)").option("--openai-key <key>", "OpenAI API key (default: env OPENAI_API_KEY)").option("--exa-key <key>", "Exa AI API key for web search (default: env EXA_API_KEY)").option("--youtube-key <key>", "YouTube API key (default: env YOUTUBE_API_KEY)").option("--perplexity-key <key>", "Perplexity API key (default: env PERPLEXITY_API_KEY)").option("--once", "Process a single video and exit (no watching)").option("--brand <path>", "Path to brand.json config (default: ./brand.json)").option("--no-silence-removal", "Skip silence removal stage").option("--no-shorts", "Skip shorts generation").option("--no-medium-clips", "Skip medium clip generation").option("--no-social", "Skip social media post generation").option("--no-captions", "Skip caption generation/burning").option("--no-visual-enhancement", "Skip visual enhancement (AI image overlays)").option("--no-intro-outro", "Skip intro/outro concatenation").option("--no-social-publish", "Skip social media publishing/queue-build stage").option("--spec <nameOrPath>", "Pipeline spec preset name or YAML file path").option("--late-api-key <key>", "Late API key (default: env LATE_API_KEY)").option("--late-profile-id <id>", "Late profile ID (default: env LATE_PROFILE_ID)").option("--ideas <ids>", "Comma-separated idea IDs to link to this video").option("--publish-by <date>", "Publish-by deadline for auto-created ideas (ISO date or +Nd for relative, default: +7d)").option("-v, --verbose", "Verbose logging").option("--progress", "Emit structured JSON progress events to stderr").option("--doctor", "Check all prerequisites and exit").action(async (videoPath) => {
   const opts = defaultCmd.opts();
   if (opts.doctor) {