vidpipe 1.3.13 → 1.3.15

package/dist/index.js

@@ -85,6 +85,7 @@ var init_types = __esm({
       PipelineStage2["Chapters"] = "chapters";
       PipelineStage2["Captions"] = "captions";
       PipelineStage2["CaptionBurn"] = "caption-burn";
+      PipelineStage2["IntroOutro"] = "intro-outro";
       PipelineStage2["Summary"] = "summary";
       PipelineStage2["Shorts"] = "shorts";
       PipelineStage2["MediumClips"] = "medium-clips";
@@ -102,15 +103,16 @@ var init_types = __esm({
       { stage: "visual-enhancement" /* VisualEnhancement */, name: "Visual Enhancement", stageNumber: 4 },
       { stage: "captions" /* Captions */, name: "Captions", stageNumber: 5 },
       { stage: "caption-burn" /* CaptionBurn */, name: "Caption Burn", stageNumber: 6 },
-      { stage: "shorts" /* Shorts */, name: "Shorts", stageNumber: 7 },
-      { stage: "medium-clips" /* MediumClips */, name: "Medium Clips", stageNumber: 8 },
-      { stage: "chapters" /* Chapters */, name: "Chapters", stageNumber: 9 },
-      { stage: "summary" /* Summary */, name: "Summary", stageNumber: 10 },
-      { stage: "social-media" /* SocialMedia */, name: "Social Media", stageNumber: 11 },
-      { stage: "short-posts" /* ShortPosts */, name: "Short Posts", stageNumber: 12 },
-      { stage: "medium-clip-posts" /* MediumClipPosts */, name: "Medium Clip Posts", stageNumber: 13 },
-      { stage: "queue-build" /* QueueBuild */, name: "Queue Build", stageNumber: 14 },
-      { stage: "blog" /* Blog */, name: "Blog", stageNumber: 15 }
+      { stage: "intro-outro" /* IntroOutro */, name: "Intro/Outro", stageNumber: 7 },
+      { stage: "shorts" /* Shorts */, name: "Shorts", stageNumber: 8 },
+      { stage: "medium-clips" /* MediumClips */, name: "Medium Clips", stageNumber: 9 },
+      { stage: "chapters" /* Chapters */, name: "Chapters", stageNumber: 10 },
+      { stage: "summary" /* Summary */, name: "Summary", stageNumber: 11 },
+      { stage: "social-media" /* SocialMedia */, name: "Social Media", stageNumber: 12 },
+      { stage: "short-posts" /* ShortPosts */, name: "Short Posts", stageNumber: 13 },
+      { stage: "medium-clip-posts" /* MediumClipPosts */, name: "Medium Clip Posts", stageNumber: 14 },
+      { stage: "queue-build" /* QueueBuild */, name: "Queue Build", stageNumber: 15 },
+      { stage: "blog" /* Blog */, name: "Blog", stageNumber: 16 }
     ];
     TOTAL_STAGES = PIPELINE_STAGES.length;
     PLATFORM_CHAR_LIMITS = {
@@ -446,6 +448,12 @@ function saveGlobalConfig(config2) {
     chmodSync(configPath, 384);
   }
 }
+function getGlobalConfigValue(section, key) {
+  const config2 = loadGlobalConfig();
+  const sectionValues = config2[section];
+  const value = sectionValues[key];
+  return typeof value === "string" ? value : void 0;
+}
 function setGlobalConfigValue(section, key, value) {
   const config2 = loadGlobalConfig();
   const sectionValues = config2[section];
@@ -592,6 +600,11 @@ function resolveConfig(cliOptions = {}) {
       process.env.SKIP_VISUAL_ENHANCEMENT,
       false
     ),
+    SKIP_INTRO_OUTRO: resolveBoolean(
+      cliOptions.introOutro === void 0 ? void 0 : !cliOptions.introOutro,
+      process.env.SKIP_INTRO_OUTRO,
+      false
+    ),
     LATE_API_KEY: resolveString(
       cliOptions.lateApiKey,
       process.env.LATE_API_KEY,
@@ -863,7 +876,7 @@ var init_githubClient = __esm({
             const response = await this.octokit.rest.issues.listForRepo({
               owner: this.owner,
               repo: this.repo,
-              state: "open",
+              state: options.state ?? "all",
               labels: options.labels && options.labels.length > 0 ? normalizeLabels(options.labels).join(",") : void 0,
               sort: void 0,
               direction: void 0,
@@ -4661,6 +4674,150 @@ var require_node = __commonJS({
   }
 });
 
+// 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;
+    }
+    return {
+      id,
+      metadata,
+      postContent,
+      hasMedia,
+      mediaPath,
+      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 createItem(id, metadata, postContent, mediaSourcePath) {
+  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;
+  }
+  logger_default.debug(`Created queue item: ${String(id).replace(/[\r\n]/g, "")}`);
+  return {
+    id,
+    metadata,
+    postContent,
+    hasMedia,
+    mediaPath: hasMedia ? mediaPath : null,
+    folderPath
+  };
+}
+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 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_types();
+    init_environment();
+    init_configLogger();
+    init_fileSystem();
+    init_paths();
+  }
+});
+
 // src/L7-app/sdk/VidPipeSDK.ts
 init_types();
 init_environment();
@@ -4712,6 +4869,17 @@ var progressEmitter = new ProgressEmitter();
 // src/L1-infra/process/process.ts
 import { execFile as nodeExecFile, execSync as nodeExecSync, spawnSync as nodeSpawnSync } from "child_process";
 import { createRequire } from "module";
+function execCommand(cmd, args, opts) {
+  return new Promise((resolve3, reject) => {
+    nodeExecFile(cmd, args, { ...opts, encoding: "utf-8" }, (error, stdout, stderr) => {
+      if (error) {
+        reject(Object.assign(error, { stdout: String(stdout ?? ""), stderr: String(stderr ?? "") }));
+      } else {
+        resolve3({ stdout: String(stdout ?? ""), stderr: String(stderr ?? "") });
+      }
+    });
+  });
+}
 function execFileRaw(cmd, args, opts, callback) {
   nodeExecFile(cmd, args, { ...opts, encoding: "utf-8" }, (error, stdout, stderr) => {
     callback(error, String(stdout ?? ""), String(stderr ?? ""));
@@ -7403,16 +7571,10 @@ var LateApiClient = class {
     return data.accounts ?? [];
   }
   async getScheduledPosts(platform) {
-    const params = new URLSearchParams({ status: "scheduled" });
-    if (platform) params.set("platform", platform);
-    const data = await this.request(`/posts?${params}`);
-    return data.posts ?? [];
+    return this.listPosts({ status: "scheduled", platform });
   }
   async getDraftPosts(platform) {
-    const params = new URLSearchParams({ status: "draft" });
-    if (platform) params.set("platform", platform);
-    const data = await this.request(`/posts?${params}`);
-    return data.posts ?? [];
+    return this.listPosts({ status: "draft", platform });
   }
   async createPost(params) {
     const data = await this.request("/posts", {
@@ -7518,6 +7680,7 @@ function createLateApiClient(...args) {
 // src/L2-clients/scheduleStore/scheduleStore.ts
 init_fileSystem();
 init_paths();
+init_globalConfig();
 async function readScheduleFile(filePath) {
   return readTextFile(filePath);
 }
@@ -7529,7 +7692,10 @@ async function writeScheduleFile(filePath, content) {
   });
 }
 function resolveSchedulePath(configPath) {
-  return configPath ?? join(process.cwd(), "schedule.json");
+  if (configPath) return configPath;
+  const globalPath = getGlobalConfigValue("defaults", "scheduleConfig");
+  if (globalPath) return globalPath;
+  return join(process.cwd(), "schedule.json");
 }
 
 // src/L3-services/scheduler/scheduleConfig.ts
@@ -7794,7 +7960,7 @@ function getPlatformSchedule(platform, clipType) {
       avoidDays: sub.avoidDays
     };
   }
-  if (clipType && schedule.slots.length === 0 && schedule.byClipType) {
+  if (schedule.slots.length === 0 && schedule.byClipType) {
     const allSlots = [];
     const allAvoidDays = /* @__PURE__ */ new Set();
     for (const sub of Object.values(schedule.byClipType)) {
@@ -7815,162 +7981,36 @@ function getDisplacementConfig() {
   return cachedConfig?.displacement ?? { ...defaultDisplacement };
 }
 
-// src/L3-services/postStore/postStore.ts
-init_types();
-init_environment();
+// src/L3-services/scheduler/realign.ts
+init_postStore();
 init_configLogger();
-init_fileSystem();
-init_paths();
-function getQueueDir() {
-  const { OUTPUT_DIR } = getConfig();
-  return join(OUTPUT_DIR, "publish-queue");
-}
-function getPublishedDir() {
-  const { OUTPUT_DIR } = getConfig();
-  return join(OUTPUT_DIR, "published");
+
+// src/L3-services/scheduler/scheduler.ts
+init_configLogger();
+init_postStore();
+var MAX_LOOKAHEAD_DAYS = 730;
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var HOUR_MS = 60 * 60 * 1e3;
+function normalizeDateTime(isoString) {
+  return new Date(isoString).getTime();
 }
-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;
-    }
-    return {
-      id,
-      metadata,
-      postContent,
-      hasMedia,
-      mediaPath,
-      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;
-  }
+function sanitizeLogValue(value) {
+  return value.replace(/[\r\n]/g, "");
 }
-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);
+function getTimezoneOffset(timezone, date) {
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    timeZoneName: "longOffset"
   });
-  return items;
-}
-async function createItem(id, metadata, postContent, mediaSourcePath) {
-  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;
-  }
-  logger_default.debug(`Created queue item: ${String(id).replace(/[\r\n]/g, "")}`);
-  return {
-    id,
-    metadata,
-    postContent,
-    hasMedia,
-    mediaPath: hasMedia ? mediaPath : null,
-    folderPath
-  };
-}
-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 getPublishedItemByLatePostId(latePostId) {
-  const publishedItems = await getPublishedItems();
-  return publishedItems.find((item) => item.metadata.latePostId === latePostId) ?? null;
-}
-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;
-}
-
-// src/L3-services/scheduler/realign.ts
-init_configLogger();
-function getTimezoneOffset(timezone, date) {
-  const formatter = new Intl.DateTimeFormat("en-US", {
-    timeZone: timezone,
-    timeZoneName: "longOffset"
-  });
-  const parts = formatter.formatToParts(date);
-  const tzPart = parts.find((p) => p.type === "timeZoneName");
-  const match = tzPart?.value?.match(/GMT([+-]\d{2}:\d{2})/);
-  if (match) return match[1];
-  if (tzPart?.value === "GMT") return "+00:00";
-  return "+00:00";
+  const parts = formatter.formatToParts(date);
+  const tzPart = parts.find((part) => part.type === "timeZoneName");
+  const match = tzPart?.value?.match(/GMT([+-]\d{2}:\d{2})/);
+  if (match) return match[1];
+  if (tzPart?.value === "GMT") return "+00:00";
+  logger_default.warn(
+    `Could not parse timezone offset for timezone "${timezone}" on date "${date.toISOString()}". Raw timeZoneName part: "${tzPart?.value ?? "undefined"}". Falling back to UTC (+00:00).`
+  );
+  return "+00:00";
 }
 function buildSlotDatetime(date, time, timezone) {
   const formatter = new Intl.DateTimeFormat("en-US", {
@@ -7980,9 +8020,12 @@ function buildSlotDatetime(date, time, timezone) {
     day: "2-digit"
   });
   const parts = formatter.formatToParts(date);
-  const year = parts.find((p) => p.type === "year")?.value ?? String(date.getFullYear());
-  const month = (parts.find((p) => p.type === "month")?.value ?? String(date.getMonth() + 1)).padStart(2, "0");
-  const day = (parts.find((p) => p.type === "day")?.value ?? String(date.getDate())).padStart(2, "0");
+  const yearPart = parts.find((part) => part.type === "year")?.value;
+  const monthPart = parts.find((part) => part.type === "month")?.value;
+  const dayPart = parts.find((part) => part.type === "day")?.value;
+  const year = yearPart ?? String(date.getFullYear());
+  const month = (monthPart ?? String(date.getMonth() + 1)).padStart(2, "0");
+  const day = (dayPart ?? String(date.getDate())).padStart(2, "0");
   const offset = getTimezoneOffset(timezone, date);
   return `${year}-${month}-${day}T${time}:00${offset}`;
 }
@@ -8003,6 +8046,277 @@ function getDayOfWeekInTimezone(date, timezone) {
   };
   return map[short] ?? "mon";
 }
+async function fetchScheduledPostsSafe(platform) {
+  try {
+    const client = new LateApiClient();
+    return await client.getScheduledPosts(platform);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger_default.warn(`Late API unreachable, using local data only: ${msg}`);
+    return [];
+  }
+}
+async function buildBookedMap(platform) {
+  const [latePosts, publishedItems] = await Promise.all([
+    fetchScheduledPostsSafe(platform),
+    getPublishedItems()
+  ]);
+  const ideaLinkedPostIds = /* @__PURE__ */ new Set();
+  for (const item of publishedItems) {
+    if (item.metadata.latePostId && item.metadata.ideaIds?.length) {
+      ideaLinkedPostIds.add(item.metadata.latePostId);
+    }
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const post of latePosts) {
+    if (!post.scheduledFor) continue;
+    for (const scheduledPlatform of post.platforms) {
+      if (!platform || scheduledPlatform.platform === platform) {
+        const ms = normalizeDateTime(post.scheduledFor);
+        map.set(ms, {
+          scheduledFor: post.scheduledFor,
+          source: "late",
+          postId: post._id,
+          platform: scheduledPlatform.platform,
+          status: post.status,
+          ideaLinked: ideaLinkedPostIds.has(post._id)
+        });
+      }
+    }
+  }
+  for (const item of publishedItems) {
+    if (platform && item.metadata.platform !== platform) continue;
+    if (!item.metadata.scheduledFor) continue;
+    const ms = normalizeDateTime(item.metadata.scheduledFor);
+    if (!map.has(ms)) {
+      map.set(ms, {
+        scheduledFor: item.metadata.scheduledFor,
+        source: "local",
+        itemId: item.id,
+        platform: item.metadata.platform,
+        ideaLinked: Boolean(item.metadata.ideaIds?.length)
+      });
+    }
+  }
+  return map;
+}
+async function getIdeaLinkedLatePostIds() {
+  const publishedItems = await getPublishedItems();
+  const ids = /* @__PURE__ */ new Set();
+  for (const item of publishedItems) {
+    if (item.metadata.latePostId && item.metadata.ideaIds?.length) {
+      ids.add(item.metadata.latePostId);
+    }
+  }
+  return ids;
+}
+function* generateTimeslots(platformConfig, timezone, fromMs, maxMs) {
+  const baseDate = new Date(fromMs);
+  const upperMs = maxMs ?? fromMs + MAX_LOOKAHEAD_DAYS * DAY_MS;
+  for (let dayOffset = 0; dayOffset <= MAX_LOOKAHEAD_DAYS; dayOffset++) {
+    const day = new Date(baseDate);
+    day.setDate(day.getDate() + dayOffset);
+    const dayOfWeek = getDayOfWeekInTimezone(day, timezone);
+    if (platformConfig.avoidDays.includes(dayOfWeek)) continue;
+    const dayCandidates = [];
+    for (const slot of platformConfig.slots) {
+      if (!slot.days.includes(dayOfWeek)) continue;
+      const datetime = buildSlotDatetime(day, slot.time, timezone);
+      const ms = normalizeDateTime(datetime);
+      if (ms <= fromMs) continue;
+      if (ms > upperMs) continue;
+      dayCandidates.push({ datetime, ms });
+    }
+    dayCandidates.sort((a, b) => a.ms - b.ms);
+    for (const candidate of dayCandidates) yield candidate;
+    if (dayCandidates.length === 0) {
+      const dayStartMs = normalizeDateTime(buildSlotDatetime(day, "00:00", timezone));
+      if (dayStartMs > upperMs) break;
+    }
+  }
+}
+function passesIdeaSpacing(candidateMs, candidatePlatform, ideaRefs, samePlatformMs, crossPlatformMs) {
+  for (const ref of ideaRefs) {
+    const diff = Math.abs(candidateMs - ref.scheduledForMs);
+    if (ref.platform === candidatePlatform && diff < samePlatformMs) return false;
+    if (diff < crossPlatformMs) return false;
+  }
+  return true;
+}
+async function getIdeaReferences(ideaIds, bookedMap) {
+  const sameIdeaPosts = await getScheduledItemsByIdeaIds(ideaIds);
+  const lateSlotsByPostId = /* @__PURE__ */ new Map();
+  const localSlotsByItemId = /* @__PURE__ */ new Map();
+  for (const slot of bookedMap.values()) {
+    if (slot.postId) {
+      const arr = lateSlotsByPostId.get(slot.postId) ?? [];
+      arr.push(slot);
+      lateSlotsByPostId.set(slot.postId, arr);
+    }
+    if (slot.itemId) {
+      const arr = localSlotsByItemId.get(slot.itemId) ?? [];
+      arr.push(slot);
+      localSlotsByItemId.set(slot.itemId, arr);
+    }
+  }
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addRef = (platform, scheduledFor) => {
+    if (!scheduledFor) return;
+    const key = `${platform}@${scheduledFor}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    refs.push({ platform, scheduledForMs: normalizeDateTime(scheduledFor) });
+  };
+  for (const item of sameIdeaPosts) {
+    addRef(item.metadata.platform, item.metadata.scheduledFor);
+    if (item.metadata.latePostId) {
+      for (const slot of lateSlotsByPostId.get(item.metadata.latePostId) ?? []) {
+        addRef(slot.platform, slot.scheduledFor);
+      }
+    }
+    for (const slot of localSlotsByItemId.get(item.id) ?? []) {
+      addRef(slot.platform, slot.scheduledFor);
+    }
+  }
+  return refs;
+}
+async function schedulePost(platformConfig, fromMs, isIdeaPost, label, ctx) {
+  const indent = "  ".repeat(ctx.depth);
+  let checked = 0;
+  let skippedBooked = 0;
+  let skippedSpacing = 0;
+  logger_default.debug(`${indent}[schedulePost] Looking for slot for ${label} (idea=${isIdeaPost}) from ${new Date(fromMs).toISOString()}`);
+  for (const { datetime, ms } of generateTimeslots(platformConfig, ctx.timezone, fromMs)) {
+    checked++;
+    const booked = ctx.bookedMap.get(ms);
+    if (!booked) {
+      if (isIdeaPost && ctx.ideaRefs.length > 0 && !passesIdeaSpacing(ms, ctx.platform, ctx.ideaRefs, ctx.samePlatformMs, ctx.crossPlatformMs)) {
+        skippedSpacing++;
+        if (skippedSpacing <= 5 || skippedSpacing % 50 === 0) {
+          logger_default.debug(`${indent}[schedulePost] \u23ED\uFE0F Slot ${datetime} too close to same-idea post \u2014 skipping`);
+        }
+        continue;
+      }
+      logger_default.debug(`${indent}[schedulePost] \u2705 Found empty slot: ${datetime} (checked ${checked} candidates, skipped ${skippedBooked} booked, ${skippedSpacing} spacing)`);
+      return datetime;
+    }
+    if (isIdeaPost && ctx.displacementEnabled && !booked.ideaLinked && booked.source === "late" && booked.postId) {
+      if (ctx.ideaRefs.length > 0 && !passesIdeaSpacing(ms, ctx.platform, ctx.ideaRefs, ctx.samePlatformMs, ctx.crossPlatformMs)) {
+        skippedSpacing++;
+        if (skippedSpacing <= 5 || skippedSpacing % 50 === 0) {
+          logger_default.debug(`${indent}[schedulePost] \u23ED\uFE0F Slot ${datetime} too close to same-idea post \u2014 skipping (even though displaceable)`);
+        }
+        continue;
+      }
+      logger_default.info(`${indent}[schedulePost] \u{1F504} Slot ${datetime} taken by non-idea post ${booked.postId} \u2014 displacing`);
+      const newHome = await schedulePost(
+        platformConfig,
+        ms,
+        false,
+        `displaced:${booked.postId}`,
+        { ...ctx, depth: ctx.depth + 1 }
+      );
+      if (newHome) {
+        if (!ctx.dryRun) {
+          try {
+            await ctx.lateClient.schedulePost(booked.postId, newHome);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger_default.warn(`${indent}[schedulePost] \u26A0\uFE0F Failed to displace ${booked.postId} via Late API: ${msg} \u2014 skipping slot`);
+            continue;
+          }
+        }
+        logger_default.info(`${indent}[schedulePost] \u{1F4E6} Displaced ${booked.postId}: ${datetime} \u2192 ${newHome}`);
+        ctx.bookedMap.delete(ms);
+        const newMs = normalizeDateTime(newHome);
+        ctx.bookedMap.set(newMs, { ...booked, scheduledFor: newHome });
+        logger_default.debug(`${indent}[schedulePost] \u2705 Taking slot: ${datetime} (checked ${checked} candidates)`);
+        return datetime;
+      }
+      logger_default.warn(`${indent}[schedulePost] \u26A0\uFE0F Could not displace ${booked.postId} \u2014 no empty slot found after ${datetime}`);
+    }
+    if (booked.ideaLinked) {
+      skippedBooked++;
+      if (skippedBooked <= 5 || skippedBooked % 50 === 0) {
+        logger_default.debug(`${indent}[schedulePost] \u23ED\uFE0F Slot ${datetime} taken by idea post ${booked.postId ?? booked.itemId} \u2014 skipping`);
+      }
+      continue;
+    }
+    skippedBooked++;
+    if (skippedBooked <= 5 || skippedBooked % 50 === 0) {
+      logger_default.debug(`${indent}[schedulePost] \u23ED\uFE0F Slot ${datetime} taken (${booked.source}/${booked.postId ?? booked.itemId}) \u2014 skipping`);
+    }
+  }
+  logger_default.warn(`[schedulePost] \u274C No slot found for ${label} \u2014 checked ${checked} candidates, skipped ${skippedBooked} booked, ${skippedSpacing} spacing`);
+  return null;
+}
+async function findNextSlot(platform, clipType, options) {
+  const config2 = await loadScheduleConfig();
+  const platformConfig = getPlatformSchedule(platform, clipType);
+  if (!platformConfig) {
+    logger_default.warn(`No schedule config found for platform "${sanitizeLogValue(platform)}"`);
+    return null;
+  }
+  const { timezone } = config2;
+  const nowMs = Date.now();
+  const ideaIds = options?.ideaIds?.filter(Boolean) ?? [];
+  const isIdeaAware = ideaIds.length > 0;
+  const bookedMap = await buildBookedMap(platform);
+  const ideaLinkedPostIds = await getIdeaLinkedLatePostIds();
+  const label = `${platform}/${clipType ?? "default"}`;
+  let ideaRefs = [];
+  let samePlatformMs = 0;
+  let crossPlatformMs = 0;
+  if (isIdeaAware) {
+    const allBookedMap = await buildBookedMap();
+    ideaRefs = await getIdeaReferences(ideaIds, allBookedMap);
+    const spacingConfig = getIdeaSpacingConfig();
+    samePlatformMs = spacingConfig.samePlatformHours * HOUR_MS;
+    crossPlatformMs = spacingConfig.crossPlatformHours * HOUR_MS;
+  }
+  logger_default.info(`[findNextSlot] Scheduling ${label} (idea=${isIdeaAware}, booked=${bookedMap.size} slots, spacingRefs=${ideaRefs.length})`);
+  const ctx = {
+    timezone,
+    bookedMap,
+    ideaLinkedPostIds,
+    lateClient: new LateApiClient(),
+    displacementEnabled: getDisplacementConfig().enabled,
+    dryRun: false,
+    depth: 0,
+    ideaRefs,
+    samePlatformMs,
+    crossPlatformMs,
+    platform
+  };
+  const result = await schedulePost(platformConfig, nowMs, isIdeaAware, label, ctx);
+  if (!result) {
+    logger_default.warn(`[findNextSlot] No available slot for "${sanitizeLogValue(platform)}" within ${MAX_LOOKAHEAD_DAYS} days`);
+  }
+  return result;
+}
+async function getScheduleCalendar(startDate, endDate) {
+  const bookedMap = await buildBookedMap();
+  let filtered = [...bookedMap.values()].filter((slot) => slot.source === "local" || slot.status === "scheduled").map((slot) => ({
+    platform: slot.platform,
+    scheduledFor: slot.scheduledFor,
+    source: slot.source,
+    postId: slot.postId,
+    itemId: slot.itemId
+  }));
+  if (startDate) {
+    const startMs = startDate.getTime();
+    filtered = filtered.filter((slot) => normalizeDateTime(slot.scheduledFor) >= startMs);
+  }
+  if (endDate) {
+    const endMs = endDate.getTime();
+    filtered = filtered.filter((slot) => normalizeDateTime(slot.scheduledFor) <= endMs);
+  }
+  filtered.sort((left, right) => normalizeDateTime(left.scheduledFor) - normalizeDateTime(right.scheduledFor));
+  return filtered;
+}
+
+// src/L3-services/scheduler/realign.ts
 var PLATFORM_ALIASES2 = { twitter: "x" };
 function normalizeSchedulePlatform(platform) {
   return PLATFORM_ALIASES2[platform] ?? platform;
@@ -8035,33 +8349,22 @@ async function fetchAllPosts(client, statuses, platform) {
   }
   return allPosts;
 }
-function generateSlots(platform, clipType, count, bookedMs, timezone) {
-  const schedule = getPlatformSchedule(platform, clipType);
-  if (!schedule || schedule.slots.length === 0) {
-    logger_default.warn(`No schedule slots for ${platform}/${clipType}`);
-    return [];
-  }
-  const available = [];
-  const now = /* @__PURE__ */ new Date();
-  const nowMs = now.getTime();
-  for (let dayOffset = 0; dayOffset < 730 && available.length < count; dayOffset++) {
-    const day = new Date(now);
-    day.setDate(day.getDate() + dayOffset);
-    const dayOfWeek = getDayOfWeekInTimezone(day, timezone);
-    if (schedule.avoidDays.includes(dayOfWeek)) continue;
-    for (const slot of schedule.slots) {
-      if (available.length >= count) break;
-      if (!slot.days.includes(dayOfWeek)) continue;
-      const iso = buildSlotDatetime(day, slot.time, timezone);
-      const ms = new Date(iso).getTime();
-      if (ms <= nowMs) continue;
-      if (!bookedMs.has(ms)) {
-        available.push(iso);
-        bookedMs.add(ms);
-      }
-    }
-  }
-  return available;
+function isOnValidSlot(iso, schedule, timezone) {
+  if (schedule.slots.length === 0) return false;
+  const date = new Date(iso);
+  const dayOfWeek = getDayOfWeekInTimezone(date, timezone);
+  if (schedule.avoidDays.includes(dayOfWeek)) return false;
+  const timeFormatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  const timeParts = timeFormatter.formatToParts(date);
+  const hour = timeParts.find((p) => p.type === "hour")?.value ?? "00";
+  const minute = timeParts.find((p) => p.type === "minute")?.value ?? "00";
+  const timeKey = `${hour}:${minute}`;
+  return schedule.slots.some((slot) => slot.time === timeKey && slot.days.includes(dayOfWeek));
 }
 async function buildRealignPlan(options = {}) {
   const config2 = await loadScheduleConfig();
@@ -8073,9 +8376,8 @@ async function buildRealignPlan(options = {}) {
     return { posts: [], toCancel: [], skipped: 0, unmatched: 0, totalFetched: 0 };
   }
   const { byLatePostId, byContent } = options.clipTypeMaps ?? await buildClipTypeMaps();
-  const grouped = /* @__PURE__ */ new Map();
   let unmatched = 0;
-  let contentMatched = 0;
+  const tagged = [];
   for (const post of allPosts) {
     const platform = post.platforms[0]?.platform;
     if (!platform) continue;
@@ -8083,494 +8385,135 @@ async function buildRealignPlan(options = {}) {
     if (!clipType && post.content) {
       const contentKey = `${platform}::${normalizeContent(post.content)}`;
       clipType = byContent.get(contentKey) ?? null;
-      if (clipType) contentMatched++;
     }
     if (!clipType) {
       clipType = "short";
       unmatched++;
     }
-    const key = `${platform}::${clipType}`;
-    if (!grouped.has(key)) grouped.set(key, []);
-    grouped.get(key).push({ post, platform, clipType });
-  }
-  const bookedMs = /* @__PURE__ */ new Set();
-  if (contentMatched > 0) {
-    logger_default.info(`${contentMatched} post(s) matched by content fallback (no latePostId)`);
+    tagged.push({ post, platform, clipType });
   }
-  const result = [];
-  const toCancel = [];
-  let skipped = 0;
-  for (const [key, posts] of grouped) {
-    const [platform, clipType] = key.split("::");
-    const schedulePlatform = normalizeSchedulePlatform(platform);
-    const schedule = getPlatformSchedule(schedulePlatform, clipType);
-    const hasSlots = schedule && schedule.slots.length > 0;
-    if (!hasSlots) {
-      for (const { post, clipType: ct } of posts) {
-        if (post.status === "cancelled") continue;
-        toCancel.push({
-          post,
-          platform,
-          clipType: ct,
-          reason: `No schedule slots for ${schedulePlatform}/${clipType}`
-        });
-      }
-      continue;
-    }
-    posts.sort((a, b) => {
-      const aTime = a.post.scheduledFor ? new Date(a.post.scheduledFor).getTime() : Infinity;
-      const bTime = b.post.scheduledFor ? new Date(b.post.scheduledFor).getTime() : Infinity;
-      return aTime - bTime;
-    });
-    const slots = generateSlots(schedulePlatform, clipType, posts.length, bookedMs, timezone);
-    for (let i = 0; i < posts.length; i++) {
-      const { post } = posts[i];
-      const newSlot = slots[i];
-      if (!newSlot) {
-        if (post.status !== "cancelled") {
-          toCancel.push({
-            post,
-            platform,
-            clipType: posts[i].clipType,
-            reason: `No more available slots for ${schedulePlatform}/${clipType}`
-          });
-        }
-        continue;
-      }
-      const currentMs = post.scheduledFor ? new Date(post.scheduledFor).getTime() : 0;
-      const newMs = new Date(newSlot).getTime();
-      if (currentMs === newMs && post.status === "scheduled") {
-        skipped++;
-        continue;
-      }
-      result.push({
-        post,
-        platform,
-        clipType: posts[i].clipType,
-        oldScheduledFor: post.scheduledFor ?? null,
-        newScheduledFor: newSlot
-      });
-    }
-  }
-  result.sort((a, b) => new Date(a.newScheduledFor).getTime() - new Date(b.newScheduledFor).getTime());
-  return { posts: result, toCancel, skipped, unmatched, totalFetched: allPosts.length };
-}
-async function executeRealignPlan(plan, onProgress) {
-  const client = new LateApiClient();
-  let updated = 0;
-  let cancelled = 0;
-  let failed = 0;
-  const errors = [];
-  const totalOps = plan.toCancel.length + plan.posts.length;
-  let completed = 0;
-  for (const entry of plan.toCancel) {
-    completed++;
-    try {
-      await client.updatePost(entry.post._id, { status: "cancelled" });
-      cancelled++;
-      const preview = entry.post.content.slice(0, 40).replace(/\n/g, " ");
-      logger_default.info(`[${completed}/${totalOps}] \u{1F6AB} Cancelled ${entry.platform}/${entry.clipType}: "${preview}..."`);
-      onProgress?.(completed, totalOps, "cancelling");
-      await new Promise((r) => setTimeout(r, 300));
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      errors.push({ postId: entry.post._id, error: msg });
-      failed++;
-      logger_default.error(`[${completed}/${totalOps}] \u274C Failed to cancel ${entry.post._id}: ${msg}`);
-    }
-  }
-  for (const entry of plan.posts) {
-    completed++;
-    try {
-      await client.schedulePost(entry.post._id, entry.newScheduledFor);
-      updated++;
-      const preview = entry.post.content.slice(0, 40).replace(/\n/g, " ");
-      logger_default.info(`[${completed}/${totalOps}] \u2705 ${entry.platform}/${entry.clipType}: "${preview}..." \u2192 ${entry.newScheduledFor}`);
-      onProgress?.(completed, totalOps, "updating");
-      await new Promise((r) => setTimeout(r, 300));
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      errors.push({ postId: entry.post._id, error: msg });
-      failed++;
-      logger_default.error(`[${completed}/${totalOps}] \u274C Failed to update ${entry.post._id}: ${msg}`);
-    }
-  }
-  return { updated, cancelled, failed, errors };
-}
-
-// src/L3-services/scheduler/scheduler.ts
-init_configLogger();
-function normalizeDateTime(isoString) {
-  return new Date(isoString).getTime();
-}
-var CHUNK_DAYS = 14;
-var MAX_LOOKAHEAD_DAYS = 730;
-var DEFAULT_IDEA_WINDOW_DAYS = 14;
-var DAY_MS = 24 * 60 * 60 * 1e3;
-var HOUR_MS = 60 * 60 * 1e3;
-function sanitizeLogValue(value) {
-  return value.replace(/[\r\n]/g, "");
-}
-function getTimezoneOffset2(timezone, date) {
-  const formatter = new Intl.DateTimeFormat("en-US", {
-    timeZone: timezone,
-    timeZoneName: "longOffset"
-  });
-  const parts = formatter.formatToParts(date);
-  const tzPart = parts.find((part) => part.type === "timeZoneName");
-  const match = tzPart?.value?.match(/GMT([+-]\d{2}:\d{2})/);
-  if (match) return match[1];
-  if (tzPart?.value === "GMT") return "+00:00";
-  logger_default.warn(
-    `Could not parse timezone offset for timezone "${timezone}" on date "${date.toISOString()}". Raw timeZoneName part: "${tzPart?.value ?? "undefined"}". Falling back to UTC (+00:00).`
-  );
-  return "+00:00";
-}
-function buildSlotDatetime2(date, time, timezone) {
-  const formatter = new Intl.DateTimeFormat("en-US", {
-    timeZone: timezone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit"
-  });
-  const parts = formatter.formatToParts(date);
-  const yearPart = parts.find((part) => part.type === "year")?.value;
-  const monthPart = parts.find((part) => part.type === "month")?.value;
-  const dayPart = parts.find((part) => part.type === "day")?.value;
-  const year = yearPart ?? String(date.getFullYear());
-  const month = (monthPart ?? String(date.getMonth() + 1)).padStart(2, "0");
-  const day = (dayPart ?? String(date.getDate())).padStart(2, "0");
-  const offset = getTimezoneOffset2(timezone, date);
-  return `${year}-${month}-${day}T${time}:00${offset}`;
-}
-function getDayOfWeekInTimezone2(date, timezone) {
-  const formatter = new Intl.DateTimeFormat("en-US", {
-    timeZone: timezone,
-    weekday: "short"
-  });
-  const short = formatter.format(date).toLowerCase().slice(0, 3);
-  const map = {
-    sun: "sun",
-    mon: "mon",
-    tue: "tue",
-    wed: "wed",
-    thu: "thu",
-    fri: "fri",
-    sat: "sat"
-  };
-  return map[short] ?? "mon";
-}
-async function fetchScheduledPostsSafe(platform) {
-  try {
-    const client = new LateApiClient();
-    return await client.getScheduledPosts(platform);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logger_default.warn(`Late API unreachable, using local data only: ${msg}`);
-    return [];
-  }
-}
-async function buildBookedSlots(platform) {
-  const [latePosts, publishedItems] = await Promise.all([
-    fetchScheduledPostsSafe(platform),
-    getPublishedItems()
-  ]);
-  const slots = [];
-  for (const post of latePosts) {
-    if (!post.scheduledFor) continue;
-    for (const scheduledPlatform of post.platforms) {
-      if (!platform || scheduledPlatform.platform === platform) {
-        slots.push({
-          scheduledFor: post.scheduledFor,
-          source: "late",
-          postId: post._id,
-          platform: scheduledPlatform.platform,
-          status: post.status
-        });
-      }
-    }
-  }
-  for (const item of publishedItems) {
-    if (platform && item.metadata.platform !== platform) continue;
-    if (!item.metadata.scheduledFor) continue;
-    slots.push({
-      scheduledFor: item.metadata.scheduledFor,
-      source: "local",
-      itemId: item.id,
-      platform: item.metadata.platform
-    });
-  }
-  return slots;
-}
-function buildIdeaReferences(sameIdeaPosts, allBookedSlots) {
-  const lateSlotsByPostId = /* @__PURE__ */ new Map();
-  const localSlotsByItemId = /* @__PURE__ */ new Map();
-  for (const slot of allBookedSlots) {
-    if (slot.postId) {
-      const slots = lateSlotsByPostId.get(slot.postId) ?? [];
-      slots.push(slot);
-      lateSlotsByPostId.set(slot.postId, slots);
-    }
-    if (slot.itemId) {
-      const slots = localSlotsByItemId.get(slot.itemId) ?? [];
-      slots.push(slot);
-      localSlotsByItemId.set(slot.itemId, slots);
-    }
-  }
-  const references = [];
-  const seen = /* @__PURE__ */ new Set();
-  const addReference = (platformName, scheduledFor) => {
-    if (!scheduledFor) return;
-    const key = `${platformName}@${scheduledFor}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    references.push({ platform: platformName, scheduledFor });
-  };
-  for (const item of sameIdeaPosts) {
-    addReference(item.metadata.platform, item.metadata.scheduledFor);
-    if (item.metadata.latePostId) {
-      for (const slot of lateSlotsByPostId.get(item.metadata.latePostId) ?? []) {
-        addReference(slot.platform, slot.scheduledFor);
-      }
-    }
-    for (const slot of localSlotsByItemId.get(item.id) ?? []) {
-      addReference(slot.platform, slot.scheduledFor);
+  const bookedMap = await buildBookedMap();
+  const ctx = {
+    timezone,
+    bookedMap,
+    ideaLinkedPostIds: /* @__PURE__ */ new Set(),
+    lateClient: client,
+    displacementEnabled: getDisplacementConfig().enabled,
+    dryRun: true,
+    depth: 0,
+    ideaRefs: [],
+    samePlatformMs: 0,
+    crossPlatformMs: 0,
+    platform: ""
+  };
+  for (const [, slot] of bookedMap) {
+    if (slot.ideaLinked && slot.postId) {
+      ctx.ideaLinkedPostIds.add(slot.postId);
     }
   }
-  return references;
-}
-function createSpacingGuard(ideaReferences, samePlatformHours, crossPlatformHours) {
-  const samePlatformWindowMs = samePlatformHours * HOUR_MS;
-  const crossPlatformWindowMs = crossPlatformHours * HOUR_MS;
-  return (candidateMs, candidatePlatform) => {
-    for (const reference of ideaReferences) {
-      const referenceMs = normalizeDateTime(reference.scheduledFor);
-      const diff = Math.abs(candidateMs - referenceMs);
-      if (reference.platform === candidatePlatform && diff < samePlatformWindowMs) {
-        return false;
+  const result = [];
+  const toCancel = [];
+  let skipped = 0;
+  tagged.sort((a, b) => {
+    const aIdea = ctx.ideaLinkedPostIds.has(a.post._id) ? 0 : 1;
+    const bIdea = ctx.ideaLinkedPostIds.has(b.post._id) ? 0 : 1;
+    return aIdea - bIdea;
+  });
+  const nowMs = Date.now();
+  for (const { post, platform, clipType } of tagged) {
+    const schedulePlatform = normalizeSchedulePlatform(platform);
+    const platformConfig = getPlatformSchedule(schedulePlatform, clipType);
+    if (!platformConfig || platformConfig.slots.length === 0) {
+      if (post.status !== "cancelled") {
+        toCancel.push({ post, platform, clipType, reason: `No schedule slots for ${schedulePlatform}/${clipType}` });
       }
-      if (diff < crossPlatformWindowMs) {
-        return false;
+      continue;
+    }
+    if (post.scheduledFor && post.status === "scheduled" && isOnValidSlot(post.scheduledFor, platformConfig, timezone)) {
+      skipped++;
+      continue;
+    }
+    if (post.scheduledFor) {
+      const currentMs2 = new Date(post.scheduledFor).getTime();
+      const currentBooked = bookedMap.get(currentMs2);
+      if (currentBooked?.postId === post._id) {
+        bookedMap.delete(currentMs2);
       }
     }
-    return true;
-  };
-}
-function resolveSearchWindow(nowMs, options) {
-  const defaultWindowEndMs = nowMs + DEFAULT_IDEA_WINDOW_DAYS * DAY_MS;
-  const publishBy = options?.publishBy;
-  if (!publishBy) {
-    return {
-      emptyWindowEndMs: defaultWindowEndMs,
-      displacementWindowEndMs: defaultWindowEndMs
-    };
-  }
-  const publishByMs = normalizeDateTime(publishBy);
-  if (Number.isNaN(publishByMs)) {
-    logger_default.warn(`Invalid publishBy "${sanitizeLogValue(publishBy)}" provided; scheduling normally without urgency bias`);
-    return {};
-  }
-  const daysUntilPublishBy = (publishByMs - nowMs) / DAY_MS;
-  if (daysUntilPublishBy <= 0) {
-    logger_default.warn(`publishBy "${sanitizeLogValue(publishBy)}" has already passed; scheduling normally without urgency bias`);
-    return {};
-  }
-  if (daysUntilPublishBy < 3) {
-    logger_default.debug(`Urgent publishBy "${sanitizeLogValue(publishBy)}"; prioritizing earliest displaceable slot`);
-  }
-  return {
-    emptyWindowEndMs: publishByMs,
-    displacementWindowEndMs: daysUntilPublishBy < 7 ? Math.min(publishByMs, nowMs + 3 * DAY_MS) : publishByMs
-  };
-}
-function findEmptySlot({
-  platformConfig,
-  timezone,
-  bookedDatetimes,
-  platform,
-  searchFromMs,
-  includeSearchDay = false,
-  maxCandidateMs,
-  passesCandidate
-}) {
-  if (maxCandidateMs !== void 0 && maxCandidateMs < searchFromMs) {
-    return null;
-  }
-  const baseDate = new Date(searchFromMs);
-  const initialOffset = includeSearchDay ? 0 : 1;
-  let maxDayOffset = MAX_LOOKAHEAD_DAYS;
-  if (maxCandidateMs !== void 0) {
-    maxDayOffset = Math.min(
-      MAX_LOOKAHEAD_DAYS,
-      Math.max(initialOffset, Math.ceil((maxCandidateMs - searchFromMs) / DAY_MS))
-    );
-  }
-  let startOffset = initialOffset;
-  while (startOffset <= maxDayOffset) {
-    const endOffset = Math.min(startOffset + CHUNK_DAYS - 1, maxDayOffset);
-    const candidates = [];
-    for (let dayOffset = startOffset; dayOffset <= endOffset; dayOffset++) {
-      const candidateDate = new Date(baseDate);
-      candidateDate.setDate(candidateDate.getDate() + dayOffset);
-      const dayOfWeek = getDayOfWeekInTimezone2(candidateDate, timezone);
-      if (platformConfig.avoidDays.includes(dayOfWeek)) continue;
-      for (const slot of platformConfig.slots) {
-        if (!slot.days.includes(dayOfWeek)) continue;
-        const candidate = buildSlotDatetime2(candidateDate, slot.time, timezone);
-        const candidateMs = normalizeDateTime(candidate);
-        if (candidateMs <= searchFromMs) continue;
-        if (maxCandidateMs !== void 0 && candidateMs > maxCandidateMs) continue;
-        if (bookedDatetimes.has(candidateMs)) continue;
-        if (passesCandidate && !passesCandidate(candidateMs, platform)) continue;
-        candidates.push(candidate);
-      }
-    }
-    candidates.sort((left, right) => normalizeDateTime(left) - normalizeDateTime(right));
-    if (candidates.length > 0) {
-      return candidates[0];
-    }
-    startOffset = endOffset + 1;
-  }
-  return null;
-}
-async function tryDisplacement({
-  bookedSlots,
-  platform,
-  platformConfig,
-  timezone,
-  bookedDatetimes,
-  options,
-  nowMs,
-  maxCandidateMs,
-  passesSpacing
-}) {
-  const displacementConfig = getDisplacementConfig();
-  if (!displacementConfig.enabled || !options.ideaIds?.length) {
-    return null;
-  }
-  const candidateSlots = bookedSlots.filter((slot) => {
-    const slotMs = normalizeDateTime(slot.scheduledFor);
-    if (slotMs <= nowMs) return false;
-    if (maxCandidateMs !== void 0 && slotMs > maxCandidateMs) return false;
-    return true;
-  }).sort((left, right) => normalizeDateTime(left.scheduledFor) - normalizeDateTime(right.scheduledFor));
-  const lateClient = new LateApiClient();
-  const publishedItemCache = /* @__PURE__ */ new Map();
-  for (const slot of candidateSlots) {
-    if (slot.source !== "late" || !slot.postId) continue;
-    const candidateMs = normalizeDateTime(slot.scheduledFor);
-    if (passesSpacing && !passesSpacing(candidateMs, platform)) continue;
-    let publishedItem = publishedItemCache.get(slot.postId);
-    if (publishedItem === void 0) {
-      publishedItem = await getPublishedItemByLatePostId(slot.postId);
-      publishedItemCache.set(slot.postId, publishedItem);
-    }
-    if (!publishedItem) {
+    const isIdea = ctx.ideaLinkedPostIds.has(post._id);
+    const label = `${schedulePlatform}/${clipType}:${post._id.slice(-6)}`;
+    const newSlot = await schedulePost(platformConfig, nowMs, isIdea, label, ctx);
+    if (!newSlot) {
+      if (post.status !== "cancelled") {
+        toCancel.push({ post, platform, clipType, reason: `No available slot for ${schedulePlatform}/${clipType}` });
+      }
       continue;
     }
-    if (publishedItem.metadata.ideaIds?.length) {
+    const newMs = new Date(newSlot).getTime();
+    ctx.bookedMap.set(newMs, {
+      scheduledFor: newSlot,
+      source: "late",
+      postId: post._id,
+      platform: schedulePlatform,
+      ideaLinked: isIdea
+    });
+    const currentMs = post.scheduledFor ? new Date(post.scheduledFor).getTime() : 0;
+    if (currentMs === newMs && post.status === "scheduled") {
+      skipped++;
       continue;
     }
-    const displacedPlatformConfig = publishedItem?.metadata.clipType ? getPlatformSchedule(platform, publishedItem.metadata.clipType) ?? platformConfig : platformConfig;
-    const newSlot = findEmptySlot({
-      platformConfig: displacedPlatformConfig,
-      timezone,
-      bookedDatetimes,
+    result.push({
+      post,
       platform,
-      searchFromMs: candidateMs,
-      includeSearchDay: true
+      clipType,
+      oldScheduledFor: post.scheduledFor ?? null,
+      newScheduledFor: newSlot
     });
-    if (!newSlot) continue;
-    await lateClient.schedulePost(slot.postId, newSlot);
-    logger_default.info(
-      `Displaced post ${sanitizeLogValue(slot.postId)} from ${sanitizeLogValue(slot.scheduledFor)} to ${sanitizeLogValue(newSlot)} for idea-linked content`
-    );
-    return {
-      slot: slot.scheduledFor,
-      displaced: {
-        postId: slot.postId,
-        originalSlot: slot.scheduledFor,
-        newSlot
-      }
-    };
   }
-  return null;
+  result.sort((a, b) => new Date(a.newScheduledFor).getTime() - new Date(b.newScheduledFor).getTime());
+  return { posts: result, toCancel, skipped, unmatched, totalFetched: allPosts.length };
 }
-async function findNextSlot(platform, clipType, options) {
-  const config2 = await loadScheduleConfig();
-  const platformConfig = getPlatformSchedule(platform, clipType);
-  if (!platformConfig) {
-    logger_default.warn(`No schedule config found for platform "${sanitizeLogValue(platform)}"`);
-    return null;
-  }
-  const ideaIds = options?.ideaIds?.filter(Boolean) ?? [];
-  const isIdeaAware = ideaIds.length > 0;
-  const nowMs = Date.now();
-  const { timezone } = config2;
-  const [allBookedSlots, sameIdeaPosts] = await Promise.all([
-    isIdeaAware ? buildBookedSlots() : Promise.resolve([]),
-    isIdeaAware ? getScheduledItemsByIdeaIds(ideaIds) : Promise.resolve([])
-  ]);
-  const bookedSlots = isIdeaAware ? allBookedSlots.filter((slot) => slot.platform === platform) : await buildBookedSlots(platform);
-  const bookedDatetimes = new Set(bookedSlots.map((slot) => normalizeDateTime(slot.scheduledFor)));
-  const spacingConfig = isIdeaAware ? getIdeaSpacingConfig() : null;
-  const spacingGuard = spacingConfig ? createSpacingGuard(
-    buildIdeaReferences(sameIdeaPosts, allBookedSlots),
-    spacingConfig.samePlatformHours,
-    spacingConfig.crossPlatformHours
-  ) : void 0;
-  const searchWindow = isIdeaAware ? resolveSearchWindow(nowMs, options) : {};
-  const emptySlot = findEmptySlot({
-    platformConfig,
-    timezone,
-    bookedDatetimes,
-    platform,
-    searchFromMs: nowMs,
-    maxCandidateMs: searchWindow.emptyWindowEndMs,
-    passesCandidate: spacingGuard
-  });
-  if (emptySlot) {
-    logger_default.debug(`Found available slot for ${sanitizeLogValue(platform)}: ${sanitizeLogValue(emptySlot)}`);
-    return emptySlot;
-  }
-  if (isIdeaAware) {
-    const displaced = await tryDisplacement({
-      bookedSlots,
-      platform,
-      platformConfig,
-      timezone,
-      bookedDatetimes,
-      options: { ...options, ideaIds },
-      nowMs,
-      maxCandidateMs: searchWindow.displacementWindowEndMs,
-      passesSpacing: spacingGuard
-    });
-    if (displaced) {
-      return displaced.slot;
+async function executeRealignPlan(plan, onProgress) {
+  const client = new LateApiClient();
+  let updated = 0;
+  let cancelled = 0;
+  let failed = 0;
+  const errors = [];
+  const totalOps = plan.toCancel.length + plan.posts.length;
+  let completed = 0;
+  for (const entry of plan.toCancel) {
+    completed++;
+    try {
+      await client.updatePost(entry.post._id, { status: "cancelled" });
+      cancelled++;
+      const preview = entry.post.content.slice(0, 40).replace(/\n/g, " ");
+      logger_default.info(`[${completed}/${totalOps}] \u{1F6AB} Cancelled ${entry.platform}/${entry.clipType}: "${preview}..."`);
+      onProgress?.(completed, totalOps, "cancelling");
+      await new Promise((r) => setTimeout(r, 300));
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push({ postId: entry.post._id, error: msg });
+      failed++;
+      logger_default.error(`[${completed}/${totalOps}] \u274C Failed to cancel ${entry.post._id}: ${msg}`);
     }
   }
-  logger_default.warn(`No available slot found for "${sanitizeLogValue(platform)}" within ${MAX_LOOKAHEAD_DAYS} days`);
-  return null;
-}
-async function getScheduleCalendar(startDate, endDate) {
-  const slots = await buildBookedSlots();
-  let filtered = slots.filter((slot) => slot.source === "local" || slot.status === "scheduled").map((slot) => ({
-    platform: slot.platform,
-    scheduledFor: slot.scheduledFor,
-    source: slot.source,
-    postId: slot.postId,
-    itemId: slot.itemId
-  }));
-  if (startDate) {
-    const startMs = startDate.getTime();
-    filtered = filtered.filter((slot) => normalizeDateTime(slot.scheduledFor) >= startMs);
-  }
-  if (endDate) {
-    const endMs = endDate.getTime();
-    filtered = filtered.filter((slot) => normalizeDateTime(slot.scheduledFor) <= endMs);
+  for (const entry of plan.posts) {
+    completed++;
+    try {
+      await client.schedulePost(entry.post._id, entry.newScheduledFor);
+      updated++;
+      const preview = entry.post.content.slice(0, 40).replace(/\n/g, " ");
+      logger_default.info(`[${completed}/${totalOps}] \u2705 ${entry.platform}/${entry.clipType}: "${preview}..." \u2192 ${entry.newScheduledFor}`);
+      onProgress?.(completed, totalOps, "updating");
+      await new Promise((r) => setTimeout(r, 300));
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push({ postId: entry.post._id, error: msg });
+      failed++;
+      logger_default.error(`[${completed}/${totalOps}] \u274C Failed to update ${entry.post._id}: ${msg}`);
+    }
   }
-  filtered.sort((left, right) => normalizeDateTime(left.scheduledFor) - normalizeDateTime(right.scheduledFor));
-  return filtered;
+  return { updated, cancelled, failed, errors };
 }
 
 // src/L2-clients/ffmpeg/audioExtraction.ts
@@ -10079,6 +10022,9 @@ function platformAcceptsMedia(platform, clipType) {
   return getMediaRule(platform, clipType) !== null;
 }
 
+// src/L3-services/queueBuilder/queueBuilder.ts
+init_postStore();
+
 // src/L1-infra/image/image.ts
 import { default as default7 } from "sharp";
 
@@ -10577,6 +10523,10 @@ function getWhisperPrompt() {
   const brand = getBrandConfig();
   return brand.customVocabulary.join(", ");
 }
+function getIntroOutroConfig() {
+  const brand = getBrandConfig();
+  return brand.introOutro ?? { enabled: false, fadeDuration: 0 };
+}
 
 // src/L4-agents/IdeationAgent.ts
 init_environment();
@@ -10766,7 +10716,7 @@ function buildSystemPrompt(brand, existingIdeas, seedTopics, count, ideaRepo) {
   }
   return promptSections.join("\n");
 }
-function buildUserMessage(count, seedTopics, hasMcpServers) {
+function buildUserMessage(count, seedTopics, hasMcpServers, userPrompt) {
   const focusText = seedTopics.length > 0 ? `Focus areas: ${seedTopics.join(", ")}` : "Focus areas: choose the strongest timely opportunities from the creator context and current trends.";
   const steps = [
     "1. Call get_brand_context to load the creator profile.",
@@ -10790,13 +10740,15 @@ function buildUserMessage(count, seedTopics, hasMcpServers) {
       "5. Call finalize_ideas when done."
     );
   }
-  return [
+  const sections = [
     `Generate ${count} new content ideas.`,
-    focusText,
-    "",
-    "Follow this exact workflow:",
-    ...steps
-  ].join("\n");
+    focusText
+  ];
+  if (userPrompt) {
+    sections.push("", `## User Prompt`, userPrompt);
+  }
+  sections.push("", "Follow this exact workflow:", ...steps);
+  return sections.join("\n");
 }
 async function loadBrandContext(brandPath) {
   if (!brandPath) {
@@ -11313,7 +11265,7 @@ async function generateIdeas(options = {}) {
   });
   try {
     const hasMcpServers = !!(config2.EXA_API_KEY || config2.YOUTUBE_API_KEY || config2.PERPLEXITY_API_KEY);
-    const userMessage = buildUserMessage(count, seedTopics, hasMcpServers);
+    const userMessage = buildUserMessage(count, seedTopics, hasMcpServers, options.prompt);
     await agent.run(userMessage);
     const ideas = agent.getGeneratedIdeas();
     if (!agent.isFinalized()) {
@@ -11443,6 +11395,290 @@ var Asset = class {
 init_paths();
 init_fileSystem();
 
+// src/L2-clients/ffmpeg/videoConcat.ts
+init_fileSystem();
+init_paths();
+init_configLogger();
+async function concatVideos(segments, output, opts = {}) {
+  if (segments.length === 0) {
+    throw new Error("concatVideos: no segments provided");
+  }
+  if (segments.length === 1) {
+    await ensureDirectory(dirname(output));
+    await execCommand(getFFmpegPath(), [
+      "-y",
+      "-i",
+      segments[0],
+      "-c",
+      "copy",
+      output
+    ], { maxBuffer: 50 * 1024 * 1024 });
+    return output;
+  }
+  const fadeDuration = opts.fadeDuration ?? 0;
+  if (fadeDuration > 0) {
+    return concatWithXfade(segments, output, fadeDuration);
+  }
+  return concatWithDemuxer(segments, output);
+}
+async function concatWithDemuxer(segments, output) {
+  await ensureDirectory(dirname(output));
+  const listContent = segments.map((s) => `file '${s.replace(/'/g, "'\\''")}'`).join("\n");
+  const listPath = output + ".concat-list.txt";
+  await writeTextFile(listPath, listContent);
+  logger_default.info(`Concat (demuxer): ${segments.length} segments \u2192 ${output}`);
+  await execCommand(getFFmpegPath(), [
+    "-y",
+    "-f",
+    "concat",
+    "-safe",
+    "0",
+    "-i",
+    listPath,
+    "-c",
+    "copy",
+    "-movflags",
+    "+faststart",
+    output
+  ], { maxBuffer: 50 * 1024 * 1024 });
+  return output;
+}
+async function concatWithXfade(segments, output, fadeDuration) {
+  await ensureDirectory(dirname(output));
+  logger_default.info(`Concat (xfade ${fadeDuration}s): ${segments.length} segments \u2192 ${output}`);
+  const durations = await Promise.all(segments.map((s) => getVideoDuration2(s)));
+  const inputs = segments.flatMap((s) => ["-i", s]);
+  const filterParts = [];
+  for (let i = 0; i < segments.length; i++) {
+    filterParts.push(`[${i}:v]fps=30,settb=AVTB,setpts=PTS-STARTPTS[vin${i}]`);
+    filterParts.push(`[${i}:a]aresample=async=1,asetpts=PTS-STARTPTS[ain${i}]`);
+  }
+  let prevLabel = "[vin0]";
+  let prevAudioLabel = "[ain0]";
+  let cumulativeOffset = 0;
+  for (let i = 1; i < segments.length; i++) {
+    const offset = cumulativeOffset + durations[i - 1] - fadeDuration;
+    const outLabel = i < segments.length - 1 ? `[v${i}]` : "[vout]";
+    const outAudioLabel = i < segments.length - 1 ? `[a${i}]` : "[aout]";
+    filterParts.push(
+      `${prevLabel}[vin${i}]xfade=transition=fade:duration=${fadeDuration}:offset=${offset.toFixed(3)}${outLabel}`
+    );
+    filterParts.push(
+      `${prevAudioLabel}[ain${i}]acrossfade=d=${fadeDuration}${outAudioLabel}`
+    );
+    prevLabel = outLabel;
+    prevAudioLabel = outAudioLabel;
+    cumulativeOffset = offset;
+  }
+  const filterComplex = filterParts.join(";");
+  await execCommand(getFFmpegPath(), [
+    "-y",
+    ...inputs,
+    "-filter_complex",
+    filterComplex,
+    "-map",
+    "[vout]",
+    "-map",
+    "[aout]",
+    "-c:v",
+    "libx264",
+    "-pix_fmt",
+    "yuv420p",
+    "-preset",
+    "ultrafast",
+    "-crf",
+    "23",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "128k",
+    "-movflags",
+    "+faststart",
+    output
+  ], { maxBuffer: 50 * 1024 * 1024 });
+  return output;
+}
+async function normalizeForConcat(videoPath, referenceVideo, output) {
+  await ensureDirectory(dirname(output));
+  const refProps = await getVideoProperties(referenceVideo);
+  logger_default.info(`Normalizing ${videoPath} to match ${referenceVideo} (${refProps.width}x${refProps.height} ${refProps.fps}fps)`);
+  await execCommand(getFFmpegPath(), [
+    "-y",
+    "-i",
+    videoPath,
+    "-vf",
+    `scale=${refProps.width}:${refProps.height}:force_original_aspect_ratio=decrease,pad=${refProps.width}:${refProps.height}:(ow-iw)/2:(oh-ih)/2,fps=${refProps.fps}`,
+    "-c:v",
+    "libx264",
+    "-pix_fmt",
+    "yuv420p",
+    "-preset",
+    "ultrafast",
+    "-crf",
+    "23",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "128k",
+    "-ar",
+    "48000",
+    "-ac",
+    "2",
+    "-movflags",
+    "+faststart",
+    output
+  ], { maxBuffer: 50 * 1024 * 1024 });
+  return output;
+}
+async function getVideoDuration2(videoPath) {
+  const { stdout } = await execCommand(getFFprobePath(), [
+    "-v",
+    "error",
+    "-show_entries",
+    "format=duration",
+    "-of",
+    "csv=p=0",
+    videoPath
+  ], { timeout: 1e4 });
+  const duration = parseFloat(stdout.trim());
+  if (!isFinite(duration) || duration <= 0) {
+    throw new Error(`Failed to get duration for ${videoPath}: ${stdout.trim()}`);
+  }
+  return duration;
+}
+async function getVideoProperties(videoPath) {
+  const { stdout } = await execCommand(getFFprobePath(), [
+    "-v",
+    "error",
+    "-select_streams",
+    "v:0",
+    "-show_entries",
+    "stream=width,height,r_frame_rate",
+    "-of",
+    "json",
+    videoPath
+  ], { timeout: 1e4 });
+  const data = JSON.parse(stdout);
+  const stream = data.streams?.[0];
+  if (!stream) throw new Error(`No video stream found in ${videoPath}`);
+  const fpsRaw = stream.r_frame_rate ?? "30/1";
+  const fpsParts = fpsRaw.split("/");
+  const fps = fpsParts.length === 2 ? Math.round(parseInt(fpsParts[0]) / parseInt(fpsParts[1])) : 30;
+  return {
+    width: stream.width,
+    height: stream.height,
+    fps: isFinite(fps) && fps > 0 ? fps : 30
+  };
+}
+
+// src/L3-services/introOutro/introOutroService.ts
+init_fileSystem();
+init_paths();
+init_environment();
+init_configLogger();
+
+// src/L0-pure/introOutro/introOutroResolver.ts
+function resolveIntroOutroToggle(config2, videoType, platform) {
+  const globalDefault = { intro: config2.enabled, outro: config2.enabled };
+  const videoTypeRule = config2.rules?.[videoType];
+  const baseToggle = videoTypeRule ? { intro: videoTypeRule.intro, outro: videoTypeRule.outro } : globalDefault;
+  if (!platform || !config2.platformOverrides?.[platform]?.[videoType]) {
+    return baseToggle;
+  }
+  const platformRule = config2.platformOverrides[platform][videoType];
+  return {
+    intro: platformRule.intro ?? baseToggle.intro,
+    outro: platformRule.outro ?? baseToggle.outro
+  };
+}
+function resolveIntroPath(config2, platform, aspectRatio) {
+  if (!config2.intro) return null;
+  if (aspectRatio && config2.intro.aspectRatios?.[aspectRatio]) {
+    return config2.intro.aspectRatios[aspectRatio];
+  }
+  if (platform && config2.intro.platforms?.[platform]) {
+    return config2.intro.platforms[platform];
+  }
+  return config2.intro.default ?? null;
+}
+function resolveOutroPath(config2, platform, aspectRatio) {
+  if (!config2.outro) return null;
+  if (aspectRatio && config2.outro.aspectRatios?.[aspectRatio]) {
+    return config2.outro.aspectRatios[aspectRatio];
+  }
+  if (platform && config2.outro.platforms?.[platform]) {
+    return config2.outro.platforms[platform];
+  }
+  return config2.outro.default ?? null;
+}
+
+// src/L3-services/introOutro/introOutroService.ts
+async function applyIntroOutro(videoPath, videoType, outputPath, platform, aspectRatio) {
+  const envConfig = getConfig();
+  if (envConfig.SKIP_INTRO_OUTRO) {
+    logger_default.debug("Intro/outro skipped via SKIP_INTRO_OUTRO");
+    return videoPath;
+  }
+  const config2 = getIntroOutroConfig();
+  if (!config2.enabled) {
+    logger_default.debug("Intro/outro disabled in brand config");
+    return videoPath;
+  }
+  const toggle = resolveIntroOutroToggle(config2, videoType, platform);
+  if (!toggle.intro && !toggle.outro) {
+    logger_default.debug(`Intro/outro both disabled for ${videoType}${platform ? ` / ${platform}` : ""}`);
+    return videoPath;
+  }
+  const brandPath = envConfig.BRAND_PATH;
+  const brandDir = dirname(brandPath);
+  const introRelative = toggle.intro ? resolveIntroPath(config2, platform, aspectRatio) : null;
+  const outroRelative = toggle.outro ? resolveOutroPath(config2, platform, aspectRatio) : null;
+  const introPath = introRelative ? resolve(brandDir, introRelative) : null;
+  const outroPath = outroRelative ? resolve(brandDir, outroRelative) : null;
+  const introExists = introPath ? await fileExists(introPath) : false;
+  const outroExists = outroPath ? await fileExists(outroPath) : false;
+  if (introPath && !introExists) {
+    logger_default.warn(`Intro video not found: ${introPath} \u2014 skipping intro`);
+  }
+  if (outroPath && !outroExists) {
+    logger_default.warn(`Outro video not found: ${outroPath} \u2014 skipping outro`);
+  }
+  const validIntro = introPath && introExists ? introPath : null;
+  const validOutro = outroPath && outroExists ? outroPath : null;
+  if (!validIntro && !validOutro) {
+    logger_default.debug("No valid intro/outro files found \u2014 skipping");
+    return videoPath;
+  }
+  const videoDir = dirname(outputPath);
+  const segments = [];
+  const normalizedIntroPath = validIntro ? join(videoDir, ".intro-normalized.mp4") : null;
+  const normalizedOutroPath = validOutro ? join(videoDir, ".outro-normalized.mp4") : null;
+  try {
+    if (validIntro && normalizedIntroPath) {
+      await normalizeForConcat(validIntro, videoPath, normalizedIntroPath);
+      segments.push(normalizedIntroPath);
+    }
+    segments.push(videoPath);
+    if (validOutro && normalizedOutroPath) {
+      await normalizeForConcat(validOutro, videoPath, normalizedOutroPath);
+      segments.push(normalizedOutroPath);
+    }
+    logger_default.info(`Applying intro/outro (${validIntro ? "intro" : ""}${validIntro && validOutro ? "+" : ""}${validOutro ? "outro" : ""}) for ${videoType}${platform ? ` / ${platform}` : ""}: ${outputPath}`);
+    await concatVideos(segments, outputPath, { fadeDuration: config2.fadeDuration });
+    return outputPath;
+  } finally {
+    if (normalizedIntroPath) await removeFile(normalizedIntroPath).catch(() => {
+    });
+    if (normalizedOutroPath) await removeFile(normalizedOutroPath).catch(() => {
+    });
+  }
+}
+
+// src/L4-agents/videoServiceBridge.ts
+function applyIntroOutro2(videoPath, videoType, outputPath, platform, aspectRatio) {
+  return applyIntroOutro(videoPath, videoType, outputPath, platform, aspectRatio);
+}
+
 // src/L0-pure/captions/captionGenerator.ts
 function pad(n, width) {
   return String(n).padStart(width, "0");
@@ -12588,6 +12824,10 @@ var ShortVideoAsset = class extends VideoAsset {
   get videoPath() {
     return join(this.videoDir, "media.mp4");
   }
+  /** Path to the short with intro/outro applied */
+  get introOutroVideoPath() {
+    return join(this.videoDir, "media-intro-outro.mp4");
+  }
   /** Directory containing social posts for this short */
   get postsDir() {
     return join(this.videoDir, "posts");
@@ -12654,6 +12894,57 @@ var ShortVideoAsset = class extends VideoAsset {
     await extractCompositeClip2(parentVideo, this.clip.segments, this.videoPath);
     return this.videoPath;
   }
+  /**
+   * Apply intro/outro to the short clip.
+   * Uses brand config rules for 'shorts' video type.
+   *
+   * @returns Path to the intro/outro'd video, or the original path if skipped
+   */
+  async getIntroOutroVideo() {
+    if (await fileExists(this.introOutroVideoPath)) {
+      return this.introOutroVideoPath;
+    }
+    const candidates = [this.clip.captionedPath, this.clip.outputPath];
+    let clipPath;
+    for (const candidate of candidates) {
+      if (candidate && await fileExists(candidate)) {
+        clipPath = candidate;
+        break;
+      }
+    }
+    if (!clipPath) {
+      clipPath = await this.getResult();
+    }
+    return applyIntroOutro2(clipPath, "shorts", this.introOutroVideoPath);
+  }
+  /**
+   * Apply intro/outro to all platform variants of this short.
+   * Resolves the correct intro/outro file per aspect ratio, auto-cropping
+   * from the default file when no ratio-specific file is configured.
+   *
+   * @returns Map of platform to intro/outro'd variant path
+   */
+  async getIntroOutroVariants() {
+    const results = /* @__PURE__ */ new Map();
+    if (!this.clip.variants || this.clip.variants.length === 0) return results;
+    for (const variant of this.clip.variants) {
+      const outputPath = join(this.videoDir, `media-${variant.platform}-intro-outro.mp4`);
+      if (await fileExists(outputPath)) {
+        results.set(variant.platform, outputPath);
+        continue;
+      }
+      if (!await fileExists(variant.path)) continue;
+      const result = await applyIntroOutro2(
+        variant.path,
+        "shorts",
+        outputPath,
+        variant.platform,
+        variant.aspectRatio
+      );
+      results.set(variant.platform, result);
+    }
+    return results;
+  }
   // ── Transcript ───────────────────────────────────────────────────────────────
   /**
    * Get transcript filtered to this short's time range.
@@ -12723,6 +13014,10 @@ var MediumClipAsset = class extends VideoAsset {
   get videoPath() {
     return join(this.videoDir, "media.mp4");
   }
+  /** Path to the clip with intro/outro applied */
+  get introOutroVideoPath() {
+    return join(this.videoDir, "media-intro-outro.mp4");
+  }
   /**
    * Directory containing social media posts for this clip.
    */
@@ -12770,6 +13065,29 @@ var MediumClipAsset = class extends VideoAsset {
     await extractCompositeClip2(parentVideo, this.clip.segments, this.videoPath);
     return this.videoPath;
   }
+  /**
+   * Apply intro/outro to the medium clip.
+   * Uses brand config rules for 'medium-clips' video type.
+   *
+   * @returns Path to the intro/outro'd video, or the original path if skipped
+   */
+  async getIntroOutroVideo() {
+    if (await fileExists(this.introOutroVideoPath)) {
+      return this.introOutroVideoPath;
+    }
+    const candidates = [this.clip.captionedPath, this.clip.outputPath];
+    let clipPath;
+    for (const candidate of candidates) {
+      if (candidate && await fileExists(candidate)) {
+        clipPath = candidate;
+        break;
+      }
+    }
+    if (!clipPath) {
+      clipPath = await this.getResult();
+    }
+    return applyIntroOutro2(clipPath, "medium-clips", this.introOutroVideoPath);
+  }
 };
 
 // src/L5-assets/MainVideoAsset.ts
@@ -12861,7 +13179,7 @@ var SilenceRemovalAgent = class extends BaseAgent {
     return this.removals;
   }
 };
-async function getVideoDuration2(videoPath) {
+async function getVideoDuration3(videoPath) {
   try {
     const metadata = await ffprobe2(videoPath);
     return metadata.format.duration ?? 0;
@@ -12936,7 +13254,7 @@ async function removeDeadSilence(video, transcript, model) {
     logger_default.info("[SilenceRemoval] All removals exceeded 20% cap \u2014 skipping edit");
     return noEdit;
   }
-  const videoDuration = await getVideoDuration2(video.repoPath);
+  const videoDuration = await getVideoDuration3(video.repoPath);
   const sortedRemovals = [...removals].sort((a, b) => a.start - b.start);
   const keepSegments = [];
   let cursor = 0;
@@ -15417,6 +15735,10 @@ var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
   get producedVideoPath() {
     return join(this.videoDir, `${this.slug}-produced.mp4`);
   }
+  /** Path to the video with intro/outro applied: videoDir/{slug}-intro-outro.mp4 */
+  get introOutroVideoPath() {
+    return join(this.videoDir, `${this.slug}-intro-outro.mp4`);
+  }
   /** Path to a produced video for a specific aspect ratio: videoDir/{slug}-produced-{ar}.mp4 */
   producedVideoPathFor(aspectRatio) {
     const arSuffix = aspectRatio.replace(":", "x");
@@ -15694,6 +16016,21 @@ var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
     logger_default.info(`Captions burned into video: ${this.captionedVideoPath}`);
     return this.captionedVideoPath;
   }
+  /**
+   * Get the video with intro/outro applied.
+   * Concatenates intro (if configured) + captioned video + outro (if configured).
+   *
+   * @param opts - Options controlling generation
+   * @returns Path to the intro/outro video, or captioned video if skipped
+   */
+  async getIntroOutroVideo(opts) {
+    if (!opts?.force && await fileExists(this.introOutroVideoPath)) {
+      return this.introOutroVideoPath;
+    }
+    const captionedPath = await this.getCaptionedVideo(opts);
+    const result = await applyIntroOutro2(captionedPath, "main", this.introOutroVideoPath);
+    return result;
+  }
   /**
    * Get the fully produced video.
    * If not already generated, runs the ProducerAgent.
@@ -16424,16 +16761,53 @@ async function processVideo(videoPath, ideas) {
     } else {
       skipStage("caption-burn" /* CaptionBurn */, "SKIP_CAPTIONS");
     }
+    let introOutroVideoPath;
+    if (!cfg.SKIP_INTRO_OUTRO) {
+      introOutroVideoPath = await trackStage("intro-outro" /* IntroOutro */, () => asset.getIntroOutroVideo());
+    } else {
+      skipStage("intro-outro" /* IntroOutro */, "SKIP_INTRO_OUTRO");
+    }
     let shorts = [];
     if (!cfg.SKIP_SHORTS) {
-      const shortAssets = await trackStage("shorts" /* Shorts */, () => asset.getShorts()) ?? [];
+      const shortAssets = await trackStage("shorts" /* Shorts */, async () => {
+        const assets = await asset.getShorts();
+        if (!cfg.SKIP_INTRO_OUTRO) {
+          for (const shortAsset of assets) {
+            const introOutroPath = await shortAsset.getIntroOutroVideo();
+            if (introOutroPath !== shortAsset.clip.outputPath) {
+              shortAsset.clip.outputPath = introOutroPath;
+              shortAsset.clip.captionedPath = introOutroPath;
+            }
+            const variantResults = await shortAsset.getIntroOutroVariants();
+            if (shortAsset.clip.variants) {
+              for (const variant of shortAsset.clip.variants) {
+                const updated = variantResults.get(variant.platform);
+                if (updated) variant.path = updated;
+              }
+            }
+          }
+        }
+        return assets;
+      }) ?? [];
       shorts = shortAssets.map((s) => s.clip);
     } else {
       skipStage("shorts" /* Shorts */, "SKIP_SHORTS");
     }
     let mediumClips = [];
     if (!cfg.SKIP_MEDIUM_CLIPS) {
-      const mediumAssets = await trackStage("medium-clips" /* MediumClips */, () => asset.getMediumClips()) ?? [];
+      const mediumAssets = await trackStage("medium-clips" /* MediumClips */, async () => {
+        const assets = await asset.getMediumClips();
+        if (!cfg.SKIP_INTRO_OUTRO) {
+          for (const clipAsset of assets) {
+            const introOutroPath = await clipAsset.getIntroOutroVideo();
+            if (introOutroPath !== clipAsset.clip.outputPath) {
+              clipAsset.clip.outputPath = introOutroPath;
+              clipAsset.clip.captionedPath = introOutroPath;
+            }
+          }
+        }
+        return assets;
+      }) ?? [];
       mediumClips = mediumAssets.map((m) => m.clip);
     } else {
       skipStage("medium-clips" /* MediumClips */, "SKIP_MEDIUM_CLIPS");
@@ -16470,7 +16844,7 @@ async function processVideo(videoPath, ideas) {
       skipStage("medium-clip-posts" /* MediumClipPosts */, "SKIP_SOCIAL");
     }
     if (!cfg.SKIP_SOCIAL_PUBLISH && socialPosts.length > 0) {
-      await trackStage("queue-build" /* QueueBuild */, () => asset.buildQueue(shorts, mediumClips, socialPosts, captionedVideoPath));
+      await trackStage("queue-build" /* QueueBuild */, () => asset.buildQueue(shorts, mediumClips, socialPosts, introOutroVideoPath ?? captionedVideoPath));
     } else if (cfg.SKIP_SOCIAL_PUBLISH) {
       skipStage("queue-build" /* QueueBuild */, "SKIP_SOCIAL_PUBLISH");
     } else {
@@ -16506,6 +16880,7 @@ async function processVideo(videoPath, ideas) {
       enhancedVideoPath,
       captions: captions ? [captions.srt, captions.vtt, captions.ass] : void 0,
       captionedVideoPath,
+      introOutroVideoPath,
       summary,
       chapters,
       shorts,
@@ -16599,7 +16974,8 @@ var defaultKeys = [
   "brandPath",
   "ideasRepo",
   "lateProfileId",
-  "geminiModel"
+  "geminiModel",
+  "scheduleConfig"
 ];
 var configKeyMap = {
   "openai-key": { section: "credentials", key: "openaiApiKey" },
@@ -16617,7 +16993,8 @@ var configKeyMap = {
   "brand-path": { section: "defaults", key: "brandPath" },
   "ideas-repo": { section: "defaults", key: "ideasRepo" },
   "late-profile-id": { section: "defaults", key: "lateProfileId" },
-  "gemini-model": { section: "defaults", key: "geminiModel" }
+  "gemini-model": { section: "defaults", key: "geminiModel" },
+  "schedule-config": { section: "defaults", key: "scheduleConfig" }
 };
 var providerDefaults = {
   copilot: "Claude Opus 4.6",