vidpipe 1.2.2 → 1.2.3

package/dist/index.js

@@ -1,143 +1,4786 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import { initConfig, validateRequiredKeys, getConfig } from './config/environment';
-import { FileWatcher } from './services/fileWatcher';
-import { processVideoSafe } from './pipeline';
-import logger, { setVerbose } from './config/logger';
-import { runDoctor } from './commands/doctor';
-import path from 'path';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(readFileSync(path.resolve(__dirname, '..', 'package.json'), 'utf-8'));
-const BANNER = `
-╔══════════════════════════════════════╗
-║   VidPipe  v${pkg.version.padEnd(24)}║
-╚══════════════════════════════════════╝
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/config/environment.ts
+import path from "path";
+import fs from "fs";
+import dotenv from "dotenv";
+var envPath = path.join(process.cwd(), ".env");
+if (fs.existsSync(envPath)) {
+  dotenv.config({ path: envPath });
+}
+var config = null;
+function validateRequiredKeys() {
+  if (!config?.OPENAI_API_KEY && !process.env.OPENAI_API_KEY) {
+    throw new Error("Missing required: OPENAI_API_KEY (set via --openai-key or env var)");
+  }
+}
+function initConfig(cli = {}) {
+  const repoRoot = process.env.REPO_ROOT || process.cwd();
+  config = {
+    OPENAI_API_KEY: cli.openaiKey || process.env.OPENAI_API_KEY || "",
+    WATCH_FOLDER: cli.watchDir || process.env.WATCH_FOLDER || path.join(repoRoot, "watch"),
+    REPO_ROOT: repoRoot,
+    FFMPEG_PATH: process.env.FFMPEG_PATH || "ffmpeg",
+    // legacy; prefer ffmpegResolver
+    FFPROBE_PATH: process.env.FFPROBE_PATH || "ffprobe",
+    // legacy; prefer ffmpegResolver
+    EXA_API_KEY: cli.exaKey || process.env.EXA_API_KEY || "",
+    LLM_PROVIDER: process.env.LLM_PROVIDER || "copilot",
+    LLM_MODEL: process.env.LLM_MODEL || "",
+    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || "",
+    OUTPUT_DIR: cli.outputDir || process.env.OUTPUT_DIR || path.join(repoRoot, "recordings"),
+    BRAND_PATH: cli.brand || process.env.BRAND_PATH || path.join(repoRoot, "brand.json"),
+    VERBOSE: cli.verbose ?? false,
+    SKIP_GIT: cli.git === false,
+    SKIP_SILENCE_REMOVAL: cli.silenceRemoval === false,
+    SKIP_SHORTS: cli.shorts === false,
+    SKIP_MEDIUM_CLIPS: cli.mediumClips === false,
+    SKIP_SOCIAL: cli.social === false,
+    SKIP_CAPTIONS: cli.captions === false
+  };
+  return config;
+}
+function getConfig() {
+  if (config) {
+    return config;
+  }
+  return initConfig();
+}
+
+// src/services/fileWatcher.ts
+import { watch } from "chokidar";
+import { EventEmitter } from "events";
+import path2 from "path";
+import fs2 from "fs";
+
+// src/config/logger.ts
+import winston from "winston";
+var logger = winston.createLogger({
+  level: "info",
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.printf(({ timestamp, level, message }) => {
+      return `${timestamp} [${level.toUpperCase()}]: ${message}`;
+    })
+  ),
+  transports: [new winston.transports.Console()]
+});
+function setVerbose() {
+  logger.level = "debug";
+}
+var logger_default = logger;
+
+// src/services/fileWatcher.ts
+var FileWatcher = class _FileWatcher extends EventEmitter {
+  watchFolder;
+  watcher = null;
+  processExisting;
+  constructor(options = {}) {
+    super();
+    const config2 = getConfig();
+    this.watchFolder = config2.WATCH_FOLDER;
+    this.processExisting = options.processExisting ?? false;
+    if (!fs2.existsSync(this.watchFolder)) {
+      fs2.mkdirSync(this.watchFolder, { recursive: true });
+      logger_default.info(`Created watch folder: ${this.watchFolder}`);
+    }
+  }
+  static MIN_FILE_SIZE = 1024 * 1024;
+  // 1MB
+  static EXTRA_STABILITY_DELAY = 3e3;
+  /** Read file size, wait, read again — if it changed the file is still being written. */
+  async isFileStable(filePath) {
+    try {
+      const sizeBefore = fs2.statSync(filePath).size;
+      await new Promise((resolve) => setTimeout(resolve, _FileWatcher.EXTRA_STABILITY_DELAY));
+      const sizeAfter = fs2.statSync(filePath).size;
+      return sizeBefore === sizeAfter;
+    } catch {
+      return false;
+    }
+  }
+  async handleDetectedFile(filePath) {
+    if (path2.extname(filePath).toLowerCase() !== ".mp4") {
+      logger_default.debug(`[watcher] Ignoring non-mp4 file: ${filePath}`);
+      return;
+    }
+    let fileSize;
+    try {
+      fileSize = fs2.statSync(filePath).size;
+    } catch (err) {
+      logger_default.warn(`[watcher] Could not stat file (may have been removed): ${filePath}`);
+      return;
+    }
+    logger_default.debug(`[watcher] File size: ${(fileSize / 1024 / 1024).toFixed(1)} MB \u2014 ${filePath}`);
+    if (fileSize < _FileWatcher.MIN_FILE_SIZE) {
+      logger_default.warn(`Skipping small file (${fileSize} bytes), likely a failed recording: ${filePath}`);
+      return;
+    }
+    const stable = await this.isFileStable(filePath);
+    if (!stable) {
+      logger_default.warn(`File is still being written, skipping for now: ${filePath}`);
+      return;
+    }
+    logger_default.info(`New video detected: ${filePath}`);
+    this.emit("new-video", filePath);
+  }
+  scanExistingFiles() {
+    const files = fs2.readdirSync(this.watchFolder);
+    for (const file of files) {
+      if (path2.extname(file).toLowerCase() === ".mp4") {
+        const filePath = path2.join(this.watchFolder, file);
+        this.handleDetectedFile(filePath).catch(
+          (err) => logger_default.error(`Error processing ${filePath}: ${err instanceof Error ? err.message : String(err)}`)
+        );
+      }
+    }
+  }
+  start() {
+    this.watcher = watch(this.watchFolder, {
+      persistent: true,
+      ignoreInitial: true,
+      depth: 0,
+      atomic: 100,
+      // Polling is more reliable on Windows for detecting renames (e.g. Bandicam temp→final)
+      usePolling: true,
+      interval: 500,
+      awaitWriteFinish: {
+        stabilityThreshold: 3e3,
+        pollInterval: 200
+      }
+    });
+    this.watcher.on("add", (filePath) => {
+      logger_default.debug(`[watcher] 'add' event: ${filePath}`);
+      this.handleDetectedFile(filePath).catch(
+        (err) => logger_default.error(`Error processing ${filePath}: ${err instanceof Error ? err.message : String(err)}`)
+      );
+    });
+    this.watcher.on("change", (filePath) => {
+      logger_default.debug(`[watcher] 'change' event: ${filePath}`);
+      if (path2.extname(filePath).toLowerCase() !== ".mp4") return;
+      logger_default.info(`Change detected on video file: ${filePath}`);
+      this.handleDetectedFile(filePath).catch(
+        (err) => logger_default.error(`Error processing ${filePath}: ${err instanceof Error ? err.message : String(err)}`)
+      );
+    });
+    this.watcher.on("unlink", (filePath) => {
+      logger_default.debug(`[watcher] 'unlink' event: ${filePath}`);
+    });
+    this.watcher.on("raw", (event, rawPath, details) => {
+      logger_default.debug(`[watcher] raw event=${event} path=${rawPath}`);
+    });
+    this.watcher.on("error", (error) => {
+      logger_default.error(`File watcher error: ${error instanceof Error ? error.message : String(error)}`);
+    });
+    this.watcher.on("ready", () => {
+      logger_default.info("File watcher is fully initialized and ready");
+      if (this.processExisting) {
+        this.scanExistingFiles();
+      }
+    });
+    logger_default.info(`Watching for new .mp4 files in: ${this.watchFolder}`);
+  }
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+      logger_default.info("File watcher stopped");
+    }
+  }
+};
+
+// src/pipeline.ts
+import path17 from "path";
+import { promises as fs19 } from "fs";
+
+// src/services/videoIngestion.ts
+import path3 from "path";
+import fs3 from "fs";
+import fsp from "fs/promises";
+import slugify from "slugify";
+import ffmpeg from "fluent-ffmpeg";
+
+// src/config/ffmpegResolver.ts
+import { createRequire } from "module";
+import { existsSync } from "fs";
+var require2 = createRequire(import.meta.url);
+function getFFmpegPath() {
+  if (process.env.FFMPEG_PATH) {
+    logger_default.debug(`FFmpeg: using FFMPEG_PATH env var: ${process.env.FFMPEG_PATH}`);
+    return process.env.FFMPEG_PATH;
+  }
+  try {
+    const staticPath = require2("ffmpeg-static");
+    if (staticPath && existsSync(staticPath)) {
+      logger_default.debug(`FFmpeg: using ffmpeg-static: ${staticPath}`);
+      return staticPath;
+    }
+  } catch {
+  }
+  logger_default.debug("FFmpeg: falling back to system PATH");
+  return "ffmpeg";
+}
+function getFFprobePath() {
+  if (process.env.FFPROBE_PATH) {
+    logger_default.debug(`FFprobe: using FFPROBE_PATH env var: ${process.env.FFPROBE_PATH}`);
+    return process.env.FFPROBE_PATH;
+  }
+  try {
+    const { path: probePath } = require2("@ffprobe-installer/ffprobe");
+    if (probePath && existsSync(probePath)) {
+      logger_default.debug(`FFprobe: using @ffprobe-installer/ffprobe: ${probePath}`);
+      return probePath;
+    }
+  } catch {
+  }
+  logger_default.debug("FFprobe: falling back to system PATH");
+  return "ffprobe";
+}
+
+// src/services/videoIngestion.ts
+var ffmpegBin = getFFmpegPath();
+var ffprobeBin = getFFprobePath();
+ffmpeg.setFfmpegPath(ffmpegBin);
+ffmpeg.setFfprobePath(ffprobeBin);
+function getVideoMetadata(filePath) {
+  return new Promise((resolve, reject) => {
+    ffmpeg.ffprobe(filePath, (err, metadata) => {
+      if (err) {
+        return reject(err);
+      }
+      resolve({ duration: metadata.format.duration ?? 0 });
+    });
+  });
+}
+async function ingestVideo(sourcePath) {
+  const config2 = getConfig();
+  const baseName = path3.basename(sourcePath, path3.extname(sourcePath));
+  const slug = slugify(baseName, { lower: true });
+  const recordingsDir = path3.join(config2.OUTPUT_DIR, slug);
+  const thumbnailsDir = path3.join(recordingsDir, "thumbnails");
+  const shortsDir = path3.join(recordingsDir, "shorts");
+  const socialPostsDir = path3.join(recordingsDir, "social-posts");
+  logger_default.info(`Ingesting video: ${sourcePath} \u2192 ${slug}`);
+  if (fs3.existsSync(recordingsDir)) {
+    logger_default.warn(`Output folder already exists, cleaning previous artifacts: ${recordingsDir}`);
+    const subDirs = ["thumbnails", "shorts", "social-posts", "chapters", "medium-clips", "captions"];
+    for (const sub of subDirs) {
+      await fsp.rm(path3.join(recordingsDir, sub), { recursive: true, force: true });
+    }
+    const stalePatterns = [
+      "transcript.json",
+      "transcript-edited.json",
+      "captions.srt",
+      "captions.vtt",
+      "captions.ass",
+      "summary.md",
+      "blog-post.md",
+      "README.md"
+    ];
+    for (const pattern of stalePatterns) {
+      await fsp.rm(path3.join(recordingsDir, pattern), { force: true });
+    }
+    const files = await fsp.readdir(recordingsDir);
+    for (const file of files) {
+      if (file.endsWith("-edited.mp4") || file.endsWith("-captioned.mp4")) {
+        await fsp.rm(path3.join(recordingsDir, file), { force: true });
+      }
+    }
+  }
+  await fsp.mkdir(recordingsDir, { recursive: true });
+  await fsp.mkdir(thumbnailsDir, { recursive: true });
+  await fsp.mkdir(shortsDir, { recursive: true });
+  await fsp.mkdir(socialPostsDir, { recursive: true });
+  const destFilename = `${slug}.mp4`;
+  const destPath = path3.join(recordingsDir, destFilename);
+  let needsCopy = true;
+  try {
+    const destStats = await fsp.stat(destPath);
+    const srcStats = await fsp.stat(sourcePath);
+    if (destStats.size === srcStats.size) {
+      logger_default.info(`Video already copied (same size), skipping copy`);
+      needsCopy = false;
+    }
+  } catch {
+  }
+  if (needsCopy) {
+    await new Promise((resolve, reject) => {
+      const readStream = fs3.createReadStream(sourcePath);
+      const writeStream = fs3.createWriteStream(destPath);
+      readStream.on("error", reject);
+      writeStream.on("error", reject);
+      writeStream.on("finish", resolve);
+      readStream.pipe(writeStream);
+    });
+    logger_default.info(`Copied video to ${destPath}`);
+  }
+  let duration = 0;
+  try {
+    const meta = await getVideoMetadata(destPath);
+    duration = meta.duration;
+  } catch (err) {
+    logger_default.warn(`ffprobe failed, continuing without duration metadata: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const stats = await fsp.stat(destPath);
+  logger_default.info(`Video metadata: duration=${duration}s, size=${stats.size} bytes`);
+  return {
+    originalPath: sourcePath,
+    repoPath: destPath,
+    videoDir: recordingsDir,
+    slug,
+    filename: destFilename,
+    duration,
+    size: stats.size,
+    createdAt: /* @__PURE__ */ new Date()
+  };
+}
+
+// src/services/transcription.ts
+import path5 from "path";
+import fsp2 from "fs/promises";
+
+// src/tools/ffmpeg/audioExtraction.ts
+import ffmpeg2 from "fluent-ffmpeg";
+import { promises as fs4 } from "fs";
+import path4 from "path";
+var ffmpegPath = getFFmpegPath();
+var ffprobePath = getFFprobePath();
+ffmpeg2.setFfmpegPath(ffmpegPath);
+ffmpeg2.setFfprobePath(ffprobePath);
+async function extractAudio(videoPath, outputPath, options = {}) {
+  const { format = "mp3" } = options;
+  const outputDir = path4.dirname(outputPath);
+  await fs4.mkdir(outputDir, { recursive: true });
+  logger_default.info(`Extracting audio (${format}): ${videoPath} \u2192 ${outputPath}`);
+  return new Promise((resolve, reject) => {
+    const command = ffmpeg2(videoPath).noVideo().audioChannels(1);
+    if (format === "mp3") {
+      command.audioCodec("libmp3lame").audioBitrate("64k").audioFrequency(16e3);
+    } else {
+      command.audioCodec("pcm_s16le").audioFrequency(16e3);
+    }
+    command.output(outputPath).on("end", () => {
+      logger_default.info(`Audio extraction complete: ${outputPath}`);
+      resolve(outputPath);
+    }).on("error", (err) => {
+      logger_default.error(`Audio extraction failed: ${err.message}`);
+      reject(new Error(`Audio extraction failed: ${err.message}`));
+    }).run();
+  });
+}
+async function splitAudioIntoChunks(audioPath, maxChunkSizeMB = 24) {
+  const stats = await fs4.stat(audioPath);
+  const fileSizeMB = stats.size / (1024 * 1024);
+  if (fileSizeMB <= maxChunkSizeMB) {
+    return [audioPath];
+  }
+  const duration = await getAudioDuration(audioPath);
+  const numChunks = Math.ceil(fileSizeMB / maxChunkSizeMB);
+  const chunkDuration = duration / numChunks;
+  const ext = path4.extname(audioPath);
+  const base = audioPath.slice(0, -ext.length);
+  const chunkPaths = [];
+  logger_default.info(
+    `Splitting ${fileSizeMB.toFixed(1)}MB audio into ${numChunks} chunks (~${chunkDuration.toFixed(0)}s each)`
+  );
+  for (let i = 0; i < numChunks; i++) {
+    const startTime = i * chunkDuration;
+    const chunkPath = `${base}_chunk${i}${ext}`;
+    chunkPaths.push(chunkPath);
+    await new Promise((resolve, reject) => {
+      const cmd = ffmpeg2(audioPath).setStartTime(startTime).setDuration(chunkDuration).audioCodec("copy").output(chunkPath).on("end", () => resolve()).on("error", (err) => reject(new Error(`Chunk split failed: ${err.message}`)));
+      cmd.run();
+    });
+    logger_default.info(`Created chunk ${i + 1}/${numChunks}: ${chunkPath}`);
+  }
+  return chunkPaths;
+}
+function getAudioDuration(audioPath) {
+  return new Promise((resolve, reject) => {
+    ffmpeg2.ffprobe(audioPath, (err, metadata) => {
+      if (err) return reject(new Error(`ffprobe failed: ${err.message}`));
+      resolve(metadata.format.duration ?? 0);
+    });
+  });
+}
+
+// src/tools/whisper/whisperClient.ts
+import OpenAI from "openai";
+import fs6 from "fs";
+
+// src/config/brand.ts
+import fs5 from "fs";
+var defaultBrand = {
+  name: "Creator",
+  handle: "@creator",
+  tagline: "",
+  voice: {
+    tone: "professional, friendly",
+    personality: "A knowledgeable content creator.",
+    style: "Clear and concise."
+  },
+  advocacy: {
+    primary: [],
+    interests: [],
+    avoids: []
+  },
+  customVocabulary: [],
+  hashtags: {
+    always: [],
+    preferred: [],
+    platforms: {}
+  },
+  contentGuidelines: {
+    shortsFocus: "Highlight key moments and insights.",
+    blogFocus: "Educational and informative content.",
+    socialFocus: "Engaging and authentic posts."
+  }
+};
+var cachedBrand = null;
+function validateBrandConfig(brand) {
+  const requiredStrings = ["name", "handle", "tagline"];
+  for (const field of requiredStrings) {
+    if (!brand[field]) {
+      logger_default.warn(`brand.json: missing or empty field "${field}"`);
+    }
+  }
+  const requiredObjects = [
+    { key: "voice", subKeys: ["tone", "personality", "style"] },
+    { key: "advocacy", subKeys: ["primary", "interests"] },
+    { key: "hashtags", subKeys: ["always", "preferred"] },
+    { key: "contentGuidelines", subKeys: ["shortsFocus", "blogFocus", "socialFocus"] }
+  ];
+  for (const { key, subKeys } of requiredObjects) {
+    if (!brand[key]) {
+      logger_default.warn(`brand.json: missing section "${key}"`);
+    } else {
+      const section = brand[key];
+      for (const sub of subKeys) {
+        if (!section[sub] || Array.isArray(section[sub]) && section[sub].length === 0) {
+          logger_default.warn(`brand.json: missing or empty field "${key}.${sub}"`);
+        }
+      }
+    }
+  }
+  if (!brand.customVocabulary || brand.customVocabulary.length === 0) {
+    logger_default.warn('brand.json: "customVocabulary" is empty \u2014 Whisper prompt will be blank');
+  }
+}
+function getBrandConfig() {
+  if (cachedBrand) return cachedBrand;
+  const config2 = getConfig();
+  const brandPath = config2.BRAND_PATH;
+  if (!fs5.existsSync(brandPath)) {
+    logger_default.warn("brand.json not found \u2014 using defaults");
+    cachedBrand = { ...defaultBrand };
+    return cachedBrand;
+  }
+  const raw = fs5.readFileSync(brandPath, "utf-8");
+  cachedBrand = JSON.parse(raw);
+  validateBrandConfig(cachedBrand);
+  logger_default.info(`Brand config loaded: ${cachedBrand.name}`);
+  return cachedBrand;
+}
+function getWhisperPrompt() {
+  const brand = getBrandConfig();
+  return brand.customVocabulary.join(", ");
+}
+
+// src/tools/whisper/whisperClient.ts
+var MAX_FILE_SIZE_MB = 25;
+var WARN_FILE_SIZE_MB = 20;
+async function transcribeAudio(audioPath) {
+  logger_default.info(`Starting Whisper transcription: ${audioPath}`);
+  if (!fs6.existsSync(audioPath)) {
+    throw new Error(`Audio file not found: ${audioPath}`);
+  }
+  const stats = fs6.statSync(audioPath);
+  const fileSizeMB = stats.size / (1024 * 1024);
+  if (fileSizeMB > MAX_FILE_SIZE_MB) {
+    throw new Error(
+      `Audio file exceeds Whisper's 25MB limit (${fileSizeMB.toFixed(1)}MB). The file should be split into smaller chunks before transcription.`
+    );
+  }
+  if (fileSizeMB > WARN_FILE_SIZE_MB) {
+    logger_default.warn(`Audio file is ${fileSizeMB.toFixed(1)}MB \u2014 approaching 25MB limit`);
+  }
+  const config2 = getConfig();
+  const openai = new OpenAI({ apiKey: config2.OPENAI_API_KEY });
+  try {
+    const prompt = getWhisperPrompt();
+    const response = await openai.audio.transcriptions.create({
+      model: "whisper-1",
+      file: fs6.createReadStream(audioPath),
+      response_format: "verbose_json",
+      timestamp_granularities: ["word", "segment"],
+      ...prompt && { prompt }
+    });
+    const verboseResponse = response;
+    const rawSegments = verboseResponse.segments ?? [];
+    const rawWords = verboseResponse.words ?? [];
+    const words = rawWords.map((w) => ({
+      word: w.word,
+      start: w.start,
+      end: w.end
+    }));
+    const segments = rawSegments.map((s) => ({
+      id: s.id,
+      text: s.text.trim(),
+      start: s.start,
+      end: s.end,
+      words: rawWords.filter((w) => w.start >= s.start && w.end <= s.end).map((w) => ({ word: w.word, start: w.start, end: w.end }))
+    }));
+    logger_default.info(
+      `Transcription complete \u2014 ${segments.length} segments, ${words.length} words, language=${response.language}`
+    );
+    return {
+      text: response.text,
+      segments,
+      words,
+      language: response.language ?? "unknown",
+      duration: response.duration ?? 0
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger_default.error(`Whisper transcription failed: ${message}`);
+    const status = error.status;
+    if (status === 401) {
+      throw new Error("OpenAI API authentication failed. Check your OPENAI_API_KEY.");
+    }
+    if (status === 429) {
+      throw new Error("OpenAI API rate limit exceeded. Please try again later.");
+    }
+    throw new Error(`Whisper transcription failed: ${message}`);
+  }
+}
+
+// src/services/transcription.ts
+var MAX_WHISPER_SIZE_MB = 25;
+async function transcribeVideo(video) {
+  const config2 = getConfig();
+  const cacheDir = path5.join(config2.REPO_ROOT, "cache");
+  await fsp2.mkdir(cacheDir, { recursive: true });
+  logger_default.info(`Cache directory ready: ${cacheDir}`);
+  const mp3Path = path5.join(cacheDir, `${video.slug}.mp3`);
+  logger_default.info(`Extracting audio for "${video.slug}"`);
+  await extractAudio(video.repoPath, mp3Path);
+  const stats = await fsp2.stat(mp3Path);
+  const fileSizeMB = stats.size / (1024 * 1024);
+  logger_default.info(`Extracted audio: ${fileSizeMB.toFixed(1)}MB`);
+  let transcript;
+  if (fileSizeMB <= MAX_WHISPER_SIZE_MB) {
+    logger_default.info(`Transcribing audio for "${video.slug}"`);
+    transcript = await transcribeAudio(mp3Path);
+  } else {
+    logger_default.info(`Audio exceeds ${MAX_WHISPER_SIZE_MB}MB, splitting into chunks`);
+    const chunkPaths = await splitAudioIntoChunks(mp3Path);
+    transcript = await transcribeChunks(chunkPaths);
+    for (const chunkPath of chunkPaths) {
+      if (chunkPath !== mp3Path) {
+        await fsp2.unlink(chunkPath).catch(() => {
+        });
+      }
+    }
+  }
+  const transcriptDir = path5.join(config2.OUTPUT_DIR, video.slug);
+  await fsp2.mkdir(transcriptDir, { recursive: true });
+  const transcriptPath = path5.join(transcriptDir, "transcript.json");
+  await fsp2.writeFile(transcriptPath, JSON.stringify(transcript, null, 2), "utf-8");
+  logger_default.info(`Transcript saved: ${transcriptPath}`);
+  await fsp2.unlink(mp3Path).catch(() => {
+  });
+  logger_default.info(`Cleaned up temp file: ${mp3Path}`);
+  logger_default.info(
+    `Transcription complete for "${video.slug}" \u2014 ${transcript.segments.length} segments, ${transcript.words.length} words`
+  );
+  return transcript;
+}
+async function transcribeChunks(chunkPaths) {
+  let allText = "";
+  const allSegments = [];
+  const allWords = [];
+  let cumulativeOffset = 0;
+  let totalDuration = 0;
+  let language = "unknown";
+  for (let i = 0; i < chunkPaths.length; i++) {
+    logger_default.info(`Transcribing chunk ${i + 1}/${chunkPaths.length}: ${chunkPaths[i]}`);
+    const result = await transcribeAudio(chunkPaths[i]);
+    if (i === 0) language = result.language;
+    const offsetSegments = result.segments.map((s) => ({
+      ...s,
+      id: allSegments.length + s.id,
+      start: s.start + cumulativeOffset,
+      end: s.end + cumulativeOffset,
+      words: s.words.map((w) => ({
+        ...w,
+        start: w.start + cumulativeOffset,
+        end: w.end + cumulativeOffset
+      }))
+    }));
+    const offsetWords = result.words.map((w) => ({
+      ...w,
+      start: w.start + cumulativeOffset,
+      end: w.end + cumulativeOffset
+    }));
+    allText += (allText ? " " : "") + result.text;
+    allSegments.push(...offsetSegments);
+    allWords.push(...offsetWords);
+    cumulativeOffset += result.duration;
+    totalDuration += result.duration;
+  }
+  return {
+    text: allText,
+    segments: allSegments,
+    words: allWords,
+    language,
+    duration: totalDuration
+  };
+}
+
+// src/services/captionGeneration.ts
+import path6 from "path";
+import fsp3 from "fs/promises";
+
+// src/tools/captions/captionGenerator.ts
+function pad(n, width) {
+  return String(n).padStart(width, "0");
+}
+function toSRT(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = Math.floor(seconds % 60);
+  const ms = Math.round((seconds - Math.floor(seconds)) * 1e3);
+  return `${pad(h, 2)}:${pad(m, 2)}:${pad(s, 2)},${pad(ms, 3)}`;
+}
+function toVTT(seconds) {
+  return toSRT(seconds).replace(",", ".");
+}
+function toASS(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = Math.floor(seconds % 60);
+  const cs = Math.round((seconds - Math.floor(seconds)) * 100);
+  return `${h}:${pad(m, 2)}:${pad(s, 2)}.${pad(cs, 2)}`;
+}
+var SILENCE_GAP_THRESHOLD = 0.8;
+var MAX_WORDS_PER_GROUP = 8;
+var WORDS_PER_LINE = 4;
+var ACTIVE_COLOR = "\\c&H00FFFF&";
+var BASE_COLOR = "\\c&HFFFFFF&";
+var ACTIVE_FONT_SIZE = 54;
+var BASE_FONT_SIZE = 42;
+var MEDIUM_ACTIVE_FONT_SIZE = 40;
+var MEDIUM_BASE_FONT_SIZE = 32;
+var PORTRAIT_ACTIVE_FONT_SIZE = 78;
+var PORTRAIT_BASE_FONT_SIZE = 66;
+var PORTRAIT_ACTIVE_COLOR = "\\c&H00FF00&";
+var PORTRAIT_BASE_COLOR = "\\c&HFFFFFF&";
+function generateSRT(transcript) {
+  return transcript.segments.map((seg, i) => {
+    const idx = i + 1;
+    const start = toSRT(seg.start);
+    const end = toSRT(seg.end);
+    const text = seg.text.trim();
+    return `${idx}
+${start} --> ${end}
+${text}`;
+  }).join("\n\n").concat("\n");
+}
+function generateVTT(transcript) {
+  const cues = transcript.segments.map((seg) => {
+    const start = toVTT(seg.start);
+    const end = toVTT(seg.end);
+    const text = seg.text.trim();
+    return `${start} --> ${end}
+${text}`;
+  }).join("\n\n");
+  return `WEBVTT
+
+${cues}
 `;
-const program = new Command();
-program
-    .name('vidpipe')
-    .description('AI-powered video content pipeline: transcribe, summarize, generate shorts, captions, and social posts')
-    .version(pkg.version, '-V, --version')
-    .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('--once', 'Process a single video and exit (no watching)')
-    .option('--brand <path>', 'Path to brand.json config (default: ./brand.json)')
-    .option('--no-git', 'Skip git commit/push stage')
-    .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('-v, --verbose', 'Verbose logging')
-    .option('--doctor', 'Check all prerequisites and exit');
-program.parse();
-const opts = program.opts();
-// Handle --doctor before anything else
-if (opts.doctor) {
-    runDoctor();
-    // runDoctor() calls process.exit(); this is a safety fallback
-    process.exit(0);
 }
-const videoArg = program.args[0];
-const onceMode = opts.once || !!videoArg;
-const cliOptions = {
-    watchDir: opts.watchDir,
-    outputDir: opts.outputDir,
-    openaiKey: opts.openaiKey,
-    exaKey: opts.exaKey,
-    brand: opts.brand,
-    verbose: opts.verbose,
-    git: opts.git,
-    silenceRemoval: opts.silenceRemoval,
-    shorts: opts.shorts,
-    mediumClips: opts.mediumClips,
-    social: opts.social,
-    captions: opts.captions,
-};
-const queue = [];
-let processing = false;
-let shutdownRequested = false;
-let watcher = null;
-async function processQueue() {
-    if (processing || queue.length === 0)
+var ASS_HEADER = `[Script Info]
+Title: Auto-generated captions
+ScriptType: v4.00+
+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,42,&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,78,&H00FFFFFF,&H0000FFFF,&H00000000,&H80000000,1,0,0,0,100,100,0,0,1,3,1,2,30,30,700,1
+Style: Hook,Montserrat,56,&H00333333,&H00333333,&H60D0D0D0,&H60E0E0E0,1,0,0,0,100,100,2,0,3,18,2,8,80,80,60,1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+`;
+var ASS_HEADER_MEDIUM = `[Script Info]
+Title: Auto-generated captions
+ScriptType: v4.00+
+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,32,&H00FFFFFF,&H0000FFFF,&H00000000,&H80000000,1,0,0,0,100,100,0,0,1,2,1,2,20,20,60,1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+`;
+function groupWordsBySpeech(words) {
+  if (words.length === 0) return [];
+  const groups = [];
+  let current = [];
+  for (let i = 0; i < words.length; i++) {
+    current.push(words[i]);
+    const isLast = i === words.length - 1;
+    const hasGap = !isLast && words[i + 1].start - words[i].end > SILENCE_GAP_THRESHOLD;
+    const atMax = current.length >= MAX_WORDS_PER_GROUP;
+    if (isLast || hasGap || atMax) {
+      groups.push(current);
+      current = [];
+    }
+  }
+  return groups;
+}
+function splitGroupIntoLines(group) {
+  if (group.length <= WORDS_PER_LINE) return [group];
+  const mid = Math.ceil(group.length / 2);
+  return [group.slice(0, mid), group.slice(mid)];
+}
+function buildPremiumDialogueLines(words, style = "shorts") {
+  const activeFontSize = style === "portrait" ? PORTRAIT_ACTIVE_FONT_SIZE : style === "medium" ? MEDIUM_ACTIVE_FONT_SIZE : ACTIVE_FONT_SIZE;
+  const baseFontSize = style === "portrait" ? PORTRAIT_BASE_FONT_SIZE : style === "medium" ? MEDIUM_BASE_FONT_SIZE : BASE_FONT_SIZE;
+  const groups = groupWordsBySpeech(words);
+  const dialogues = [];
+  for (const group of groups) {
+    const displayLines = splitGroupIntoLines(group);
+    for (let activeIdx = 0; activeIdx < group.length; activeIdx++) {
+      const activeWord = group[activeIdx];
+      const endTime = activeIdx < group.length - 1 ? group[activeIdx + 1].start : activeWord.end;
+      const renderedLines = [];
+      let globalIdx = 0;
+      for (const line of displayLines) {
+        const rendered = line.map((w) => {
+          const idx = globalIdx++;
+          const text2 = w.word.trim();
+          if (idx === activeIdx) {
+            if (style === "portrait") {
+              return `{${PORTRAIT_ACTIVE_COLOR}\\fs${activeFontSize}\\fscx130\\fscy130\\t(0,150,\\fscx100\\fscy100)}${text2}`;
+            }
+            return `{${ACTIVE_COLOR}\\fs${activeFontSize}}${text2}`;
+          }
+          if (style === "portrait") {
+            return `{${PORTRAIT_BASE_COLOR}\\fs${baseFontSize}}${text2}`;
+          }
+          return `{${BASE_COLOR}\\fs${baseFontSize}}${text2}`;
+        });
+        renderedLines.push(rendered.join(" "));
+      }
+      const text = renderedLines.join("\\N");
+      dialogues.push(
+        `Dialogue: 0,${toASS(activeWord.start)},${toASS(endTime)},Default,,0,0,0,,${text}`
+      );
+    }
+  }
+  return dialogues;
+}
+function generateStyledASS(transcript, style = "shorts") {
+  const header = style === "portrait" ? ASS_HEADER_PORTRAIT : style === "medium" ? ASS_HEADER_MEDIUM : ASS_HEADER;
+  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 bufferedStart = Math.max(0, startTime - buffer);
+  const bufferedEnd = endTime + buffer;
+  const words = transcript.words.filter(
+    (w) => w.start >= bufferedStart && w.end <= bufferedEnd
+  );
+  if (words.length === 0) return header;
+  const adjusted = words.map((w) => ({
+    word: w.word,
+    start: w.start - bufferedStart,
+    end: w.end - bufferedStart
+  }));
+  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 allAdjusted = [];
+  let runningOffset = 0;
+  for (const seg of segments) {
+    const bufferedStart = Math.max(0, seg.start - buffer);
+    const bufferedEnd = seg.end + buffer;
+    const segDuration = bufferedEnd - bufferedStart;
+    const words = transcript.words.filter(
+      (w) => w.start >= bufferedStart && w.end <= bufferedEnd
+    );
+    for (const w of words) {
+      allAdjusted.push({
+        word: w.word,
+        start: w.start - bufferedStart + runningOffset,
+        end: w.end - bufferedStart + runningOffset
+      });
+    }
+    runningOffset += segDuration;
+  }
+  if (allAdjusted.length === 0) return header;
+  return header + buildPremiumDialogueLines(allAdjusted, style).join("\n") + "\n";
+}
+var HOOK_TEXT_MAX_LENGTH = 60;
+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");
+  return baseASS + hookLine + "\n";
+}
+function generatePortraitASSWithHookComposite(transcript, segments, hookText, buffer) {
+  const baseASS = generateStyledASSForComposite(transcript, segments, buffer, "portrait");
+  const hookLine = generateHookOverlay(hookText, 4, "portrait");
+  return baseASS + hookLine + "\n";
+}
+
+// src/services/captionGeneration.ts
+async function generateCaptions(video, transcript) {
+  const config2 = getConfig();
+  const captionsDir = path6.join(config2.OUTPUT_DIR, video.slug, "captions");
+  await fsp3.mkdir(captionsDir, { recursive: true });
+  const srtPath = path6.join(captionsDir, "captions.srt");
+  const vttPath = path6.join(captionsDir, "captions.vtt");
+  const assPath = path6.join(captionsDir, "captions.ass");
+  const srt = generateSRT(transcript);
+  const vtt = generateVTT(transcript);
+  const ass = generateStyledASS(transcript);
+  await Promise.all([
+    fsp3.writeFile(srtPath, srt, "utf-8"),
+    fsp3.writeFile(vttPath, vtt, "utf-8"),
+    fsp3.writeFile(assPath, ass, "utf-8")
+  ]);
+  const paths = [srtPath, vttPath, assPath];
+  logger_default.info(`Captions saved: ${paths.join(", ")}`);
+  return paths;
+}
+
+// src/agents/SummaryAgent.ts
+import { promises as fs8 } from "fs";
+import path8 from "path";
+
+// src/providers/CopilotProvider.ts
+import { CopilotClient } from "@github/copilot-sdk";
+var DEFAULT_MODEL = "Claude Opus 4.6";
+var DEFAULT_TIMEOUT_MS = 3e5;
+var CopilotProvider = class {
+  name = "copilot";
+  client = null;
+  isAvailable() {
+    return true;
+  }
+  getDefaultModel() {
+    return DEFAULT_MODEL;
+  }
+  async createSession(config2) {
+    if (!this.client) {
+      this.client = new CopilotClient({ autoStart: true, logLevel: "error" });
+    }
+    const copilotSession = await this.client.createSession({
+      systemMessage: { mode: "replace", content: config2.systemPrompt },
+      tools: config2.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters,
+        handler: t.handler
+      })),
+      streaming: config2.streaming ?? true
+    });
+    return new CopilotSessionWrapper(
+      copilotSession,
+      config2.timeoutMs ?? DEFAULT_TIMEOUT_MS
+    );
+  }
+  /** Tear down the underlying Copilot client. */
+  async close() {
+    try {
+      if (this.client) {
+        await this.client.stop();
+        this.client = null;
+      }
+    } catch (err) {
+      logger_default.error(`[CopilotProvider] Error during close: ${err}`);
+    }
+  }
+};
+var CopilotSessionWrapper = class {
+  constructor(session, timeoutMs) {
+    this.session = session;
+    this.timeoutMs = timeoutMs;
+    this.setupEventForwarding();
+    this.setupUsageTracking();
+  }
+  eventHandlers = /* @__PURE__ */ new Map();
+  // Latest usage data captured from assistant.usage events
+  lastUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  lastCost;
+  lastQuotaSnapshots;
+  async sendAndWait(message) {
+    const start = Date.now();
+    this.lastUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    this.lastCost = void 0;
+    this.lastQuotaSnapshots = void 0;
+    const response = await this.session.sendAndWait(
+      { prompt: message },
+      this.timeoutMs
+    );
+    const content = response?.data?.content ?? "";
+    const toolCalls = [];
+    return {
+      content,
+      toolCalls,
+      usage: this.lastUsage,
+      cost: this.lastCost,
+      quotaSnapshots: this.lastQuotaSnapshots,
+      durationMs: Date.now() - start
+    };
+  }
+  on(event, handler) {
+    const handlers = this.eventHandlers.get(event) ?? [];
+    handlers.push(handler);
+    this.eventHandlers.set(event, handlers);
+  }
+  async close() {
+    await this.session.destroy();
+    this.eventHandlers.clear();
+  }
+  /** Capture assistant.usage events for token/cost tracking. */
+  setupUsageTracking() {
+    this.session.on((event) => {
+      if (event.type === "assistant.usage") {
+        const d = event.data;
+        this.lastUsage = {
+          inputTokens: d.inputTokens ?? 0,
+          outputTokens: d.outputTokens ?? 0,
+          totalTokens: (d.inputTokens ?? 0) + (d.outputTokens ?? 0),
+          cacheReadTokens: d.cacheReadTokens,
+          cacheWriteTokens: d.cacheWriteTokens
+        };
+        if (d.cost != null) {
+          this.lastCost = {
+            amount: d.cost,
+            unit: "premium_requests",
+            model: d.model ?? DEFAULT_MODEL,
+            multiplier: d.multiplier
+          };
+        }
+        if (d.quotaSnapshots != null) {
+          this.lastQuotaSnapshots = d.quotaSnapshots;
+        }
+      }
+    });
+  }
+  /** Forward CopilotSession events to ProviderEvent subscribers. */
+  setupEventForwarding() {
+    this.session.on((event) => {
+      switch (event.type) {
+        case "assistant.message_delta":
+          this.emit("delta", event.data);
+          break;
+        case "tool.execution_start":
+          this.emit("tool_start", event.data);
+          break;
+        case "tool.execution_complete":
+          this.emit("tool_end", event.data);
+          break;
+        case "assistant.usage":
+          this.emit("usage", event.data);
+          break;
+        case "session.error":
+          this.emit("error", event.data);
+          break;
+      }
+    });
+  }
+  emit(type, data) {
+    const handlers = this.eventHandlers.get(type);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler({ type, data });
+      }
+    }
+  }
+};
+
+// src/providers/OpenAIProvider.ts
+import OpenAI2 from "openai";
+
+// src/config/pricing.ts
+var COPILOT_PRU_OVERAGE_RATE = 0.04;
+var MODEL_PRICING = {
+  // === OpenAI Models (from Copilot model picker) ===
+  "gpt-4o": { inputPer1M: 2.5, outputPer1M: 10, pruMultiplier: 0, copilotIncluded: true },
+  "gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.6, pruMultiplier: 0, copilotIncluded: true },
+  "gpt-4.1": { inputPer1M: 2, outputPer1M: 8, pruMultiplier: 0, copilotIncluded: true },
+  "gpt-4.1-mini": { inputPer1M: 0.4, outputPer1M: 1.6 },
+  "gpt-5-mini": { inputPer1M: 0.15, outputPer1M: 0.6, pruMultiplier: 0, copilotIncluded: true },
+  "gpt-5": { inputPer1M: 2.5, outputPer1M: 10, pruMultiplier: 1 },
+  "gpt-5-codex": { inputPer1M: 2.5, outputPer1M: 10, pruMultiplier: 1 },
+  "gpt-5.1": { inputPer1M: 2.5, outputPer1M: 10, pruMultiplier: 1 },
+  "gpt-5.1-codex": { inputPer1M: 2.5, outputPer1M: 10, pruMultiplier: 1 },
+  "gpt-5.1-codex-max": { inputPer1M: 2.5, outputPer1M: 10, pruMultiplier: 1 },
+  "gpt-5.1-codex-mini": { inputPer1M: 0.15, outputPer1M: 0.6, pruMultiplier: 0.33 },
+  "gpt-5.2": { inputPer1M: 2.5, outputPer1M: 10, pruMultiplier: 1 },
+  "gpt-5.2-codex": { inputPer1M: 2.5, outputPer1M: 10, pruMultiplier: 1 },
+  "o3": { inputPer1M: 10, outputPer1M: 40, pruMultiplier: 5 },
+  "o4-mini-high": { inputPer1M: 1.1, outputPer1M: 4.4, pruMultiplier: 20 },
+  // === Anthropic Models (from Copilot model picker) ===
+  "claude-haiku-4.5": { inputPer1M: 0.8, outputPer1M: 4, pruMultiplier: 0.33 },
+  "claude-sonnet-4": { inputPer1M: 3, outputPer1M: 15, pruMultiplier: 1 },
+  "claude-sonnet-4.5": { inputPer1M: 3, outputPer1M: 15, pruMultiplier: 1 },
+  "claude-opus-4.5": { inputPer1M: 15, outputPer1M: 75, pruMultiplier: 3 },
+  "claude-opus-4.6": { inputPer1M: 5, outputPer1M: 25, pruMultiplier: 3 },
+  "claude-opus-4.6-fast": { inputPer1M: 5, outputPer1M: 25, pruMultiplier: 9 },
+  // === Google Models (from Copilot model picker) ===
+  "gemini-2.5-pro": { inputPer1M: 1.25, outputPer1M: 5, pruMultiplier: 1 },
+  "gemini-3-flash": { inputPer1M: 0.1, outputPer1M: 0.4, pruMultiplier: 0.33 },
+  "gemini-3-pro": { inputPer1M: 1.25, outputPer1M: 5, pruMultiplier: 1 }
+};
+function calculateTokenCost(model, inputTokens, outputTokens) {
+  const pricing = getModelPricing(model);
+  if (!pricing || !pricing.inputPer1M && !pricing.outputPer1M) return 0;
+  const inputCost = (pricing.inputPer1M ?? 0) / 1e6 * inputTokens;
+  const outputCost = (pricing.outputPer1M ?? 0) / 1e6 * outputTokens;
+  return inputCost + outputCost;
+}
+function calculatePRUCost(model) {
+  const pricing = getModelPricing(model);
+  if (!pricing) return 1;
+  if (pricing.copilotIncluded) return 0;
+  return pricing.pruMultiplier ?? 1;
+}
+function getModelPricing(model) {
+  return MODEL_PRICING[model] ?? MODEL_PRICING[model.toLowerCase()] ?? Object.entries(MODEL_PRICING).find(
+    ([key]) => model.toLowerCase().includes(key.toLowerCase())
+  )?.[1];
+}
+
+// src/providers/OpenAIProvider.ts
+var MAX_TOOL_ROUNDS = 50;
+function toOpenAITools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }
+  }));
+}
+function buildHandlerMap(tools) {
+  return new Map(tools.map((t) => [t.name, t.handler]));
+}
+function addUsage(a, b) {
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    totalTokens: a.totalTokens + b.totalTokens
+  };
+}
+var OpenAISession = class {
+  client;
+  model;
+  messages;
+  tools;
+  handlers;
+  listeners = /* @__PURE__ */ new Map();
+  timeoutMs;
+  constructor(client, config2, model) {
+    this.client = client;
+    this.model = model;
+    this.messages = [{ role: "system", content: config2.systemPrompt }];
+    this.tools = toOpenAITools(config2.tools);
+    this.handlers = buildHandlerMap(config2.tools);
+    this.timeoutMs = config2.timeoutMs;
+  }
+  // ── public API ─────────────────────────────────────────────────────
+  async sendAndWait(message) {
+    this.messages.push({ role: "user", content: message });
+    let cumulative = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    const start = Date.now();
+    let toolRound = 0;
+    while (true) {
+      if (++toolRound > MAX_TOOL_ROUNDS) {
+        logger_default.warn(`OpenAI agent exceeded ${MAX_TOOL_ROUNDS} tool rounds \u2014 aborting to prevent runaway`);
+        throw new Error(`Max tool rounds (${MAX_TOOL_ROUNDS}) exceeded \u2014 possible infinite loop`);
+      }
+      const controller = new AbortController();
+      const timeoutId = this.timeoutMs ? setTimeout(() => controller.abort(), this.timeoutMs) : void 0;
+      let response;
+      try {
+        response = await this.client.chat.completions.create(
+          {
+            model: this.model,
+            messages: this.messages,
+            ...this.tools.length > 0 ? { tools: this.tools } : {}
+          },
+          { signal: controller.signal }
+        );
+      } finally {
+        if (timeoutId) clearTimeout(timeoutId);
+      }
+      const choice = response.choices[0];
+      const assistantMsg = choice.message;
+      if (response.usage) {
+        const iterUsage = {
+          inputTokens: response.usage.prompt_tokens,
+          outputTokens: response.usage.completion_tokens,
+          totalTokens: response.usage.total_tokens
+        };
+        cumulative = addUsage(cumulative, iterUsage);
+        this.emit("usage", iterUsage);
+      }
+      this.messages.push(assistantMsg);
+      const toolCalls = assistantMsg.tool_calls;
+      if (!toolCalls || toolCalls.length === 0) {
+        const cost = calculateTokenCost(this.model, cumulative.inputTokens, cumulative.outputTokens);
+        return {
+          content: assistantMsg.content ?? "",
+          toolCalls: [],
+          usage: cumulative,
+          cost: { amount: cost, unit: "usd", model: this.model },
+          durationMs: Date.now() - start
+        };
+      }
+      for (const tc of toolCalls) {
+        if (tc.type !== "function") continue;
+        const fnName = tc.function.name;
+        const handler = this.handlers.get(fnName);
+        let result;
+        if (!handler) {
+          logger_default.warn(`OpenAI requested unknown tool: ${fnName}`);
+          result = { error: `Unknown tool: ${fnName}` };
+        } else {
+          this.emit("tool_start", { name: fnName, arguments: tc.function.arguments });
+          try {
+            const args = JSON.parse(tc.function.arguments);
+            result = await handler(args);
+          } catch (err) {
+            logger_default.error(`Tool ${fnName} failed: ${err}`);
+            result = { error: String(err) };
+          }
+          this.emit("tool_end", { name: fnName, result });
+        }
+        this.messages.push({
+          role: "tool",
+          tool_call_id: tc.id,
+          content: typeof result === "string" ? result : JSON.stringify(result)
+        });
+      }
+    }
+  }
+  on(event, handler) {
+    const list = this.listeners.get(event) ?? [];
+    list.push(handler);
+    this.listeners.set(event, list);
+  }
+  async close() {
+    this.messages = [];
+    this.listeners.clear();
+  }
+  // ── internals ──────────────────────────────────────────────────────
+  emit(type, data) {
+    for (const handler of this.listeners.get(type) ?? []) {
+      try {
+        handler({ type, data });
+      } catch {
+      }
+    }
+  }
+};
+var OpenAIProvider = class {
+  name = "openai";
+  isAvailable() {
+    return !!process.env.OPENAI_API_KEY;
+  }
+  getDefaultModel() {
+    return "gpt-4o";
+  }
+  async createSession(config2) {
+    const client = new OpenAI2();
+    const model = config2.model ?? this.getDefaultModel();
+    logger_default.info(`OpenAI session created (model=${model}, tools=${config2.tools.length})`);
+    return new OpenAISession(client, config2, model);
+  }
+};
+
+// src/providers/ClaudeProvider.ts
+import Anthropic from "@anthropic-ai/sdk";
+var DEFAULT_MODEL2 = "claude-opus-4.6";
+var DEFAULT_MAX_TOKENS = 8192;
+var MAX_TOOL_ROUNDS2 = 50;
+function toAnthropicTools(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.parameters
+  }));
+}
+function extractText(content) {
+  return content.filter((b) => b.type === "text").map((b) => b.text).join("");
+}
+function extractToolUse(content) {
+  return content.filter((b) => b.type === "tool_use");
+}
+var ClaudeSession = class {
+  client;
+  systemPrompt;
+  tools;
+  anthropicTools;
+  messages = [];
+  model;
+  maxTokens;
+  handlers = /* @__PURE__ */ new Map();
+  timeoutMs;
+  constructor(client, config2) {
+    this.client = client;
+    this.systemPrompt = config2.systemPrompt;
+    this.tools = config2.tools;
+    this.anthropicTools = toAnthropicTools(config2.tools);
+    this.model = config2.model ?? DEFAULT_MODEL2;
+    this.maxTokens = DEFAULT_MAX_TOKENS;
+    this.timeoutMs = config2.timeoutMs;
+  }
+  on(event, handler) {
+    const list = this.handlers.get(event) ?? [];
+    list.push(handler);
+    this.handlers.set(event, list);
+  }
+  emit(type, data) {
+    for (const handler of this.handlers.get(type) ?? []) {
+      handler({ type, data });
+    }
+  }
+  async sendAndWait(message) {
+    this.messages.push({ role: "user", content: message });
+    let cumulativeUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0
+    };
+    const startMs = Date.now();
+    let toolRound = 0;
+    while (true) {
+      if (++toolRound > MAX_TOOL_ROUNDS2) {
+        logger_default.warn(`Claude agent exceeded ${MAX_TOOL_ROUNDS2} tool rounds \u2014 aborting to prevent runaway`);
+        throw new Error(`Max tool rounds (${MAX_TOOL_ROUNDS2}) exceeded \u2014 possible infinite loop`);
+      }
+      const controller = new AbortController();
+      const timeoutId = this.timeoutMs ? setTimeout(() => controller.abort(), this.timeoutMs) : void 0;
+      let response;
+      try {
+        response = await this.client.messages.create(
+          {
+            model: this.model,
+            max_tokens: this.maxTokens,
+            system: this.systemPrompt,
+            messages: this.messages,
+            ...this.anthropicTools.length > 0 ? { tools: this.anthropicTools } : {}
+          },
+          { signal: controller.signal }
+        );
+      } finally {
+        if (timeoutId) clearTimeout(timeoutId);
+      }
+      cumulativeUsage.inputTokens += response.usage.input_tokens;
+      cumulativeUsage.outputTokens += response.usage.output_tokens;
+      cumulativeUsage.totalTokens = cumulativeUsage.inputTokens + cumulativeUsage.outputTokens;
+      if (response.usage.cache_read_input_tokens) {
+        cumulativeUsage.cacheReadTokens = (cumulativeUsage.cacheReadTokens ?? 0) + response.usage.cache_read_input_tokens;
+      }
+      if (response.usage.cache_creation_input_tokens) {
+        cumulativeUsage.cacheWriteTokens = (cumulativeUsage.cacheWriteTokens ?? 0) + response.usage.cache_creation_input_tokens;
+      }
+      this.emit("usage", cumulativeUsage);
+      this.messages.push({ role: "assistant", content: response.content });
+      const toolUseBlocks = extractToolUse(response.content);
+      if (toolUseBlocks.length === 0 || response.stop_reason === "end_turn") {
+        const text = extractText(response.content);
+        const cost = calculateTokenCost(
+          this.model,
+          cumulativeUsage.inputTokens,
+          cumulativeUsage.outputTokens
+        );
+        return {
+          content: text,
+          toolCalls: [],
+          usage: cumulativeUsage,
+          cost: cost > 0 ? { amount: cost, unit: "usd", model: this.model } : void 0,
+          durationMs: Date.now() - startMs
+        };
+      }
+      const toolResults = [];
+      for (const block of toolUseBlocks) {
+        const tool = this.tools.find((t) => t.name === block.name);
+        if (!tool) {
+          logger_default.warn(`Claude requested unknown tool: ${block.name}`);
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: block.id,
+            content: JSON.stringify({ error: `Unknown tool: ${block.name}` })
+          });
+          continue;
+        }
+        this.emit("tool_start", { name: block.name, arguments: block.input });
+        try {
+          const result = await tool.handler(block.input);
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: block.id,
+            content: JSON.stringify(result)
+          });
+          this.emit("tool_end", { name: block.name, result });
+        } catch (err) {
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          logger_default.error(`Tool ${block.name} failed: ${errorMsg}`);
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: block.id,
+            content: JSON.stringify({ error: errorMsg }),
+            is_error: true
+          });
+          this.emit("error", { name: block.name, error: errorMsg });
+        }
+      }
+      this.messages.push({ role: "user", content: toolResults });
+    }
+  }
+  async close() {
+    this.messages = [];
+    this.handlers.clear();
+  }
+};
+var ClaudeProvider = class {
+  name = "claude";
+  isAvailable() {
+    return !!process.env.ANTHROPIC_API_KEY;
+  }
+  getDefaultModel() {
+    return DEFAULT_MODEL2;
+  }
+  async createSession(config2) {
+    const client = new Anthropic();
+    return new ClaudeSession(client, config2);
+  }
+};
+
+// src/providers/index.ts
+var providers = {
+  copilot: () => new CopilotProvider(),
+  openai: () => new OpenAIProvider(),
+  claude: () => new ClaudeProvider()
+};
+var currentProvider = null;
+var currentProviderName = null;
+function getProvider(name) {
+  const raw = name ?? (process.env.LLM_PROVIDER || "copilot").trim().toLowerCase();
+  const providerName = raw;
+  if (currentProvider && currentProviderName === providerName) {
+    return currentProvider;
+  }
+  currentProvider?.close?.().catch(() => {
+  });
+  if (!providers[providerName]) {
+    throw new Error(
+      `Unknown LLM provider: "${providerName}". Valid options: ${Object.keys(providers).join(", ")}`
+    );
+  }
+  const provider = providers[providerName]();
+  if (!provider.isAvailable()) {
+    logger_default.warn(
+      `Provider "${providerName}" is not available (missing API key or config). Falling back to copilot provider.`
+    );
+    currentProvider = providers.copilot();
+    currentProviderName = "copilot";
+    return currentProvider;
+  }
+  logger_default.info(`Using LLM provider: ${providerName} (model: ${provider.getDefaultModel()})`);
+  currentProvider = provider;
+  currentProviderName = providerName;
+  return currentProvider;
+}
+
+// src/services/costTracker.ts
+var CostTracker = class {
+  records = [];
+  latestQuota;
+  currentAgent = "unknown";
+  currentStage = "unknown";
+  /** Set the current agent name (called by BaseAgent before LLM calls) */
+  setAgent(agent) {
+    this.currentAgent = agent;
+  }
+  /** Set the current pipeline stage */
+  setStage(stage) {
+    this.currentStage = stage;
+  }
+  /** Record a usage event from any provider */
+  recordUsage(provider, model, usage, cost, durationMs, quotaSnapshot) {
+    const finalCost = cost ?? {
+      amount: provider === "copilot" ? calculatePRUCost(model) : calculateTokenCost(model, usage.inputTokens, usage.outputTokens),
+      unit: provider === "copilot" ? "premium_requests" : "usd",
+      model
+    };
+    const record = {
+      timestamp: /* @__PURE__ */ new Date(),
+      provider,
+      model,
+      agent: this.currentAgent,
+      stage: this.currentStage,
+      usage,
+      cost: finalCost,
+      durationMs
+    };
+    this.records.push(record);
+    if (quotaSnapshot) {
+      this.latestQuota = quotaSnapshot;
+    }
+    logger_default.debug(
+      `[CostTracker] ${provider}/${model} | ${this.currentAgent} | in=${usage.inputTokens} out=${usage.outputTokens} | cost=${finalCost.amount.toFixed(4)} ${finalCost.unit}`
+    );
+  }
+  /** Get the full cost report */
+  getReport() {
+    const report = {
+      totalCostUSD: 0,
+      totalPRUs: 0,
+      totalTokens: { input: 0, output: 0, total: 0 },
+      byProvider: {},
+      byAgent: {},
+      byModel: {},
+      records: [...this.records],
+      copilotQuota: this.latestQuota
+    };
+    for (const record of this.records) {
+      const { provider, model, agent, usage, cost } = record;
+      report.totalTokens.input += usage.inputTokens;
+      report.totalTokens.output += usage.outputTokens;
+      report.totalTokens.total += usage.totalTokens;
+      const usdCost = cost.unit === "usd" ? cost.amount : cost.amount * COPILOT_PRU_OVERAGE_RATE;
+      const prus = cost.unit === "premium_requests" ? cost.amount : 0;
+      report.totalCostUSD += usdCost;
+      report.totalPRUs += prus;
+      if (!report.byProvider[provider]) report.byProvider[provider] = { costUSD: 0, prus: 0, calls: 0 };
+      report.byProvider[provider].costUSD += usdCost;
+      report.byProvider[provider].prus += prus;
+      report.byProvider[provider].calls += 1;
+      if (!report.byAgent[agent]) report.byAgent[agent] = { costUSD: 0, prus: 0, calls: 0 };
+      report.byAgent[agent].costUSD += usdCost;
+      report.byAgent[agent].prus += prus;
+      report.byAgent[agent].calls += 1;
+      if (!report.byModel[model]) report.byModel[model] = { costUSD: 0, prus: 0, calls: 0 };
+      report.byModel[model].costUSD += usdCost;
+      report.byModel[model].prus += prus;
+      report.byModel[model].calls += 1;
+    }
+    return report;
+  }
+  /** Format report as human-readable string for console output */
+  formatReport() {
+    const report = this.getReport();
+    const lines = [
+      "",
+      "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
+      "  \u{1F4B0} Pipeline Cost Report",
+      "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
+      "",
+      `  Total Cost:    $${report.totalCostUSD.toFixed(4)} USD`
+    ];
+    if (report.totalPRUs > 0) {
+      lines.push(`  Total PRUs:    ${report.totalPRUs} premium requests`);
+    }
+    lines.push(
+      `  Total Tokens:  ${report.totalTokens.total.toLocaleString()} (${report.totalTokens.input.toLocaleString()} in / ${report.totalTokens.output.toLocaleString()} out)`,
+      `  LLM Calls:     ${this.records.length}`
+    );
+    if (report.copilotQuota) {
+      lines.push(
+        "",
+        `  Copilot Quota: ${report.copilotQuota.remainingPercentage.toFixed(1)}% remaining`,
+        `  Used/Total:    ${report.copilotQuota.usedRequests}/${report.copilotQuota.entitlementRequests} PRUs`
+      );
+      if (report.copilotQuota.resetDate) {
+        lines.push(`  Resets:        ${report.copilotQuota.resetDate}`);
+      }
+    }
+    if (Object.keys(report.byAgent).length > 1) {
+      lines.push("", "  By Agent:");
+      for (const [agent, data] of Object.entries(report.byAgent)) {
+        lines.push(`    ${agent}: $${data.costUSD.toFixed(4)} (${data.calls} calls)`);
+      }
+    }
+    if (Object.keys(report.byModel).length > 1) {
+      lines.push("", "  By Model:");
+      for (const [model, data] of Object.entries(report.byModel)) {
+        lines.push(`    ${model}: $${data.costUSD.toFixed(4)} (${data.calls} calls)`);
+      }
+    }
+    lines.push("", "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550", "");
+    return lines.join("\n");
+  }
+  /** Reset all tracking (for new pipeline run) */
+  reset() {
+    this.records = [];
+    this.latestQuota = void 0;
+    this.currentAgent = "unknown";
+    this.currentStage = "unknown";
+  }
+};
+var costTracker = new CostTracker();
+
+// src/agents/BaseAgent.ts
+var BaseAgent = class {
+  constructor(agentName, systemPrompt, provider) {
+    this.agentName = agentName;
+    this.systemPrompt = systemPrompt;
+    this.provider = provider ?? getProvider();
+  }
+  provider;
+  session = null;
+  /** Tools this agent exposes to the LLM. Override in subclasses. */
+  getTools() {
+    return [];
+  }
+  /**
+   * Send a user message to the agent and return the final response text.
+   *
+   * 1. Lazily creates an LLMSession via the provider
+   * 2. Registers event listeners for logging
+   * 3. Calls sendAndWait and records usage via CostTracker
+   */
+  async run(userMessage) {
+    if (!this.session) {
+      this.session = await this.provider.createSession({
+        systemPrompt: this.systemPrompt,
+        tools: this.getTools(),
+        streaming: true,
+        model: process.env.LLM_MODEL || void 0,
+        timeoutMs: 3e5
+        // 5 min timeout
+      });
+      this.setupEventHandlers(this.session);
+    }
+    logger_default.info(`[${this.agentName}] Sending message: ${userMessage.substring(0, 80)}\u2026`);
+    costTracker.setAgent(this.agentName);
+    const response = await this.session.sendAndWait(userMessage);
+    costTracker.recordUsage(
+      this.provider.name,
+      response.cost?.model ?? this.provider.getDefaultModel(),
+      response.usage,
+      response.cost,
+      response.durationMs,
+      response.quotaSnapshots ? Object.values(response.quotaSnapshots)[0] : void 0
+    );
+    const content = response.content;
+    logger_default.info(`[${this.agentName}] Response received (${content.length} chars)`);
+    return content;
+  }
+  /** Wire up session event listeners for logging. */
+  setupEventHandlers(session) {
+    session.on("delta", (event) => {
+      logger_default.debug(`[${this.agentName}] delta: ${JSON.stringify(event.data)}`);
+    });
+    session.on("tool_start", (event) => {
+      logger_default.info(`[${this.agentName}] tool start: ${JSON.stringify(event.data)}`);
+    });
+    session.on("tool_end", (event) => {
+      logger_default.info(`[${this.agentName}] tool done: ${JSON.stringify(event.data)}`);
+    });
+    session.on("error", (event) => {
+      logger_default.error(`[${this.agentName}] error: ${JSON.stringify(event.data)}`);
+    });
+  }
+  /** Tear down the session. */
+  async destroy() {
+    try {
+      if (this.session) {
+        await this.session.close();
+        this.session = null;
+      }
+    } catch (err) {
+      logger_default.error(`[${this.agentName}] Error during destroy: ${err}`);
+    }
+  }
+};
+
+// src/tools/ffmpeg/frameCapture.ts
+import ffmpeg3 from "fluent-ffmpeg";
+import { promises as fs7 } from "fs";
+import path7 from "path";
+var ffmpegPath2 = getFFmpegPath();
+var ffprobePath2 = getFFprobePath();
+ffmpeg3.setFfmpegPath(ffmpegPath2);
+ffmpeg3.setFfprobePath(ffprobePath2);
+async function captureFrame(videoPath, timestamp, outputPath) {
+  const outputDir = path7.dirname(outputPath);
+  await fs7.mkdir(outputDir, { recursive: true });
+  logger_default.info(`Capturing frame at ${timestamp}s \u2192 ${outputPath}`);
+  return new Promise((resolve, reject) => {
+    ffmpeg3(videoPath).seekInput(timestamp).frames(1).output(outputPath).on("end", () => {
+      logger_default.info(`Frame captured: ${outputPath}`);
+      resolve(outputPath);
+    }).on("error", (err) => {
+      logger_default.error(`Frame capture failed: ${err.message}`);
+      reject(new Error(`Frame capture failed: ${err.message}`));
+    }).run();
+  });
+}
+
+// src/agents/SummaryAgent.ts
+function fmtTime(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = Math.floor(seconds % 60);
+  return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+}
+function buildTranscriptBlock(transcript) {
+  return transcript.segments.map((seg) => `[${fmtTime(seg.start)} \u2192 ${fmtTime(seg.end)}] ${seg.text.trim()}`).join("\n");
+}
+function buildSystemPrompt(shortsInfo, socialPostsInfo, captionsInfo, chaptersInfo) {
+  const brand = getBrandConfig();
+  return `You are a Video Summary Agent writing from the perspective of ${brand.name} (${brand.handle}).
+Brand voice: ${brand.voice.tone}. ${brand.voice.personality} ${brand.voice.style}
+
+Your job is to analyse a video transcript and produce a beautiful, narrative-style Markdown README.
+
+**Workflow**
+1. Read the transcript carefully.
+2. Identify 3-8 key topics, decisions, highlights, or memorable moments.
+3. For each highlight, decide on a representative timestamp and call the "capture_frame" tool to grab a screenshot.
+4. Once all frames are captured, call the "write_summary" tool with the final Markdown.
+
+**Markdown structure \u2014 follow this layout exactly:**
+
+\`\`\`
+# [Video Title]
+
+> [Compelling one-line hook/tagline that captures the video's value]
+
+[2-3 paragraph natural summary that reads like a blog post, NOT a timeline.
+Weave in key insights naturally. Write in the brand voice: ${brand.voice.tone}.
+${brand.contentGuidelines.blogFocus}]
+
+---
+
+## Key Moments
+
+[For each key topic: write a narrative paragraph (not bullet points).
+Embed the timestamp as an inline badge like \`[0:12]\` within the text, NOT as a section header.
+Embed the screenshot naturally within or after the paragraph.
+Use blockquotes (>) for standout quotes or insights.]
+
+![Description](thumbnails/snapshot-001.png)
+
+[Continue with next topic paragraph...]
+
+---
+
+## \u{1F4CA} Quick Reference
+
+| Topic | Timestamp |
+|-------|-----------|
+| Topic name | \`M:SS\` |
+| ... | ... |
+
+---
+${chaptersInfo}
+${shortsInfo}
+${socialPostsInfo}
+${captionsInfo}
+
+---
+
+*Generated on [DATE] \u2022 Duration: [DURATION] \u2022 Tags: [relevant tags]*
+\`\`\`
+
+**Writing style rules**
+- Write in a narrative, blog-post style \u2014 NOT a timestamp-driven timeline.
+- Timestamps appear as subtle inline badges like \`[0:12]\` or \`[1:30]\` within sentences, never as section headers.
+- The summary paragraphs should flow naturally and be enjoyable to read.
+- Use the brand perspective: ${brand.voice.personality}
+- Topics to emphasize: ${brand.advocacy.interests.join(", ")}
+- Avoid: ${brand.advocacy.avoids.join(", ")}
+
+**Screenshot distribution rules \u2014 CRITICAL**
+- You MUST spread screenshots across the ENTIRE video duration, from beginning to end.
+- Divide the video into equal segments based on the number of screenshots you plan to capture, and pick one timestamp from each segment.
+- NO MORE than 2 screenshots should fall within the same 60-second window.
+- If the video is longer than 2 minutes, your first screenshot must NOT be in the first 10% and your last screenshot must be in the final 30% of the video.
+- Use the suggested timestamp ranges provided in the user message as guidance, but pick the exact moment within each range that best matches a key topic in the transcript.
+
+**Tool rules**
+- Always call "capture_frame" BEFORE "write_summary".
+- The snapshot index must be a 1-based integer; the filename will be snapshot-001.png, etc.
+- In the Markdown, reference screenshots as \`thumbnails/snapshot-001.png\` (relative path).
+- Call "write_summary" exactly once with the complete Markdown string.`;
+}
+var SummaryAgent = class extends BaseAgent {
+  videoPath;
+  outputDir;
+  snapshots = [];
+  constructor(videoPath, outputDir, systemPrompt) {
+    super("SummaryAgent", systemPrompt);
+    this.videoPath = videoPath;
+    this.outputDir = outputDir;
+  }
+  // Resolved paths
+  get thumbnailDir() {
+    return path8.join(this.outputDir, "thumbnails");
+  }
+  get markdownPath() {
+    return path8.join(this.outputDir, "README.md");
+  }
+  /* ── Tools exposed to the LLM ─────────────────────────────────────────── */
+  getTools() {
+    return [
+      {
+        name: "capture_frame",
+        description: "Capture a screenshot from the video at a specific timestamp. Provide: timestamp (seconds), description (what is shown), index (1-based integer for filename).",
+        parameters: {
+          type: "object",
+          properties: {
+            timestamp: { type: "number", description: "Timestamp in seconds to capture" },
+            description: { type: "string", description: "Brief description of the visual moment" },
+            index: { type: "integer", description: "1-based snapshot index (used for filename)" }
+          },
+          required: ["timestamp", "description", "index"]
+        },
+        handler: async (rawArgs) => {
+          const args = rawArgs;
+          return this.handleCaptureFrame(args);
+        }
+      },
+      {
+        name: "write_summary",
+        description: "Write the final Markdown summary to disk. Provide: markdown (full README content), title, overview, and keyTopics array.",
+        parameters: {
+          type: "object",
+          properties: {
+            markdown: { type: "string", description: "Complete Markdown content for README.md" },
+            title: { type: "string", description: "Video title" },
+            overview: { type: "string", description: "Short overview paragraph" },
+            keyTopics: {
+              type: "array",
+              items: { type: "string" },
+              description: "List of key topic names"
+            }
+          },
+          required: ["markdown", "title", "overview", "keyTopics"]
+        },
+        handler: async (rawArgs) => {
+          const args = rawArgs;
+          return this.handleWriteSummary(args);
+        }
+      }
+    ];
+  }
+  /* ── Tool dispatch (required by BaseAgent) ─────────────────────────────── */
+  async handleToolCall(toolName, args) {
+    switch (toolName) {
+      case "capture_frame":
+        return this.handleCaptureFrame(args);
+      case "write_summary":
+        return this.handleWriteSummary(args);
+      default:
+        throw new Error(`Unknown tool: ${toolName}`);
+    }
+  }
+  /* ── Tool implementations ──────────────────────────────────────────────── */
+  async handleCaptureFrame(args) {
+    const idx = String(args.index).padStart(3, "0");
+    const filename = `snapshot-${idx}.png`;
+    const outputPath = path8.join(this.thumbnailDir, filename);
+    await captureFrame(this.videoPath, args.timestamp, outputPath);
+    const snapshot = {
+      timestamp: args.timestamp,
+      description: args.description,
+      outputPath
+    };
+    this.snapshots.push(snapshot);
+    logger_default.info(`[SummaryAgent] Captured snapshot ${idx} at ${fmtTime(args.timestamp)}`);
+    return `Frame captured: thumbnails/${filename}`;
+  }
+  async handleWriteSummary(args) {
+    await fs8.mkdir(this.outputDir, { recursive: true });
+    await fs8.writeFile(this.markdownPath, args.markdown, "utf-8");
+    logger_default.info(`[SummaryAgent] Wrote summary \u2192 ${this.markdownPath}`);
+    return `Summary written to ${this.markdownPath}`;
+  }
+  /** Expose collected data after the run. */
+  getResult(args) {
+    return {
+      title: args.title,
+      overview: args.overview,
+      keyTopics: args.keyTopics,
+      snapshots: this.snapshots,
+      markdownPath: this.markdownPath
+    };
+  }
+};
+function buildShortsSection(shorts) {
+  if (!shorts || shorts.length === 0) {
+    return `
+## \u2702\uFE0F Shorts
+
+| Short | Duration | Description |
+|-------|----------|-------------|
+| *Shorts will appear here once generated* | | |`;
+  }
+  const rows = shorts.map((s) => `| [${s.title}](shorts/${s.slug}.mp4) | ${Math.round(s.totalDuration)}s | ${s.description} |`).join("\n");
+  return `
+## \u2702\uFE0F Shorts
+
+| Short | Duration | Description |
+|-------|----------|-------------|
+${rows}`;
+}
+function buildSocialPostsSection() {
+  return `
+## \u{1F4F1} Social Media Posts
+
+- [TikTok](social-posts/tiktok.md)
+- [YouTube](social-posts/youtube.md)
+- [Instagram](social-posts/instagram.md)
+- [LinkedIn](social-posts/linkedin.md)
+- [X / Twitter](social-posts/x.md)
+- [Dev.to Blog](social-posts/devto.md)`;
+}
+function buildCaptionsSection() {
+  return `
+## \u{1F3AC} Captions
+
+- [SRT](captions/captions.srt) | [VTT](captions/captions.vtt) | [ASS (Styled)](captions/captions.ass)`;
+}
+function toYouTubeTimestamp(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = Math.floor(seconds % 60);
+  return h > 0 ? `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}` : `${m}:${String(s).padStart(2, "0")}`;
+}
+function buildChaptersSection(chapters) {
+  if (!chapters || chapters.length === 0) {
+    return "";
+  }
+  const rows = chapters.map((ch) => `| \`${toYouTubeTimestamp(ch.timestamp)}\` | ${ch.title} | ${ch.description} |`).join("\n");
+  return `
+## \u{1F4D1} Chapters
+
+| Time | Chapter | Description |
+|------|---------|-------------|
+${rows}
+
+> \u{1F4CB} [YouTube Timestamps](chapters/chapters-youtube.txt) \u2022 [Markdown](chapters/chapters.md) \u2022 [JSON](chapters/chapters.json)`;
+}
+async function generateSummary(video, transcript, shorts, chapters) {
+  const config2 = getConfig();
+  const outputDir = path8.join(config2.OUTPUT_DIR, video.slug);
+  const shortsInfo = buildShortsSection(shorts);
+  const socialPostsInfo = buildSocialPostsSection();
+  const captionsInfo = buildCaptionsSection();
+  const chaptersInfo = buildChaptersSection(chapters);
+  const systemPrompt = buildSystemPrompt(shortsInfo, socialPostsInfo, captionsInfo, chaptersInfo);
+  const agent = new SummaryAgent(video.repoPath, outputDir, systemPrompt);
+  const transcriptBlock = buildTranscriptBlock(transcript);
+  const screenshotCount = Math.min(8, Math.max(3, Math.round(video.duration / 120)));
+  const interval = video.duration / screenshotCount;
+  const suggestedRanges = Array.from({ length: screenshotCount }, (_, i) => {
+    const center = Math.round(interval * (i + 0.5));
+    const lo = Math.max(0, Math.round(center - interval / 2));
+    const hi = Math.min(Math.round(video.duration), Math.round(center + interval / 2));
+    return `${fmtTime(lo)}\u2013${fmtTime(hi)} (${lo}s\u2013${hi}s)`;
+  }).join(", ");
+  const userPrompt = [
+    `**Video:** ${video.filename}`,
+    `**Duration:** ${fmtTime(video.duration)} (${Math.round(video.duration)} seconds)`,
+    `**Date:** ${video.createdAt.toISOString().slice(0, 10)}`,
+    "",
+    `**Suggested screenshot time ranges (one screenshot per range):**`,
+    suggestedRanges,
+    "",
+    "---",
+    "",
+    "**Transcript:**",
+    "",
+    transcriptBlock
+  ].join("\n");
+  let lastWriteArgs;
+  const origHandleWrite = agent.handleWriteSummary.bind(agent);
+  agent.handleWriteSummary = async (args) => {
+    lastWriteArgs = args;
+    return origHandleWrite(args);
+  };
+  try {
+    await agent.run(userPrompt);
+    if (!lastWriteArgs) {
+      throw new Error("SummaryAgent did not call write_summary");
+    }
+    return agent.getResult(lastWriteArgs);
+  } finally {
+    await agent.destroy();
+  }
+}
+
+// src/tools/ffmpeg/clipExtraction.ts
+import ffmpeg4 from "fluent-ffmpeg";
+import { execFile } from "child_process";
+import { promises as fs9 } from "fs";
+import pathMod from "path";
+import { randomUUID } from "crypto";
+var ffmpegPath3 = getFFmpegPath();
+var ffprobePath3 = getFFprobePath();
+ffmpeg4.setFfmpegPath(ffmpegPath3);
+ffmpeg4.setFfprobePath(ffprobePath3);
+var DEFAULT_FPS = 25;
+async function getVideoFps(videoPath) {
+  return new Promise((resolve) => {
+    execFile(
+      ffprobePath3,
+      ["-v", "error", "-select_streams", "v:0", "-show_entries", "stream=r_frame_rate", "-of", "csv=p=0", videoPath],
+      { timeout: 5e3 },
+      (error, stdout) => {
+        if (error || !stdout.trim()) {
+          resolve(DEFAULT_FPS);
+          return;
+        }
+        const parts = stdout.trim().split("/");
+        const fps = parts.length === 2 ? parseInt(parts[0]) / parseInt(parts[1]) : parseFloat(stdout.trim());
+        resolve(isFinite(fps) && fps > 0 ? Math.round(fps) : DEFAULT_FPS);
+      }
+    );
+  });
+}
+async function extractClip(videoPath, start, end, outputPath, buffer = 1) {
+  const outputDir = pathMod.dirname(outputPath);
+  await fs9.mkdir(outputDir, { recursive: true });
+  const bufferedStart = Math.max(0, start - buffer);
+  const bufferedEnd = end + buffer;
+  const duration = bufferedEnd - bufferedStart;
+  logger_default.info(`Extracting clip [${start}s\u2013${end}s] (buffered: ${bufferedStart.toFixed(2)}s\u2013${bufferedEnd.toFixed(2)}s) \u2192 ${outputPath}`);
+  return new Promise((resolve, reject) => {
+    ffmpeg4(videoPath).setStartTime(bufferedStart).setDuration(duration).outputOptions(["-c:v", "libx264", "-preset", "ultrafast", "-crf", "23", "-threads", "4", "-c:a", "aac", "-b:a", "128k"]).output(outputPath).on("end", () => {
+      logger_default.info(`Clip extraction complete: ${outputPath}`);
+      resolve(outputPath);
+    }).on("error", (err) => {
+      logger_default.error(`Clip extraction failed: ${err.message}`);
+      reject(new Error(`Clip extraction failed: ${err.message}`));
+    }).run();
+  });
+}
+async function extractCompositeClip(videoPath, segments, outputPath, buffer = 1) {
+  if (!segments || segments.length === 0) {
+    throw new Error("At least one segment is required");
+  }
+  if (segments.length === 1) {
+    return extractClip(videoPath, segments[0].start, segments[0].end, outputPath, buffer);
+  }
+  const outputDir = pathMod.dirname(outputPath);
+  await fs9.mkdir(outputDir, { recursive: true });
+  const tempDir = pathMod.join(outputDir, `.temp-${randomUUID()}`);
+  await fs9.mkdir(tempDir, { recursive: true });
+  const tempFiles = [];
+  try {
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      const tempPath = pathMod.join(tempDir, `segment-${i}.mp4`);
+      tempFiles.push(tempPath);
+      const bufferedStart = Math.max(0, seg.start - buffer);
+      const bufferedEnd = seg.end + buffer;
+      logger_default.info(`Extracting segment ${i + 1}/${segments.length} [${seg.start}s\u2013${seg.end}s] (buffered: ${bufferedStart.toFixed(2)}s\u2013${bufferedEnd.toFixed(2)}s)`);
+      await new Promise((resolve, reject) => {
+        ffmpeg4(videoPath).setStartTime(bufferedStart).setDuration(bufferedEnd - bufferedStart).outputOptions(["-threads", "4", "-preset", "ultrafast"]).output(tempPath).on("end", () => resolve()).on("error", (err) => reject(new Error(`Segment ${i} extraction failed: ${err.message}`))).run();
+      });
+    }
+    const concatListPath = pathMod.join(tempDir, "concat-list.txt");
+    const listContent = tempFiles.map((f) => `file '${f.replace(/'/g, "'\\''")}'`).join("\n");
+    await fs9.writeFile(concatListPath, listContent);
+    logger_default.info(`Concatenating ${segments.length} segments \u2192 ${outputPath}`);
+    await new Promise((resolve, reject) => {
+      ffmpeg4().input(concatListPath).inputOptions(["-f", "concat", "-safe", "0"]).outputOptions(["-c:v", "libx264", "-preset", "ultrafast", "-crf", "23", "-threads", "4", "-c:a", "aac"]).output(outputPath).on("end", () => resolve()).on("error", (err) => reject(new Error(`Concat failed: ${err.message}`))).run();
+    });
+    logger_default.info(`Composite clip complete: ${outputPath}`);
+    return outputPath;
+  } finally {
+    await fs9.rm(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function extractCompositeClipWithTransitions(videoPath, segments, outputPath, transitionDuration = 0.5, buffer = 1) {
+  if (!segments || segments.length === 0) {
+    throw new Error("At least one segment is required");
+  }
+  if (segments.length === 1) {
+    return extractClip(videoPath, segments[0].start, segments[0].end, outputPath, buffer);
+  }
+  if (segments.length === 2 && transitionDuration <= 0) {
+    return extractCompositeClip(videoPath, segments, outputPath, buffer);
+  }
+  const outputDir = pathMod.dirname(outputPath);
+  await fs9.mkdir(outputDir, { recursive: true });
+  const fps = await getVideoFps(videoPath);
+  const filterParts = [];
+  const segDurations = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const bufferedStart = Math.max(0, seg.start - buffer);
+    const bufferedEnd = seg.end + buffer;
+    const duration = bufferedEnd - bufferedStart;
+    segDurations.push(duration);
+    filterParts.push(
+      `[0:v]trim=start=${bufferedStart.toFixed(3)}:end=${bufferedEnd.toFixed(3)},setpts=PTS-STARTPTS,fps=${fps}[v${i}]`
+    );
+    filterParts.push(
+      `[0:a]atrim=start=${bufferedStart.toFixed(3)}:end=${bufferedEnd.toFixed(3)},asetpts=PTS-STARTPTS[a${i}]`
+    );
+  }
+  let prevVideo = "v0";
+  let prevAudio = "a0";
+  let cumulativeDuration = segDurations[0];
+  for (let i = 1; i < segments.length; i++) {
+    const offset = Math.max(0, cumulativeDuration - transitionDuration);
+    const outVideo = i === segments.length - 1 ? "vout" : `xv${i - 1}`;
+    const outAudio = i === segments.length - 1 ? "aout" : `xa${i - 1}`;
+    filterParts.push(
+      `[${prevVideo}][v${i}]xfade=transition=fade:duration=${transitionDuration.toFixed(3)}:offset=${offset.toFixed(3)}[${outVideo}]`
+    );
+    filterParts.push(
+      `[${prevAudio}][a${i}]acrossfade=d=${transitionDuration.toFixed(3)}[${outAudio}]`
+    );
+    prevVideo = outVideo;
+    prevAudio = outAudio;
+    cumulativeDuration = cumulativeDuration - transitionDuration + segDurations[i];
+  }
+  const filterComplex = filterParts.join(";\n");
+  const args = [
+    "-y",
+    "-i",
+    videoPath,
+    "-filter_complex",
+    filterComplex,
+    "-map",
+    "[vout]",
+    "-map",
+    "[aout]",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-crf",
+    "23",
+    "-threads",
+    "4",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "128k",
+    outputPath
+  ];
+  logger_default.info(`[ClipExtraction] Compositing ${segments.length} segments with xfade transitions \u2192 ${outputPath}`);
+  return new Promise((resolve, reject) => {
+    execFile(ffmpegPath3, args, { maxBuffer: 50 * 1024 * 1024 }, (error, _stdout, stderr) => {
+      if (error) {
+        logger_default.error(`[ClipExtraction] xfade composite failed: ${stderr}`);
+        reject(new Error(`xfade composite clip failed: ${error.message}`));
+        return;
+      }
+      logger_default.info(`[ClipExtraction] xfade composite complete: ${outputPath}`);
+      resolve(outputPath);
+    });
+  });
+}
+
+// src/tools/ffmpeg/captionBurning.ts
+import { execFile as execFile2 } from "child_process";
+import { promises as fs10 } from "fs";
+import pathMod2 from "path";
+import os from "os";
+import { fileURLToPath } from "url";
+var ffmpegPath4 = getFFmpegPath();
+var __dirname = pathMod2.dirname(fileURLToPath(import.meta.url));
+var FONTS_DIR = pathMod2.resolve(__dirname, "..", "..", "..", "assets", "fonts");
+async function burnCaptions(videoPath, assPath, outputPath) {
+  const outputDir = pathMod2.dirname(outputPath);
+  await fs10.mkdir(outputDir, { recursive: true });
+  logger_default.info(`Burning captions into video \u2192 ${outputPath}`);
+  const workDir = await fs10.mkdtemp(pathMod2.join(os.tmpdir(), "caption-"));
+  const tempAss = pathMod2.join(workDir, "captions.ass");
+  const tempOutput = pathMod2.join(workDir, "output.mp4");
+  await fs10.copyFile(assPath, tempAss);
+  const fontFiles = await fs10.readdir(FONTS_DIR);
+  for (const f of fontFiles) {
+    if (f.endsWith(".ttf") || f.endsWith(".otf")) {
+      await fs10.copyFile(pathMod2.join(FONTS_DIR, f), pathMod2.join(workDir, f));
+    }
+  }
+  const args = [
+    "-y",
+    "-i",
+    videoPath,
+    "-vf",
+    "ass=captions.ass:fontsdir=.",
+    "-c:a",
+    "copy",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-crf",
+    "23",
+    "-threads",
+    "4",
+    tempOutput
+  ];
+  return new Promise((resolve, reject) => {
+    execFile2(ffmpegPath4, args, { cwd: workDir, maxBuffer: 10 * 1024 * 1024 }, async (error, _stdout, stderr) => {
+      const cleanup = async () => {
+        const files = await fs10.readdir(workDir).catch(() => []);
+        for (const f of files) {
+          await fs10.unlink(pathMod2.join(workDir, f)).catch(() => {
+          });
+        }
+        await fs10.rmdir(workDir).catch(() => {
+        });
+      };
+      if (error) {
+        await cleanup();
+        logger_default.error(`Caption burning failed: ${stderr || error.message}`);
+        reject(new Error(`Caption burning failed: ${stderr || error.message}`));
+        return;
+      }
+      try {
+        await fs10.rename(tempOutput, outputPath);
+      } catch {
+        await fs10.copyFile(tempOutput, outputPath);
+      }
+      await cleanup();
+      logger_default.info(`Captions burned: ${outputPath}`);
+      resolve(outputPath);
+    });
+  });
+}
+
+// src/tools/ffmpeg/aspectRatio.ts
+import { execFile as execFile4 } from "child_process";
+import { promises as fs12 } from "fs";
+import pathMod3 from "path";
+
+// src/tools/ffmpeg/faceDetection.ts
+import { execFile as execFile3 } from "child_process";
+import { promises as fs11 } from "fs";
+import path9 from "path";
+import os2 from "os";
+import sharp from "sharp";
+var ffmpegPath5 = getFFmpegPath();
+var ffprobePath4 = getFFprobePath();
+var SAMPLE_FRAMES = 5;
+var ANALYSIS_WIDTH = 320;
+var ANALYSIS_HEIGHT = 180;
+var CORNER_FRACTION = 0.25;
+var MIN_SKIN_RATIO = 0.05;
+var MIN_CONFIDENCE = 0.3;
+var REFINE_MIN_EDGE_DIFF = 3;
+var REFINE_MIN_SIZE_FRAC = 0.05;
+var REFINE_MAX_SIZE_FRAC = 0.55;
+async function getVideoDuration(videoPath) {
+  return new Promise((resolve, reject) => {
+    execFile3(
+      ffprobePath4,
+      ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", videoPath],
+      (error, stdout) => {
+        if (error) {
+          reject(new Error(`ffprobe failed: ${error.message}`));
+          return;
+        }
+        resolve(parseFloat(stdout.trim()));
+      }
+    );
+  });
+}
+async function getVideoResolution(videoPath) {
+  return new Promise((resolve, reject) => {
+    execFile3(
+      ffprobePath4,
+      [
+        "-v",
+        "error",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "stream=width,height",
+        "-of",
+        "csv=p=0",
+        videoPath
+      ],
+      (error, stdout) => {
+        if (error) {
+          reject(new Error(`ffprobe failed: ${error.message}`));
+          return;
+        }
+        const [w, h] = stdout.trim().split(",").map(Number);
+        resolve({ width: w, height: h });
+      }
+    );
+  });
+}
+async function extractSampleFrames(videoPath, tempDir) {
+  const duration = await getVideoDuration(videoPath);
+  const interval = Math.max(1, Math.floor(duration / (SAMPLE_FRAMES + 1)));
+  const timestamps = [];
+  for (let i = 1; i <= SAMPLE_FRAMES; i++) {
+    timestamps.push(i * interval);
+  }
+  const framePaths = [];
+  for (let i = 0; i < timestamps.length; i++) {
+    const framePath = path9.join(tempDir, `frame_${i}.png`);
+    framePaths.push(framePath);
+    await new Promise((resolve, reject) => {
+      execFile3(
+        ffmpegPath5,
+        [
+          "-y",
+          "-ss",
+          timestamps[i].toFixed(2),
+          "-i",
+          videoPath,
+          "-vf",
+          `scale=${ANALYSIS_WIDTH}:${ANALYSIS_HEIGHT}`,
+          "-frames:v",
+          "1",
+          "-q:v",
+          "2",
+          framePath
+        ],
+        { maxBuffer: 10 * 1024 * 1024 },
+        (error) => {
+          if (error) {
+            reject(new Error(`Frame extraction failed at ${timestamps[i]}s: ${error.message}`));
+            return;
+          }
+          resolve();
+        }
+      );
+    });
+  }
+  return framePaths;
+}
+function isSkinTone(r, g, b) {
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  return r > 95 && g > 40 && b > 20 && max - min > 15 && Math.abs(r - g) > 15 && r > g && r > b;
+}
+async function analyzeCorner(framePath, position) {
+  const cornerW = Math.floor(ANALYSIS_WIDTH * CORNER_FRACTION);
+  const cornerH = Math.floor(ANALYSIS_HEIGHT * CORNER_FRACTION);
+  let left;
+  let top;
+  switch (position) {
+    case "top-left":
+      left = 0;
+      top = 0;
+      break;
+    case "top-right":
+      left = ANALYSIS_WIDTH - cornerW;
+      top = 0;
+      break;
+    case "bottom-left":
+      left = 0;
+      top = ANALYSIS_HEIGHT - cornerH;
+      break;
+    case "bottom-right":
+      left = ANALYSIS_WIDTH - cornerW;
+      top = ANALYSIS_HEIGHT - cornerH;
+      break;
+  }
+  const { data, info } = await sharp(framePath).extract({ left, top, width: cornerW, height: cornerH }).raw().toBuffer({ resolveWithObject: true });
+  const totalPixels = info.width * info.height;
+  const channels = info.channels;
+  let skinCount = 0;
+  let sumR = 0, sumG = 0, sumB = 0;
+  let sumR2 = 0, sumG2 = 0, sumB2 = 0;
+  for (let i = 0; i < data.length; i += channels) {
+    const r = data[i];
+    const g = data[i + 1];
+    const b = data[i + 2];
+    if (isSkinTone(r, g, b)) skinCount++;
+    sumR += r;
+    sumG += g;
+    sumB += b;
+    sumR2 += r * r;
+    sumG2 += g * g;
+    sumB2 += b * b;
+  }
+  const skinToneRatio = skinCount / totalPixels;
+  const meanR = sumR / totalPixels;
+  const meanG = sumG / totalPixels;
+  const meanB = sumB / totalPixels;
+  const varR = sumR2 / totalPixels - meanR * meanR;
+  const varG = sumG2 / totalPixels - meanG * meanG;
+  const varB = sumB2 / totalPixels - meanB * meanB;
+  const variance = (varR + varG + varB) / 3;
+  return {
+    position,
+    x: left,
+    y: top,
+    width: cornerW,
+    height: cornerH,
+    skinToneRatio,
+    variance
+  };
+}
+function columnMeansForRows(data, width, channels, yFrom, yTo) {
+  const means = new Float64Array(width);
+  const count = yTo - yFrom;
+  if (count <= 0) return means;
+  for (let x = 0; x < width; x++) {
+    let sum = 0;
+    for (let y = yFrom; y < yTo; y++) {
+      const idx = (y * width + x) * channels;
+      sum += (data[idx] + data[idx + 1] + data[idx + 2]) / 3;
+    }
+    means[x] = sum / count;
+  }
+  return means;
+}
+function rowMeansForCols(data, width, channels, height, xFrom, xTo) {
+  const means = new Float64Array(height);
+  const count = xTo - xFrom;
+  if (count <= 0) return means;
+  for (let y = 0; y < height; y++) {
+    let sum = 0;
+    for (let x = xFrom; x < xTo; x++) {
+      const idx = (y * width + x) * channels;
+      sum += (data[idx] + data[idx + 1] + data[idx + 2]) / 3;
+    }
+    means[y] = sum / count;
+  }
+  return means;
+}
+function averageFloat64Arrays(arrays) {
+  if (arrays.length === 0) return new Float64Array(0);
+  const len = arrays[0].length;
+  const result = new Float64Array(len);
+  for (const arr of arrays) {
+    for (let i = 0; i < len; i++) result[i] += arr[i];
+  }
+  for (let i = 0; i < len; i++) result[i] /= arrays.length;
+  return result;
+}
+function findPeakDiff(means, searchFrom, searchTo, minDiff) {
+  const lo = Math.max(0, Math.min(searchFrom, searchTo));
+  const hi = Math.min(means.length - 1, Math.max(searchFrom, searchTo));
+  let maxDiff = 0;
+  let maxIdx = -1;
+  for (let i = lo; i < hi; i++) {
+    const d = Math.abs(means[i + 1] - means[i]);
+    if (d > maxDiff) {
+      maxDiff = d;
+      maxIdx = i;
+    }
+  }
+  return maxDiff >= minDiff ? { index: maxIdx, magnitude: maxDiff } : { index: -1, magnitude: maxDiff };
+}
+async function refineBoundingBox(framePaths, position) {
+  if (framePaths.length === 0) return null;
+  const isRight = position.includes("right");
+  const isBottom = position.includes("bottom");
+  let fw = 0, fh = 0;
+  const colMeansAll = [];
+  const rowMeansAll = [];
+  for (const fp of framePaths) {
+    const { data, info } = await sharp(fp).raw().toBuffer({ resolveWithObject: true });
+    fw = info.width;
+    fh = info.height;
+    const yFrom2 = isBottom ? Math.floor(fh * 0.35) : 0;
+    const yTo2 = isBottom ? fh : Math.ceil(fh * 0.65);
+    colMeansAll.push(columnMeansForRows(data, fw, info.channels, yFrom2, yTo2));
+    const xFrom2 = isRight ? Math.floor(fw * 0.35) : 0;
+    const xTo2 = isRight ? fw : Math.ceil(fw * 0.65);
+    rowMeansAll.push(rowMeansForCols(data, fw, info.channels, fh, xFrom2, xTo2));
+  }
+  const avgCols = averageFloat64Arrays(colMeansAll);
+  const avgRows = averageFloat64Arrays(rowMeansAll);
+  const xFrom = isRight ? Math.floor(fw * 0.35) : Math.floor(fw * 0.05);
+  const xTo = isRight ? Math.floor(fw * 0.95) : Math.floor(fw * 0.65);
+  const xEdge = findPeakDiff(avgCols, xFrom, xTo, REFINE_MIN_EDGE_DIFF);
+  const yFrom = isBottom ? Math.floor(fh * 0.35) : Math.floor(fh * 0.05);
+  const yTo = isBottom ? Math.floor(fh * 0.95) : Math.floor(fh * 0.65);
+  const yEdge = findPeakDiff(avgRows, yFrom, yTo, REFINE_MIN_EDGE_DIFF);
+  if (xEdge.index < 0 || yEdge.index < 0) {
+    logger_default.info(
+      `[FaceDetection] Edge refinement: no strong edges (xDiff=${xEdge.magnitude.toFixed(1)}, yDiff=${yEdge.magnitude.toFixed(1)})`
+    );
+    return null;
+  }
+  let x, y, w, h;
+  if (isRight) {
+    x = xEdge.index + 1;
+    w = fw - x;
+  } else {
+    x = 0;
+    w = xEdge.index;
+  }
+  if (isBottom) {
+    y = yEdge.index + 1;
+    h = fh - y;
+  } else {
+    y = 0;
+    h = yEdge.index;
+  }
+  if (w < fw * REFINE_MIN_SIZE_FRAC || h < fh * REFINE_MIN_SIZE_FRAC || w > fw * REFINE_MAX_SIZE_FRAC || h > fh * REFINE_MAX_SIZE_FRAC) {
+    logger_default.info(
+      `[FaceDetection] Refined bounds implausible (${w}x${h} in ${fw}x${fh}), using coarse bounds`
+    );
+    return null;
+  }
+  logger_default.info(
+    `[FaceDetection] Refined webcam: (${x},${y}) ${w}x${h} at analysis scale (xDiff=${xEdge.magnitude.toFixed(1)}, yDiff=${yEdge.magnitude.toFixed(1)})`
+  );
+  return { x, y, width: w, height: h };
+}
+function calculateCornerConfidence(scores) {
+  if (scores.length === 0) return 0;
+  const nonZeroCount = scores.filter((s) => s > 0).length;
+  const consistency = nonZeroCount / scores.length;
+  const avgScore = scores.reduce((a, b) => a + b, 0) / scores.length;
+  return consistency * Math.min(avgScore * 10, 1);
+}
+async function detectWebcamRegion(videoPath) {
+  const tempDir = await fs11.mkdtemp(path9.join(os2.tmpdir(), "face-detect-"));
+  try {
+    const resolution = await getVideoResolution(videoPath);
+    const framePaths = await extractSampleFrames(videoPath, tempDir);
+    const positions = [
+      "top-left",
+      "top-right",
+      "bottom-left",
+      "bottom-right"
+    ];
+    const scoresByPosition = /* @__PURE__ */ new Map();
+    for (const pos of positions) {
+      scoresByPosition.set(pos, []);
+    }
+    for (const framePath of framePaths) {
+      for (const pos of positions) {
+        const analysis = await analyzeCorner(framePath, pos);
+        const score = analysis.skinToneRatio > MIN_SKIN_RATIO ? analysis.skinToneRatio * Math.min(analysis.variance / 1e3, 1) : 0;
+        scoresByPosition.get(pos).push(score);
+      }
+    }
+    let bestPosition = null;
+    let bestConfidence = 0;
+    for (const [pos, scores] of scoresByPosition) {
+      const confidence = calculateCornerConfidence(scores);
+      if (confidence > bestConfidence) {
+        bestConfidence = confidence;
+        bestPosition = pos;
+      }
+    }
+    if (!bestPosition || bestConfidence < MIN_CONFIDENCE) {
+      logger_default.info("[FaceDetection] No webcam region detected");
+      return null;
+    }
+    const refined = await refineBoundingBox(framePaths, bestPosition);
+    const scaleX = resolution.width / ANALYSIS_WIDTH;
+    const scaleY = resolution.height / ANALYSIS_HEIGHT;
+    let origX, origY, origW, origH;
+    if (refined) {
+      origX = Math.round(refined.x * scaleX);
+      origY = Math.round(refined.y * scaleY);
+      origW = Math.round(refined.width * scaleX);
+      origH = Math.round(refined.height * scaleY);
+    } else {
+      const cornerW = Math.floor(ANALYSIS_WIDTH * CORNER_FRACTION);
+      const cornerH = Math.floor(ANALYSIS_HEIGHT * CORNER_FRACTION);
+      origW = Math.round(cornerW * scaleX);
+      origH = Math.round(cornerH * scaleY);
+      switch (bestPosition) {
+        case "top-left":
+          origX = 0;
+          origY = 0;
+          break;
+        case "top-right":
+          origX = resolution.width - origW;
+          origY = 0;
+          break;
+        case "bottom-left":
+          origX = 0;
+          origY = resolution.height - origH;
+          break;
+        case "bottom-right":
+          origX = resolution.width - origW;
+          origY = resolution.height - origH;
+          break;
+      }
+    }
+    const region = {
+      x: origX,
+      y: origY,
+      width: origW,
+      height: origH,
+      position: bestPosition,
+      confidence: Math.round(bestConfidence * 100) / 100
+    };
+    logger_default.info(
+      `[FaceDetection] Webcam detected at ${region.position} (${region.x},${region.y} ${region.width}x${region.height}) confidence=${region.confidence} refined=${!!refined}`
+    );
+    return region;
+  } finally {
+    const files = await fs11.readdir(tempDir).catch(() => []);
+    for (const f of files) {
+      await fs11.unlink(path9.join(tempDir, f)).catch(() => {
+      });
+    }
+    await fs11.rmdir(tempDir).catch(() => {
+    });
+  }
+}
+
+// src/tools/ffmpeg/aspectRatio.ts
+var ffmpegPath6 = getFFmpegPath();
+var PLATFORM_RATIOS = {
+  "tiktok": "9:16",
+  "youtube-shorts": "9:16",
+  "instagram-reels": "9:16",
+  "instagram-feed": "4:5",
+  "linkedin": "1:1",
+  "youtube": "16:9",
+  "twitter": "1:1"
+};
+var DIMENSIONS = {
+  "16:9": { width: 1920, height: 1080 },
+  "9:16": { width: 1080, height: 1920 },
+  "1:1": { width: 1080, height: 1080 },
+  "4:5": { width: 1080, height: 1350 }
+};
+function buildCropFilter(targetRatio, letterbox) {
+  if (letterbox) {
+    const { width, height } = DIMENSIONS[targetRatio];
+    return `scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2:black`;
+  }
+  switch (targetRatio) {
+    case "9:16":
+      return "crop=ih*9/16:ih:(iw-ih*9/16)/2:0,scale=1080:1920";
+    case "1:1":
+      return "crop=ih:ih:(iw-ih)/2:0,scale=1080:1080";
+    case "4:5":
+      return "crop=ih*4/5:ih:(iw-ih*4/5)/2:0,scale=1080:1350";
+    case "16:9":
+      return "scale=1920:1080";
+  }
+}
+async function convertAspectRatio(inputPath, outputPath, targetRatio, options = {}) {
+  const outputDir = pathMod3.dirname(outputPath);
+  await fs12.mkdir(outputDir, { recursive: true });
+  const sourceRatio = "16:9";
+  if (sourceRatio === targetRatio && !options.letterbox) {
+    logger_default.info(`Aspect ratio already ${targetRatio}, copying \u2192 ${outputPath}`);
+    await fs12.copyFile(inputPath, outputPath);
+    return outputPath;
+  }
+  const vf = buildCropFilter(targetRatio, options.letterbox ?? false);
+  logger_default.info(`Converting aspect ratio to ${targetRatio} (filter: ${vf}) \u2192 ${outputPath}`);
+  const args = [
+    "-y",
+    "-i",
+    inputPath,
+    "-vf",
+    vf,
+    "-c:v",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-crf",
+    "23",
+    "-c:a",
+    "copy",
+    "-threads",
+    "4",
+    outputPath
+  ];
+  return new Promise((resolve, reject) => {
+    execFile4(ffmpegPath6, args, { maxBuffer: 10 * 1024 * 1024 }, (error, _stdout, stderr) => {
+      if (error) {
+        logger_default.error(`Aspect ratio conversion failed: ${stderr || error.message}`);
+        reject(new Error(`Aspect ratio conversion failed: ${stderr || error.message}`));
+        return;
+      }
+      logger_default.info(`Aspect ratio conversion complete: ${outputPath}`);
+      resolve(outputPath);
+    });
+  });
+}
+async function convertWithSmartLayout(inputPath, outputPath, config2) {
+  const { label, targetW, screenH, camH, fallbackRatio } = config2;
+  const outputDir = pathMod3.dirname(outputPath);
+  await fs12.mkdir(outputDir, { recursive: true });
+  const webcam = await detectWebcamRegion(inputPath);
+  if (!webcam) {
+    logger_default.info(`[${label}] No webcam found, falling back to center-crop`);
+    return convertAspectRatio(inputPath, outputPath, fallbackRatio);
+  }
+  const resolution = await getVideoResolution(inputPath);
+  let screenCropX;
+  let screenCropW;
+  if (webcam.position === "top-right" || webcam.position === "bottom-right") {
+    screenCropX = 0;
+    screenCropW = webcam.x;
+  } else {
+    screenCropX = webcam.x + webcam.width;
+    screenCropW = Math.max(0, resolution.width - screenCropX);
+  }
+  const targetAR = targetW / camH;
+  const webcamAR = webcam.width / webcam.height;
+  let faceX, faceY, faceW, faceH;
+  if (webcamAR > targetAR) {
+    faceH = webcam.height;
+    faceW = Math.round(faceH * targetAR);
+    faceX = webcam.x + Math.round((webcam.width - faceW) / 2);
+    faceY = webcam.y;
+  } else {
+    faceW = webcam.width;
+    faceH = Math.round(faceW / targetAR);
+    faceX = webcam.x;
+    faceY = webcam.y + Math.round((webcam.height - faceH) / 2);
+  }
+  const filterComplex = [
+    `[0:v]crop=${screenCropW}:ih:${screenCropX}:0,scale=${targetW}:${screenH}:force_original_aspect_ratio=decrease,pad=${targetW}:${screenH}:(ow-iw)/2:(oh-ih)/2:black[screen]`,
+    `[0:v]crop=${faceW}:${faceH}:${faceX}:${faceY},scale=${targetW}:${camH}[cam]`,
+    "[screen][cam]vstack[out]"
+  ].join(";");
+  logger_default.info(`[${label}] Split-screen layout: webcam at ${webcam.position} \u2192 ${outputPath}`);
+  const args = [
+    "-y",
+    "-i",
+    inputPath,
+    "-filter_complex",
+    filterComplex,
+    "-map",
+    "[out]",
+    "-map",
+    "0:a",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-crf",
+    "23",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "128k",
+    "-threads",
+    "4",
+    outputPath
+  ];
+  return new Promise((resolve, reject) => {
+    execFile4(ffmpegPath6, args, { maxBuffer: 10 * 1024 * 1024 }, (error, _stdout, stderr) => {
+      if (error) {
+        logger_default.error(`[${label}] FFmpeg failed: ${stderr || error.message}`);
+        reject(new Error(`${label} conversion failed: ${stderr || error.message}`));
         return;
-    processing = true;
+      }
+      logger_default.info(`[${label}] Complete: ${outputPath}`);
+      resolve(outputPath);
+    });
+  });
+}
+async function convertToPortraitSmart(inputPath, outputPath) {
+  return convertWithSmartLayout(inputPath, outputPath, {
+    label: "SmartPortrait",
+    targetW: 1080,
+    screenH: 1248,
+    camH: 672,
+    fallbackRatio: "9:16"
+  });
+}
+async function convertToSquareSmart(inputPath, outputPath) {
+  return convertWithSmartLayout(inputPath, outputPath, {
+    label: "SmartSquare",
+    targetW: 1080,
+    screenH: 700,
+    camH: 380,
+    fallbackRatio: "1:1"
+  });
+}
+async function convertToFeedSmart(inputPath, outputPath) {
+  return convertWithSmartLayout(inputPath, outputPath, {
+    label: "SmartFeed",
+    targetW: 1080,
+    screenH: 878,
+    camH: 472,
+    fallbackRatio: "4:5"
+  });
+}
+async function generatePlatformVariants(inputPath, outputDir, slug, platforms = ["tiktok", "linkedin"]) {
+  await fs12.mkdir(outputDir, { recursive: true });
+  const ratioMap = /* @__PURE__ */ new Map();
+  for (const p of platforms) {
+    const ratio = PLATFORM_RATIOS[p];
+    if (ratio === "16:9") continue;
+    const list = ratioMap.get(ratio) ?? [];
+    list.push(p);
+    ratioMap.set(ratio, list);
+  }
+  const variants = [];
+  for (const [ratio, associatedPlatforms] of ratioMap) {
+    const suffix = ratio === "9:16" ? "portrait" : ratio === "4:5" ? "feed" : "square";
+    const outPath = pathMod3.join(outputDir, `${slug}-${suffix}.mp4`);
     try {
-        while (queue.length > 0) {
-            const videoPath = queue.shift();
-            logger.info(`Processing video: ${videoPath}`);
-            await processVideoSafe(videoPath);
-            if (onceMode) {
-                logger.info('--once flag set, exiting after first video.');
-                await shutdown();
-                return;
+      if (ratio === "9:16") {
+        await convertToPortraitSmart(inputPath, outPath);
+      } else if (ratio === "1:1") {
+        await convertToSquareSmart(inputPath, outPath);
+      } else if (ratio === "4:5") {
+        await convertToFeedSmart(inputPath, outPath);
+      } 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 });
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger_default.warn(`Skipping ${ratio} variant for ${slug}: ${message}`);
+    }
+  }
+  return variants;
+}
+
+// src/agents/ShortsAgent.ts
+import { v4 as uuidv4 } from "uuid";
+import slugify2 from "slugify";
+import { promises as fs13 } from "fs";
+import path10 from "path";
+var SYSTEM_PROMPT = `You are a short-form video content strategist. Your job is to analyze a video transcript with word-level timestamps and identify the most compelling moments to extract as shorts (15\u201360 seconds each).
+
+## What to look for
+- **Key insights** \u2014 concise, quotable takeaways
+- **Funny moments** \u2014 humor, wit, unexpected punchlines
+- **Controversial takes** \u2014 bold opinions that spark discussion
+- **Educational nuggets** \u2014 clear explanations of complex topics
+- **Emotional peaks** \u2014 passion, vulnerability, excitement
+- **Topic compilations** \u2014 multiple brief mentions of one theme that can be stitched together
+
+## Short types
+- **Single segment** \u2014 one contiguous section of the video
+- **Composite** \u2014 multiple non-contiguous segments combined into one short (great for topic compilations or building a narrative arc)
+
+## Rules
+1. Each short must be 15\u201360 seconds total duration.
+2. Timestamps must align to word boundaries from the transcript.
+3. Prefer natural sentence boundaries for clean cuts.
+4. Aim for 3\u20138 shorts per video, depending on length and richness.
+5. Every short needs a catchy, descriptive title (5\u201310 words).
+6. Tags should be lowercase, no hashes, 3\u20136 per short.
+7. A 1-second buffer is automatically added before and after each segment boundary during extraction, so plan segments based on content timestamps without worrying about clipping words at the edges.
+
+When you have identified the shorts, call the **plan_shorts** tool with your complete plan.`;
+var PLAN_SHORTS_SCHEMA = {
+  type: "object",
+  properties: {
+    shorts: {
+      type: "array",
+      description: "Array of planned short clips",
+      items: {
+        type: "object",
+        properties: {
+          title: { type: "string", description: "Catchy short title (5\u201310 words)" },
+          description: { type: "string", description: "Brief description of the short content" },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Lowercase tags without hashes, 3\u20136 per short"
+          },
+          segments: {
+            type: "array",
+            description: "One or more time segments that compose this short",
+            items: {
+              type: "object",
+              properties: {
+                start: { type: "number", description: "Start time in seconds" },
+                end: { type: "number", description: "End time in seconds" },
+                description: { type: "string", description: "What happens in this segment" }
+              },
+              required: ["start", "end", "description"]
             }
-            if (shutdownRequested)
-                break;
+          }
+        },
+        required: ["title", "description", "tags", "segments"]
+      }
+    }
+  },
+  required: ["shorts"]
+};
+var ShortsAgent = class extends BaseAgent {
+  plannedShorts = [];
+  constructor() {
+    super("ShortsAgent", SYSTEM_PROMPT);
+  }
+  getTools() {
+    return [
+      {
+        name: "plan_shorts",
+        description: "Submit the planned shorts as a structured JSON array. Call this once with all planned shorts.",
+        parameters: PLAN_SHORTS_SCHEMA,
+        handler: async (args) => {
+          return this.handleToolCall("plan_shorts", args);
         }
+      }
+    ];
+  }
+  async handleToolCall(toolName, args) {
+    if (toolName === "plan_shorts") {
+      this.plannedShorts = args.shorts;
+      logger_default.info(`[ShortsAgent] Planned ${this.plannedShorts.length} shorts`);
+      return { success: true, count: this.plannedShorts.length };
+    }
+    throw new Error(`Unknown tool: ${toolName}`);
+  }
+  getPlannedShorts() {
+    return this.plannedShorts;
+  }
+};
+async function generateShorts(video, transcript) {
+  const agent = new ShortsAgent();
+  const transcriptLines = transcript.segments.map((seg) => {
+    const words = seg.words.map((w) => `[${w.start.toFixed(2)}-${w.end.toFixed(2)}] ${w.word}`).join(" ");
+    return `[${seg.start.toFixed(2)}s \u2013 ${seg.end.toFixed(2)}s] ${seg.text}
+Words: ${words}`;
+  });
+  const prompt = [
+    `Analyze the following transcript (${transcript.duration.toFixed(0)}s total) and plan shorts.
+`,
+    `Video: ${video.filename}`,
+    `Duration: ${transcript.duration.toFixed(1)}s
+`,
+    "--- TRANSCRIPT ---\n",
+    transcriptLines.join("\n\n"),
+    "\n--- END TRANSCRIPT ---"
+  ].join("\n");
+  try {
+    await agent.run(prompt);
+    const planned = agent.getPlannedShorts();
+    if (planned.length === 0) {
+      logger_default.warn("[ShortsAgent] No shorts were planned");
+      return [];
     }
-    finally {
-        processing = false;
+    const shortsDir = path10.join(path10.dirname(video.repoPath), "shorts");
+    await fs13.mkdir(shortsDir, { recursive: true });
+    const shorts = [];
+    for (const plan of planned) {
+      const id = uuidv4();
+      const shortSlug = slugify2(plan.title, { lower: true, strict: true });
+      const totalDuration = plan.segments.reduce((sum, s) => sum + (s.end - s.start), 0);
+      const outputPath = path10.join(shortsDir, `${shortSlug}.mp4`);
+      const segments = plan.segments.map((s) => ({
+        start: s.start,
+        end: s.end,
+        description: s.description
+      }));
+      if (segments.length === 1) {
+        await extractClip(video.repoPath, segments[0].start, segments[0].end, outputPath);
+      } else {
+        await extractCompositeClip(video.repoPath, segments, outputPath);
+      }
+      let variants;
+      try {
+        const defaultPlatforms = ["tiktok", "youtube-shorts", "instagram-reels", "instagram-feed", "linkedin"];
+        const results = await generatePlatformVariants(outputPath, shortsDir, shortSlug, defaultPlatforms);
+        if (results.length > 0) {
+          variants = results.map((v) => ({
+            path: v.path,
+            aspectRatio: v.aspectRatio,
+            platform: v.platform,
+            width: v.width,
+            height: v.height
+          }));
+          logger_default.info(`[ShortsAgent] Generated ${variants.length} platform variants for: ${plan.title}`);
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger_default.warn(`[ShortsAgent] Platform variant generation failed for ${plan.title}: ${message}`);
+      }
+      let captionedPath;
+      try {
+        const assContent = segments.length === 1 ? generateStyledASSForSegment(transcript, segments[0].start, segments[0].end) : generateStyledASSForComposite(transcript, segments);
+        const assPath = path10.join(shortsDir, `${shortSlug}.ass`);
+        await fs13.writeFile(assPath, assContent);
+        captionedPath = path10.join(shortsDir, `${shortSlug}-captioned.mp4`);
+        await burnCaptions(outputPath, assPath, captionedPath);
+        logger_default.info(`[ShortsAgent] Burned captions for short: ${plan.title}`);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger_default.warn(`[ShortsAgent] Caption burning failed for ${plan.title}: ${message}`);
+        captionedPath = void 0;
+      }
+      if (variants) {
+        const portraitVariant = variants.find((v) => v.aspectRatio === "9:16");
+        if (portraitVariant) {
+          try {
+            const portraitAssContent = segments.length === 1 ? generatePortraitASSWithHook(transcript, plan.title, segments[0].start, segments[0].end) : generatePortraitASSWithHookComposite(transcript, segments, plan.title);
+            const portraitAssPath = path10.join(shortsDir, `${shortSlug}-portrait.ass`);
+            await fs13.writeFile(portraitAssPath, portraitAssContent);
+            const portraitCaptionedPath = portraitVariant.path.replace(".mp4", "-captioned.mp4");
+            await burnCaptions(portraitVariant.path, portraitAssPath, portraitCaptionedPath);
+            portraitVariant.path = portraitCaptionedPath;
+            logger_default.info(`[ShortsAgent] Burned portrait captions with hook for: ${plan.title}`);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger_default.warn(`[ShortsAgent] Portrait caption burning failed for ${plan.title}: ${message}`);
+          }
+        }
+      }
+      const mdPath = path10.join(shortsDir, `${shortSlug}.md`);
+      const mdContent = [
+        `# ${plan.title}
+`,
+        plan.description,
+        "",
+        "## Segments\n",
+        ...plan.segments.map(
+          (s, i) => `${i + 1}. **${s.start.toFixed(2)}s \u2013 ${s.end.toFixed(2)}s** \u2014 ${s.description}`
+        ),
+        "",
+        "## Tags\n",
+        plan.tags.map((t) => `- ${t}`).join("\n"),
+        ""
+      ].join("\n");
+      await fs13.writeFile(mdPath, mdContent);
+      shorts.push({
+        id,
+        title: plan.title,
+        slug: shortSlug,
+        segments,
+        totalDuration,
+        outputPath,
+        captionedPath,
+        description: plan.description,
+        tags: plan.tags,
+        variants
+      });
+      logger_default.info(`[ShortsAgent] Created short: ${plan.title} (${totalDuration.toFixed(1)}s)`);
     }
+    logger_default.info(`[ShortsAgent] Generated ${shorts.length} shorts`);
+    return shorts;
+  } finally {
+    await agent.destroy();
+  }
 }
-function enqueue(videoPath) {
-    queue.push(videoPath);
-    logger.info(`Queued video: ${videoPath} (queue length: ${queue.length})`);
-    processQueue().catch(err => logger.error('Queue processing error:', err));
+
+// src/agents/MediumVideoAgent.ts
+import { v4 as uuidv42 } from "uuid";
+import slugify3 from "slugify";
+import { promises as fs14 } from "fs";
+import path11 from "path";
+var SYSTEM_PROMPT2 = `You are a medium-form video content strategist. Your job is to analyze a video transcript with word-level timestamps and identify the best 1\u20133 minute segments to extract as standalone medium-form clips.
+
+## What to look for
+
+- **Complete topics** \u2014 a subject is introduced, explored, and concluded
+- **Narrative arcs** \u2014 problem \u2192 solution \u2192 result; question \u2192 exploration \u2192 insight
+- **Educational deep dives** \u2014 clear, thorough explanations of complex topics
+- **Compelling stories** \u2014 anecdotes with setup, tension, and resolution
+- **Strong arguments** \u2014 claim \u2192 evidence \u2192 implication sequences
+- **Topic compilations** \u2014 multiple brief mentions of one theme across the video that can be compiled into a cohesive 1\u20133 minute segment
+
+## Clip types
+
+- **Deep Dive** \u2014 a single contiguous section (1\u20133 min) covering one topic in depth
+- **Compilation** \u2014 multiple non-contiguous segments stitched together around a single theme or narrative thread (1\u20133 min total)
+
+## Rules
+
+1. Each clip must be 60\u2013180 seconds total duration.
+2. Timestamps must align to word boundaries from the transcript.
+3. Prefer natural sentence and paragraph boundaries for clean entry/exit points.
+4. Each clip must be self-contained \u2014 a viewer with no other context should understand and get value from the clip.
+5. Aim for 2\u20134 medium clips per video, depending on length and richness.
+6. Every clip needs a descriptive title (5\u201312 words) and a topic label.
+7. For compilations, specify segments in the order they should appear in the final clip (which may differ from chronological order).
+8. Tags should be lowercase, no hashes, 3\u20136 per clip.
+9. A 1-second buffer is automatically added around each segment boundary.
+10. Each clip needs a hook \u2014 the opening line or concept that draws viewers in.
+
+## Differences from shorts
+
+- Shorts capture *moments*; medium clips capture *complete ideas*.
+- Don't just find the most exciting 60 seconds \u2014 find where a topic starts and where it naturally concludes.
+- It's OK if a medium clip has slower pacing \u2014 depth and coherence matter more than constant high energy.
+- Look for segments that work as standalone mini-tutorials or explanations.
+- Avoid overlap with content that would work better as a short (punchy, viral, single-moment).
+
+When you have identified the clips, call the **plan_medium_clips** tool with your complete plan.`;
+var PLAN_MEDIUM_CLIPS_SCHEMA = {
+  type: "object",
+  properties: {
+    clips: {
+      type: "array",
+      description: "Array of planned medium-length clips",
+      items: {
+        type: "object",
+        properties: {
+          title: { type: "string", description: "Descriptive clip title (5\u201312 words)" },
+          description: { type: "string", description: "Brief description of the clip content" },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Lowercase tags without hashes, 3\u20136 per clip"
+          },
+          segments: {
+            type: "array",
+            description: "One or more time segments that compose this clip",
+            items: {
+              type: "object",
+              properties: {
+                start: { type: "number", description: "Start time in seconds" },
+                end: { type: "number", description: "End time in seconds" },
+                description: { type: "string", description: "What happens in this segment" }
+              },
+              required: ["start", "end", "description"]
+            }
+          },
+          totalDuration: { type: "number", description: "Total clip duration in seconds (60\u2013180)" },
+          hook: { type: "string", description: "Opening hook for the clip" },
+          topic: { type: "string", description: "Main topic covered in the clip" }
+        },
+        required: ["title", "description", "tags", "segments", "totalDuration", "hook", "topic"]
+      }
+    }
+  },
+  required: ["clips"]
+};
+var MediumVideoAgent = class extends BaseAgent {
+  plannedClips = [];
+  constructor() {
+    super("MediumVideoAgent", SYSTEM_PROMPT2);
+  }
+  getTools() {
+    return [
+      {
+        name: "plan_medium_clips",
+        description: "Submit the planned medium-length clips as a structured JSON array. Call this once with all planned clips.",
+        parameters: PLAN_MEDIUM_CLIPS_SCHEMA,
+        handler: async (args) => {
+          return this.handleToolCall("plan_medium_clips", args);
+        }
+      }
+    ];
+  }
+  async handleToolCall(toolName, args) {
+    if (toolName === "plan_medium_clips") {
+      this.plannedClips = args.clips;
+      logger_default.info(`[MediumVideoAgent] Planned ${this.plannedClips.length} medium clips`);
+      return { success: true, count: this.plannedClips.length };
+    }
+    throw new Error(`Unknown tool: ${toolName}`);
+  }
+  getPlannedClips() {
+    return this.plannedClips;
+  }
+};
+async function generateMediumClips(video, transcript) {
+  const agent = new MediumVideoAgent();
+  const transcriptLines = transcript.segments.map((seg) => {
+    const words = seg.words.map((w) => `[${w.start.toFixed(2)}-${w.end.toFixed(2)}] ${w.word}`).join(" ");
+    return `[${seg.start.toFixed(2)}s \u2013 ${seg.end.toFixed(2)}s] ${seg.text}
+Words: ${words}`;
+  });
+  const prompt = [
+    `Analyze the following transcript (${transcript.duration.toFixed(0)}s total) and plan medium-length clips (1\u20133 minutes each).
+`,
+    `Video: ${video.filename}`,
+    `Duration: ${transcript.duration.toFixed(1)}s
+`,
+    "--- TRANSCRIPT ---\n",
+    transcriptLines.join("\n\n"),
+    "\n--- END TRANSCRIPT ---"
+  ].join("\n");
+  try {
+    await agent.run(prompt);
+    const planned = agent.getPlannedClips();
+    if (planned.length === 0) {
+      logger_default.warn("[MediumVideoAgent] No medium clips were planned");
+      return [];
+    }
+    const clipsDir = path11.join(path11.dirname(video.repoPath), "medium-clips");
+    await fs14.mkdir(clipsDir, { recursive: true });
+    const clips = [];
+    for (const plan of planned) {
+      const id = uuidv42();
+      const clipSlug = slugify3(plan.title, { lower: true, strict: true });
+      const totalDuration = plan.segments.reduce((sum, s) => sum + (s.end - s.start), 0);
+      const outputPath = path11.join(clipsDir, `${clipSlug}.mp4`);
+      const segments = plan.segments.map((s) => ({
+        start: s.start,
+        end: s.end,
+        description: s.description
+      }));
+      if (segments.length === 1) {
+        await extractClip(video.repoPath, segments[0].start, segments[0].end, outputPath);
+      } else {
+        await extractCompositeClipWithTransitions(video.repoPath, segments, outputPath);
+      }
+      let captionedPath;
+      try {
+        const assContent = segments.length === 1 ? generateStyledASSForSegment(transcript, segments[0].start, segments[0].end, 1, "medium") : generateStyledASSForComposite(transcript, segments, 1, "medium");
+        const assPath = path11.join(clipsDir, `${clipSlug}.ass`);
+        await fs14.writeFile(assPath, assContent);
+        captionedPath = path11.join(clipsDir, `${clipSlug}-captioned.mp4`);
+        await burnCaptions(outputPath, assPath, captionedPath);
+        logger_default.info(`[MediumVideoAgent] Burned captions for clip: ${plan.title}`);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger_default.warn(`[MediumVideoAgent] Caption burning failed for ${plan.title}: ${message}`);
+        captionedPath = void 0;
+      }
+      const mdPath = path11.join(clipsDir, `${clipSlug}.md`);
+      const mdContent = [
+        `# ${plan.title}
+`,
+        `**Topic:** ${plan.topic}
+`,
+        `**Hook:** ${plan.hook}
+`,
+        plan.description,
+        "",
+        "## Segments\n",
+        ...plan.segments.map(
+          (s, i) => `${i + 1}. **${s.start.toFixed(2)}s \u2013 ${s.end.toFixed(2)}s** \u2014 ${s.description}`
+        ),
+        "",
+        "## Tags\n",
+        plan.tags.map((t) => `- ${t}`).join("\n"),
+        ""
+      ].join("\n");
+      await fs14.writeFile(mdPath, mdContent);
+      clips.push({
+        id,
+        title: plan.title,
+        slug: clipSlug,
+        segments,
+        totalDuration,
+        outputPath,
+        captionedPath,
+        description: plan.description,
+        tags: plan.tags,
+        hook: plan.hook,
+        topic: plan.topic
+      });
+      logger_default.info(`[MediumVideoAgent] Created medium clip: ${plan.title} (${totalDuration.toFixed(1)}s)`);
+    }
+    logger_default.info(`[MediumVideoAgent] Generated ${clips.length} medium clips`);
+    return clips;
+  } finally {
+    await agent.destroy();
+  }
 }
-async function shutdown() {
-    if (shutdownRequested)
+
+// src/agents/SocialMediaAgent.ts
+import * as fs15 from "fs";
+import * as path12 from "path";
+
+// src/tools/search/exaClient.ts
+import Exa from "exa-js";
+async function searchWeb(query, numResults = 5) {
+  const config2 = getConfig();
+  if (!config2.EXA_API_KEY) {
+    logger_default.warn("EXA_API_KEY not set \u2014 skipping web search");
+    return [];
+  }
+  const exa = new Exa(config2.EXA_API_KEY);
+  try {
+    const results = await exa.searchAndContents(query, {
+      numResults,
+      text: { maxCharacters: 200 }
+    });
+    return results.results.map((r) => ({
+      title: r.title || "",
+      url: r.url,
+      // Exa SDK searchAndContents returns `text` when text option is used, but the type doesn't include it
+      snippet: r.text || ""
+    }));
+  } catch (err) {
+    logger_default.error(`Exa search failed: ${err instanceof Error ? err.message : err}`);
+    return [];
+  }
+}
+
+// src/agents/SocialMediaAgent.ts
+var SYSTEM_PROMPT3 = `You are a viral social-media content strategist.
+Given a video transcript and summary you MUST generate one post for each of the 5 platforms listed below.
+Each post must match the platform's tone, format, and constraints exactly.
+
+Platform guidelines:
+1. **TikTok** \u2013 Casual, hook-driven, trending hashtags, 150 chars max, emoji-heavy.
+2. **YouTube** \u2013 Descriptive, SEO-optimized title + description, relevant tags.
+3. **Instagram** \u2013 Visual storytelling, emoji-rich, 30 hashtags max, engaging caption.
+4. **LinkedIn** \u2013 Professional, thought-leadership, industry insights, 1-3 hashtags.
+5. **X (Twitter)** \u2013 Concise, punchy, 280 chars max, 2-5 hashtags, thread-ready.
+
+IMPORTANT \u2013 Content format:
+The "content" field you provide must be the FINAL, ready-to-post text that can be directly copied and pasted onto the platform. Do NOT use markdown headers, bullet points, or any formatting inside the content. Include hashtags inline at the end of the post text where appropriate. The content is saved as-is for direct posting.
+
+Workflow:
+1. First call the "search_links" tool with the key topics to find relevant URLs.
+2. Then call the "create_posts" tool with a JSON object that has a "posts" array.
+   Each element must have: platform, content, hashtags (array), links (array), characterCount.
+
+Include relevant links in posts when search results provide them.
+Always call "create_posts" exactly once with all 5 platform posts.`;
+var SocialMediaAgent = class extends BaseAgent {
+  collectedPosts = [];
+  constructor() {
+    super("SocialMediaAgent", SYSTEM_PROMPT3);
+  }
+  getTools() {
+    return [
+      {
+        name: "search_links",
+        description: "Search for relevant URLs based on topics discussed in the video.",
+        parameters: {
+          type: "object",
+          properties: {
+            topics: {
+              type: "array",
+              items: { type: "string" },
+              description: "List of topics to search for"
+            }
+          },
+          required: ["topics"]
+        },
+        handler: async (args) => {
+          const { topics } = args;
+          logger_default.info(`[SocialMediaAgent] search_links called with topics: ${topics.join(", ")}`);
+          const allResults = {};
+          for (const topic of topics) {
+            allResults[topic] = await searchWeb(topic, 3);
+          }
+          return JSON.stringify({ results: allResults });
+        }
+      },
+      {
+        name: "create_posts",
+        description: "Submit the generated social media posts for all 5 platforms.",
+        parameters: {
+          type: "object",
+          properties: {
+            posts: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  platform: { type: "string" },
+                  content: { type: "string" },
+                  hashtags: { type: "array", items: { type: "string" } },
+                  links: { type: "array", items: { type: "string" } },
+                  characterCount: { type: "number" }
+                },
+                required: ["platform", "content", "hashtags", "links", "characterCount"]
+              },
+              description: "Array of posts, one per platform"
+            }
+          },
+          required: ["posts"]
+        },
+        handler: async (args) => {
+          const { posts } = args;
+          this.collectedPosts = posts;
+          logger_default.info(`[SocialMediaAgent] create_posts received ${posts.length} posts`);
+          return JSON.stringify({ success: true, count: posts.length });
+        }
+      }
+    ];
+  }
+  async handleToolCall(toolName, args) {
+    logger_default.warn(`[SocialMediaAgent] Unexpected handleToolCall for "${toolName}"`);
+    return { error: `Unknown tool: ${toolName}` };
+  }
+  getCollectedPosts() {
+    return this.collectedPosts;
+  }
+};
+function toPlatformEnum(raw) {
+  const normalised = raw.toLowerCase().trim();
+  switch (normalised) {
+    case "tiktok":
+      return "tiktok" /* TikTok */;
+    case "youtube":
+      return "youtube" /* YouTube */;
+    case "instagram":
+      return "instagram" /* Instagram */;
+    case "linkedin":
+      return "linkedin" /* LinkedIn */;
+    case "x":
+    case "twitter":
+      return "x" /* X */;
+    default:
+      return normalised;
+  }
+}
+function renderPostFile(post, opts2) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const platform = toPlatformEnum(post.platform);
+  const lines = ["---"];
+  lines.push(`platform: ${platform}`);
+  lines.push(`status: draft`);
+  lines.push(`scheduledDate: null`);
+  if (post.hashtags.length > 0) {
+    lines.push("hashtags:");
+    for (const tag of post.hashtags) {
+      lines.push(`  - "${tag}"`);
+    }
+  } else {
+    lines.push("hashtags: []");
+  }
+  if (post.links.length > 0) {
+    lines.push("links:");
+    for (const link of post.links) {
+      lines.push(`  - url: "${link}"`);
+      lines.push(`    title: null`);
+    }
+  } else {
+    lines.push("links: []");
+  }
+  lines.push(`characterCount: ${post.characterCount}`);
+  lines.push(`videoSlug: "${opts2.videoSlug}"`);
+  lines.push(`shortSlug: ${opts2.shortSlug ? `"${opts2.shortSlug}"` : "null"}`);
+  lines.push(`createdAt: "${now}"`);
+  lines.push("---");
+  lines.push("");
+  lines.push(post.content);
+  lines.push("");
+  return lines.join("\n");
+}
+async function generateShortPosts(video, short, transcript) {
+  const agent = new SocialMediaAgent();
+  try {
+    const relevantText = transcript.segments.filter(
+      (seg) => short.segments.some((ss) => seg.start < ss.end && seg.end > ss.start)
+    ).map((seg) => seg.text).join(" ");
+    const userMessage = [
+      "## Short Clip Metadata",
+      `- **Title:** ${short.title}`,
+      `- **Description:** ${short.description}`,
+      `- **Duration:** ${short.totalDuration.toFixed(1)}s`,
+      `- **Tags:** ${short.tags.join(", ")}`,
+      "",
+      "## Relevant Transcript",
+      relevantText.slice(0, 3e3)
+    ].join("\n");
+    await agent.run(userMessage);
+    const collectedPosts = agent.getCollectedPosts();
+    const shortsDir = path12.join(path12.dirname(video.repoPath), "shorts");
+    const postsDir = path12.join(shortsDir, short.slug, "posts");
+    fs15.mkdirSync(postsDir, { recursive: true });
+    const socialPosts = collectedPosts.map((p) => {
+      const platform = toPlatformEnum(p.platform);
+      const outputPath = path12.join(postsDir, `${platform}.md`);
+      fs15.writeFileSync(
+        outputPath,
+        renderPostFile(p, { videoSlug: video.slug, shortSlug: short.slug }),
+        "utf-8"
+      );
+      logger_default.info(`[SocialMediaAgent] Wrote short post ${outputPath}`);
+      return {
+        platform,
+        content: p.content,
+        hashtags: p.hashtags,
+        links: p.links,
+        characterCount: p.characterCount,
+        outputPath
+      };
+    });
+    return socialPosts;
+  } finally {
+    await agent.destroy();
+  }
+}
+async function generateSocialPosts(video, transcript, summary, outputDir) {
+  const agent = new SocialMediaAgent();
+  try {
+    const userMessage = [
+      "## Video Metadata",
+      `- **Title:** ${summary.title}`,
+      `- **Slug:** ${video.slug}`,
+      `- **Duration:** ${video.duration}s`,
+      "",
+      "## Summary",
+      summary.overview,
+      "",
+      "## Key Topics",
+      summary.keyTopics.map((t) => `- ${t}`).join("\n"),
+      "",
+      "## Transcript (first 3000 chars)",
+      transcript.text.slice(0, 3e3)
+    ].join("\n");
+    await agent.run(userMessage);
+    const collectedPosts = agent.getCollectedPosts();
+    const outDir = outputDir ?? path12.join(video.videoDir, "social-posts");
+    fs15.mkdirSync(outDir, { recursive: true });
+    const socialPosts = collectedPosts.map((p) => {
+      const platform = toPlatformEnum(p.platform);
+      const outputPath = path12.join(outDir, `${platform}.md`);
+      fs15.writeFileSync(
+        outputPath,
+        renderPostFile(p, { videoSlug: video.slug }),
+        "utf-8"
+      );
+      logger_default.info(`[SocialMediaAgent] Wrote ${outputPath}`);
+      return {
+        platform,
+        content: p.content,
+        hashtags: p.hashtags,
+        links: p.links,
+        characterCount: p.characterCount,
+        outputPath
+      };
+    });
+    return socialPosts;
+  } finally {
+    await agent.destroy();
+  }
+}
+
+// src/agents/BlogAgent.ts
+import * as fs16 from "fs";
+import * as path13 from "path";
+function buildSystemPrompt2() {
+  const brand = getBrandConfig();
+  return `You are a technical blog writer for dev.to, writing from the perspective of ${brand.name} (${brand.handle}).
+
+Voice & style:
+- Tone: ${brand.voice.tone}
+- Personality: ${brand.voice.personality}
+- Style: ${brand.voice.style}
+
+Content guidelines: ${brand.contentGuidelines.blogFocus}
+
+Your task is to generate a full dev.to-style technical blog post (800-1500 words) based on a video transcript and summary.
+
+The blog post MUST include:
+1. dev.to frontmatter (title, published: false, description, tags, cover_image placeholder)
+2. An engaging introduction with a hook
+3. Clear sections covering the main content (e.g. The Problem, The Solution, How It Works)
+4. Code snippets where the video content discusses code \u2014 use fenced code blocks with language tags
+5. Key Takeaways section
+6. A conclusion
+7. A footer referencing the original video
+
+Workflow:
+1. First call "search_web" with key topics to find relevant articles/resources to link to.
+2. Then call "write_blog" with the complete blog post including frontmatter and body.
+   - Weave the search result links organically into the post text (don't dump them at the end).
+   - Reference the video and any shorts naturally.
+
+Always call "write_blog" exactly once with the complete post.`;
+}
+var BlogAgent = class extends BaseAgent {
+  blogContent = null;
+  constructor() {
+    super("BlogAgent", buildSystemPrompt2());
+  }
+  getTools() {
+    return [
+      {
+        name: "search_web",
+        description: "Search the web for relevant articles and resources to link in the blog post.",
+        parameters: {
+          type: "object",
+          properties: {
+            queries: {
+              type: "array",
+              items: { type: "string" },
+              description: "List of search queries for finding relevant links"
+            }
+          },
+          required: ["queries"]
+        },
+        handler: async (args) => {
+          const { queries } = args;
+          logger_default.info(`[BlogAgent] search_web called with ${queries.length} queries`);
+          const allResults = {};
+          for (const query of queries) {
+            allResults[query] = await searchWeb(query, 3);
+          }
+          return JSON.stringify({ results: allResults });
+        }
+      },
+      {
+        name: "write_blog",
+        description: "Submit the complete dev.to blog post with frontmatter and markdown body.",
+        parameters: {
+          type: "object",
+          properties: {
+            frontmatter: {
+              type: "object",
+              properties: {
+                title: { type: "string" },
+                description: { type: "string" },
+                tags: { type: "array", items: { type: "string" } },
+                cover_image: { type: "string" }
+              },
+              required: ["title", "description", "tags"]
+            },
+            body: {
+              type: "string",
+              description: "The full markdown body of the blog post (excluding frontmatter)"
+            }
+          },
+          required: ["frontmatter", "body"]
+        },
+        handler: async (args) => {
+          const blogArgs = args;
+          this.blogContent = blogArgs;
+          logger_default.info(`[BlogAgent] write_blog received post: "${blogArgs.frontmatter.title}"`);
+          return JSON.stringify({ success: true });
+        }
+      }
+    ];
+  }
+  async handleToolCall(toolName, _args) {
+    logger_default.warn(`[BlogAgent] Unexpected handleToolCall for "${toolName}"`);
+    return { error: `Unknown tool: ${toolName}` };
+  }
+  getBlogContent() {
+    return this.blogContent;
+  }
+};
+function renderBlogMarkdown(blog) {
+  const fm = blog.frontmatter;
+  const tags = fm.tags.map((t) => t.toLowerCase().replace(/[^a-z0-9]/g, "")).join(", ");
+  const lines = [
+    "---",
+    `title: "${fm.title}"`,
+    "published: false",
+    `description: "${fm.description}"`,
+    `tags: ${tags}`,
+    `cover_image: ${fm.cover_image || ""}`,
+    "---",
+    "",
+    blog.body
+  ];
+  return lines.join("\n");
+}
+async function generateBlogPost(video, transcript, summary) {
+  const agent = new BlogAgent();
+  try {
+    const userMessage = [
+      "## Video Metadata",
+      `- **Title:** ${summary.title}`,
+      `- **Slug:** ${video.slug}`,
+      `- **Duration:** ${video.duration}s`,
+      `- **Recorded:** ${video.createdAt.toISOString().split("T")[0]}`,
+      "",
+      "## Summary",
+      summary.overview,
+      "",
+      "## Key Topics",
+      summary.keyTopics.map((t) => `- ${t}`).join("\n"),
+      "",
+      "## Transcript (first 6000 chars)",
+      transcript.text.slice(0, 6e3)
+    ].join("\n");
+    await agent.run(userMessage);
+    const blogContent = agent.getBlogContent();
+    if (!blogContent) {
+      throw new Error("BlogAgent did not produce any blog content");
+    }
+    const outDir = path13.join(video.videoDir, "social-posts");
+    fs16.mkdirSync(outDir, { recursive: true });
+    const outputPath = path13.join(outDir, "devto.md");
+    fs16.writeFileSync(outputPath, renderBlogMarkdown(blogContent), "utf-8");
+    logger_default.info(`[BlogAgent] Wrote blog post to ${outputPath}`);
+    return outputPath;
+  } finally {
+    await agent.destroy();
+  }
+}
+
+// src/agents/ChapterAgent.ts
+import { promises as fs17 } from "fs";
+import path14 from "path";
+function toYouTubeTimestamp2(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = Math.floor(seconds % 60);
+  return h > 0 ? `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}` : `${m}:${String(s).padStart(2, "0")}`;
+}
+function fmtTime2(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = Math.floor(seconds % 60);
+  return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+}
+function buildTranscriptBlock2(transcript) {
+  return transcript.segments.map((seg) => `[${fmtTime2(seg.start)} \u2192 ${fmtTime2(seg.end)}] ${seg.text.trim()}`).join("\n");
+}
+function generateChaptersJSON(chapters) {
+  return JSON.stringify({ chapters }, null, 2);
+}
+function generateYouTubeTimestamps(chapters) {
+  return chapters.map((ch) => `${toYouTubeTimestamp2(ch.timestamp)} ${ch.title}`).join("\n");
+}
+function generateChaptersMarkdown(chapters) {
+  const rows = chapters.map((ch) => `| ${toYouTubeTimestamp2(ch.timestamp)} | ${ch.title} | ${ch.description} |`).join("\n");
+  return `## Chapters
+
+| Time | Chapter | Description |
+|------|---------|-------------|
+${rows}
+`;
+}
+function generateFFMetadata(chapters, totalDuration) {
+  let meta = ";FFMETADATA1\n\n";
+  for (let i = 0; i < chapters.length; i++) {
+    const ch = chapters[i];
+    const startMs = Math.round(ch.timestamp * 1e3);
+    const endMs = i < chapters.length - 1 ? Math.round(chapters[i + 1].timestamp * 1e3) : Math.round(totalDuration * 1e3);
+    const escapedTitle = ch.title.replace(/[=;#\\]/g, "\\$&");
+    meta += `[CHAPTER]
+TIMEBASE=1/1000
+START=${startMs}
+END=${endMs}
+title=${escapedTitle}
+
+`;
+  }
+  return meta;
+}
+function buildChapterSystemPrompt() {
+  return `You are a video chapter generator. Analyze the transcript and identify distinct topic segments.
+
+Rules:
+- First chapter MUST start at 0:00
+- Minimum 3 chapters, maximum 10
+- Each chapter should be 2-5 minutes long
+- Chapter titles should be concise (3-7 words)
+- Look for topic transitions, "moving on", "next", "now let's", etc.
+- Include a brief 1-sentence description per chapter
+
+**Output format:**
+Call the "generate_chapters" tool with an array of chapter objects.
+Each chapter: { timestamp (seconds from start), title (short, 3-7 words), description (1-sentence summary) }
+
+**Title style:**
+- Use title case: "Setting Up the Database"
+- Be specific: "Configuring PostgreSQL" not "Database Stuff"
+- Include the action when relevant: "Building the API Routes"
+- Keep under 50 characters`;
+}
+var ChapterAgent = class extends BaseAgent {
+  outputDir;
+  totalDuration;
+  constructor(outputDir, totalDuration) {
+    super("ChapterAgent", buildChapterSystemPrompt());
+    this.outputDir = outputDir;
+    this.totalDuration = totalDuration;
+  }
+  get chaptersDir() {
+    return path14.join(this.outputDir, "chapters");
+  }
+  getTools() {
+    return [
+      {
+        name: "generate_chapters",
+        description: "Write the identified chapters to disk in all formats. Provide: chapters (array of { timestamp, title, description }).",
+        parameters: {
+          type: "object",
+          properties: {
+            chapters: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  timestamp: { type: "number", description: "Seconds from video start" },
+                  title: { type: "string", description: "Short chapter title (3-7 words)" },
+                  description: { type: "string", description: "1-sentence summary" }
+                },
+                required: ["timestamp", "title", "description"]
+              }
+            }
+          },
+          required: ["chapters"]
+        },
+        handler: async (rawArgs) => {
+          const args = rawArgs;
+          return this.handleGenerateChapters(args);
+        }
+      }
+    ];
+  }
+  async handleToolCall(toolName, args) {
+    switch (toolName) {
+      case "generate_chapters":
+        return this.handleGenerateChapters(args);
+      default:
+        throw new Error(`Unknown tool: ${toolName}`);
+    }
+  }
+  async handleGenerateChapters(args) {
+    const { chapters } = args;
+    await fs17.mkdir(this.chaptersDir, { recursive: true });
+    await Promise.all([
+      fs17.writeFile(
+        path14.join(this.chaptersDir, "chapters.json"),
+        generateChaptersJSON(chapters),
+        "utf-8"
+      ),
+      fs17.writeFile(
+        path14.join(this.chaptersDir, "chapters-youtube.txt"),
+        generateYouTubeTimestamps(chapters),
+        "utf-8"
+      ),
+      fs17.writeFile(
+        path14.join(this.chaptersDir, "chapters.md"),
+        generateChaptersMarkdown(chapters),
+        "utf-8"
+      ),
+      fs17.writeFile(
+        path14.join(this.chaptersDir, "chapters.ffmetadata"),
+        generateFFMetadata(chapters, this.totalDuration),
+        "utf-8"
+      )
+    ]);
+    logger_default.info(`[ChapterAgent] Wrote ${chapters.length} chapters in 4 formats \u2192 ${this.chaptersDir}`);
+    return `Chapters written: ${chapters.length} chapters in 4 formats to ${this.chaptersDir}`;
+  }
+};
+async function generateChapters(video, transcript) {
+  const config2 = getConfig();
+  const outputDir = path14.join(config2.OUTPUT_DIR, video.slug);
+  const agent = new ChapterAgent(outputDir, video.duration);
+  const transcriptBlock = buildTranscriptBlock2(transcript);
+  const userPrompt = [
+    `**Video:** ${video.filename}`,
+    `**Duration:** ${fmtTime2(video.duration)} (${Math.round(video.duration)} seconds)`,
+    "",
+    "---",
+    "",
+    "**Transcript:**",
+    "",
+    transcriptBlock
+  ].join("\n");
+  let capturedChapters;
+  const origHandler = agent.handleGenerateChapters.bind(agent);
+  agent.handleGenerateChapters = async (args) => {
+    capturedChapters = args.chapters;
+    return origHandler(args);
+  };
+  try {
+    await agent.run(userPrompt);
+    if (!capturedChapters) {
+      throw new Error("ChapterAgent did not call generate_chapters");
+    }
+    return capturedChapters;
+  } finally {
+    await agent.destroy();
+  }
+}
+
+// src/services/gitOperations.ts
+import { execSync } from "child_process";
+async function commitAndPush(videoSlug, message) {
+  const { REPO_ROOT } = getConfig();
+  const commitMessage = message || `Auto-processed video: ${videoSlug}`;
+  try {
+    logger_default.info(`Staging all changes in ${REPO_ROOT}`);
+    execSync("git add -A", { cwd: REPO_ROOT, stdio: "pipe" });
+    logger_default.info(`Committing: ${commitMessage}`);
+    execSync(`git commit -m "${commitMessage}"`, { cwd: REPO_ROOT, stdio: "pipe" });
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", { cwd: REPO_ROOT, stdio: "pipe" }).toString().trim();
+    logger_default.info(`Pushing to origin ${branch}`);
+    execSync(`git push origin ${branch}`, { cwd: REPO_ROOT, stdio: "pipe" });
+    logger_default.info("Git commit and push completed successfully");
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (msg.includes("nothing to commit")) {
+      logger_default.info("Nothing to commit, working tree clean");
+      return;
+    }
+    logger_default.error(`Git operation failed: ${msg}`);
+    throw error;
+  }
+}
+
+// src/agents/SilenceRemovalAgent.ts
+import ffmpeg6 from "fluent-ffmpeg";
+import path16 from "path";
+
+// src/tools/ffmpeg/silenceDetection.ts
+import ffmpeg5 from "fluent-ffmpeg";
+var ffmpegPath7 = getFFmpegPath();
+ffmpeg5.setFfmpegPath(ffmpegPath7);
+async function detectSilence(audioPath, minDuration = 1, noiseThreshold = "-30dB") {
+  logger_default.info(`Detecting silence in: ${audioPath} (min=${minDuration}s, threshold=${noiseThreshold})`);
+  return new Promise((resolve, reject) => {
+    const regions = [];
+    let stderr = "";
+    ffmpeg5(audioPath).audioFilters(`silencedetect=noise=${noiseThreshold}:d=${minDuration}`).format("null").output("-").on("stderr", (line) => {
+      stderr += line + "\n";
+    }).on("end", () => {
+      let pendingStart = null;
+      for (const line of stderr.split("\n")) {
+        const startMatch = line.match(/silence_start:\s*([\d.]+)/);
+        if (startMatch) {
+          pendingStart = parseFloat(startMatch[1]);
+        }
+        const endMatch = line.match(/silence_end:\s*([\d.]+)\s*\|\s*silence_duration:\s*([\d.]+)/);
+        if (endMatch) {
+          const end = parseFloat(endMatch[1]);
+          const duration = parseFloat(endMatch[2]);
+          const start = pendingStart ?? Math.max(0, end - duration);
+          regions.push({ start, end, duration });
+          pendingStart = null;
+        }
+      }
+      const badRegions = regions.filter((r) => r.end <= r.start);
+      if (badRegions.length > 0) {
+        logger_default.warn(`[SilenceDetect] Found ${badRegions.length} invalid regions (end <= start) \u2014 filtering out`);
+      }
+      const validRegions = regions.filter((r) => r.end > r.start);
+      if (validRegions.length > 0) {
+        logger_default.info(`Sample silence regions: ${validRegions.slice(0, 3).map((r) => `${r.start.toFixed(1)}s-${r.end.toFixed(1)}s (${r.duration.toFixed(2)}s)`).join(", ")}`);
+      }
+      logger_default.info(`Detected ${validRegions.length} silence regions`);
+      resolve(validRegions);
+    }).on("error", (err) => {
+      logger_default.error(`Silence detection failed: ${err.message}`);
+      reject(new Error(`Silence detection failed: ${err.message}`));
+    }).run();
+  });
+}
+
+// src/tools/ffmpeg/singlePassEdit.ts
+import { execFile as execFile5 } from "child_process";
+import { promises as fs18 } from "fs";
+import path15 from "path";
+import os3 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var ffmpegPath8 = getFFmpegPath();
+var __dirname2 = path15.dirname(fileURLToPath2(import.meta.url));
+var FONTS_DIR2 = path15.resolve(__dirname2, "..", "..", "..", "assets", "fonts");
+function buildFilterComplex(keepSegments, options) {
+  if (keepSegments.length === 0) {
+    throw new Error("keepSegments must not be empty");
+  }
+  const filterParts = [];
+  const concatInputs = [];
+  const hasCaptions = options?.assFilename;
+  for (let i = 0; i < keepSegments.length; i++) {
+    const seg = keepSegments[i];
+    filterParts.push(
+      `[0:v]trim=start=${seg.start.toFixed(3)}:end=${seg.end.toFixed(3)},setpts=PTS-STARTPTS[v${i}]`
+    );
+    filterParts.push(
+      `[0:a]atrim=start=${seg.start.toFixed(3)}:end=${seg.end.toFixed(3)},asetpts=PTS-STARTPTS[a${i}]`
+    );
+    concatInputs.push(`[v${i}][a${i}]`);
+  }
+  const concatOutV = hasCaptions ? "[cv]" : "[outv]";
+  const concatOutA = hasCaptions ? "[ca]" : "[outa]";
+  filterParts.push(
+    `${concatInputs.join("")}concat=n=${keepSegments.length}:v=1:a=1${concatOutV}${concatOutA}`
+  );
+  if (hasCaptions) {
+    const fontsdir = options?.fontsdir ?? ".";
+    filterParts.push(`[cv]ass=${options.assFilename}:fontsdir=${fontsdir}[outv]`);
+  }
+  return filterParts.join(";\n");
+}
+async function singlePassEdit(inputPath, keepSegments, outputPath) {
+  const filterComplex = buildFilterComplex(keepSegments);
+  const args = [
+    "-y",
+    "-i",
+    inputPath,
+    "-filter_complex",
+    filterComplex,
+    "-map",
+    "[outv]",
+    "-map",
+    "[outa]",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-crf",
+    "23",
+    "-threads",
+    "4",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "128k",
+    outputPath
+  ];
+  logger_default.info(`[SinglePassEdit] Editing ${keepSegments.length} segments \u2192 ${outputPath}`);
+  return new Promise((resolve, reject) => {
+    execFile5(ffmpegPath8, args, { maxBuffer: 50 * 1024 * 1024 }, (error, _stdout, stderr) => {
+      if (error) {
+        logger_default.error(`[SinglePassEdit] FFmpeg failed: ${stderr}`);
+        reject(new Error(`Single-pass edit failed: ${error.message}`));
+        return;
+      }
+      logger_default.info(`[SinglePassEdit] Complete: ${outputPath}`);
+      resolve(outputPath);
+    });
+  });
+}
+async function singlePassEditAndCaption(inputPath, keepSegments, assPath, outputPath) {
+  const tempDir = await fs18.mkdtemp(path15.join(os3.tmpdir(), "caption-"));
+  const tempAss = path15.join(tempDir, "captions.ass");
+  await fs18.copyFile(assPath, tempAss);
+  const fontFiles = await fs18.readdir(FONTS_DIR2);
+  for (const f of fontFiles) {
+    if (f.endsWith(".ttf") || f.endsWith(".otf")) {
+      await fs18.copyFile(path15.join(FONTS_DIR2, f), path15.join(tempDir, f));
+    }
+  }
+  const filterComplex = buildFilterComplex(keepSegments, {
+    assFilename: "captions.ass",
+    fontsdir: "."
+  });
+  const args = [
+    "-y",
+    "-i",
+    inputPath,
+    "-filter_complex",
+    filterComplex,
+    "-map",
+    "[outv]",
+    "-map",
+    "[ca]",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-crf",
+    "23",
+    "-threads",
+    "4",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "128k",
+    outputPath
+  ];
+  logger_default.info(`[SinglePassEdit] Processing ${keepSegments.length} segments with captions \u2192 ${outputPath}`);
+  return new Promise((resolve, reject) => {
+    execFile5(ffmpegPath8, args, { cwd: tempDir, maxBuffer: 50 * 1024 * 1024 }, async (error, _stdout, stderr) => {
+      const files = await fs18.readdir(tempDir).catch(() => []);
+      for (const f of files) {
+        await fs18.unlink(path15.join(tempDir, f)).catch(() => {
+        });
+      }
+      await fs18.rmdir(tempDir).catch(() => {
+      });
+      if (error) {
+        logger_default.error(`[SinglePassEdit] FFmpeg failed: ${stderr}`);
+        reject(new Error(`Single-pass edit failed: ${error.message}`));
         return;
-    shutdownRequested = true;
-    logger.info('Shutting down...');
-    if (watcher) {
-        watcher.stop();
+      }
+      logger_default.info(`[SinglePassEdit] Complete: ${outputPath}`);
+      resolve(outputPath);
+    });
+  });
+}
+
+// src/agents/SilenceRemovalAgent.ts
+var ffmpegPath9 = getFFmpegPath();
+var ffprobePath5 = getFFprobePath();
+ffmpeg6.setFfmpegPath(ffmpegPath9);
+ffmpeg6.setFfprobePath(ffprobePath5);
+var SYSTEM_PROMPT4 = `You are a video editor AI that decides which silent regions in a video should be removed.
+You will receive a transcript with timestamps and a list of detected silence regions.
+
+Be CONSERVATIVE. Only remove silence that is CLEARLY dead air \u2014 no speech, no demonstration, no purpose.
+Aim to remove no more than 10-15% of total video duration.
+When in doubt, KEEP the silence.
+
+KEEP silences that are:
+- Dramatic pauses after impactful statements
+- Brief thinking pauses (< 2 seconds) in natural speech
+- Pauses before important reveals or demonstrations
+- Pauses where the speaker is clearly showing something on screen
+- Silence during screen demonstrations or typing \u2014 the viewer is watching the screen
+
+REMOVE silences that are:
+- Dead air with no purpose (> 3 seconds of nothing)
+- Gaps between topics where the speaker was gathering thoughts
+- Silence at the very beginning or end of the video
+
+Return a JSON array of silence regions to REMOVE (not keep).
+When you have decided, call the **decide_removals** tool with your removal list.`;
+var DECIDE_REMOVALS_SCHEMA = {
+  type: "object",
+  properties: {
+    removals: {
+      type: "array",
+      description: "Array of silence regions to remove",
+      items: {
+        type: "object",
+        properties: {
+          start: { type: "number", description: "Start time in seconds" },
+          end: { type: "number", description: "End time in seconds" },
+          reason: { type: "string", description: "Why this silence should be removed" }
+        },
+        required: ["start", "end", "reason"]
+      }
+    }
+  },
+  required: ["removals"]
+};
+var SilenceRemovalAgent = class extends BaseAgent {
+  removals = [];
+  constructor() {
+    super("SilenceRemovalAgent", SYSTEM_PROMPT4);
+  }
+  getTools() {
+    return [
+      {
+        name: "decide_removals",
+        description: "Submit the list of silence regions to remove. Call this once with all removal decisions.",
+        parameters: DECIDE_REMOVALS_SCHEMA,
+        handler: async (args) => {
+          return this.handleToolCall("decide_removals", args);
+        }
+      }
+    ];
+  }
+  async handleToolCall(toolName, args) {
+    if (toolName === "decide_removals") {
+      this.removals = args.removals;
+      logger_default.info(`[SilenceRemovalAgent] Decided to remove ${this.removals.length} silence regions`);
+      return { success: true, count: this.removals.length };
+    }
+    throw new Error(`Unknown tool: ${toolName}`);
+  }
+  getRemovals() {
+    return this.removals;
+  }
+};
+function getVideoDuration2(videoPath) {
+  return new Promise((resolve, reject) => {
+    ffmpeg6.ffprobe(videoPath, (err, metadata) => {
+      if (err) return reject(new Error(`ffprobe failed: ${err.message}`));
+      resolve(metadata.format.duration ?? 0);
+    });
+  });
+}
+async function removeDeadSilence(video, transcript) {
+  const noEdit = { editedPath: video.repoPath, removals: [], keepSegments: [], wasEdited: false };
+  const silenceRegions = await detectSilence(video.repoPath, 0.5);
+  if (silenceRegions.length === 0) {
+    logger_default.info("[SilenceRemoval] No silence regions detected \u2014 skipping");
+    return noEdit;
+  }
+  const totalSilence = silenceRegions.reduce((sum, r) => sum + r.duration, 0);
+  logger_default.info(`[SilenceRemoval] ${silenceRegions.length} silence regions detected (${totalSilence.toFixed(1)}s total silence)`);
+  let regionsForAgent = silenceRegions.filter((r) => r.duration >= 2);
+  if (regionsForAgent.length === 0) {
+    logger_default.info("[SilenceRemoval] No silence regions >= 2s \u2014 skipping");
+    return noEdit;
+  }
+  if (regionsForAgent.length > 30) {
+    regionsForAgent = [...regionsForAgent].sort((a, b) => b.duration - a.duration).slice(0, 30);
+    regionsForAgent.sort((a, b) => a.start - b.start);
+    logger_default.info(`[SilenceRemoval] Capped to top 30 longest regions for agent analysis`);
+  }
+  const agent = new SilenceRemovalAgent();
+  const transcriptLines = transcript.segments.map(
+    (seg) => `[${seg.start.toFixed(2)}s \u2013 ${seg.end.toFixed(2)}s] ${seg.text}`
+  );
+  const silenceLines = regionsForAgent.map(
+    (r, i) => `${i + 1}. ${r.start.toFixed(2)}s \u2013 ${r.end.toFixed(2)}s (${r.duration.toFixed(2)}s)`
+  );
+  const prompt = [
+    `Video: ${video.filename} (${transcript.duration.toFixed(1)}s total)
+`,
+    "--- TRANSCRIPT ---\n",
+    transcriptLines.join("\n"),
+    "\n--- END TRANSCRIPT ---\n",
+    "--- SILENCE REGIONS ---\n",
+    silenceLines.join("\n"),
+    "\n--- END SILENCE REGIONS ---\n",
+    "Analyze the context around each silence region and decide which to remove."
+  ].join("\n");
+  let removals;
+  try {
+    await agent.run(prompt);
+    removals = agent.getRemovals();
+  } finally {
+    await agent.destroy();
+  }
+  if (removals.length === 0) {
+    logger_default.info("[SilenceRemoval] Agent decided to keep all silences \u2014 skipping edit");
+    return noEdit;
+  }
+  const maxRemoval = transcript.duration * 0.2;
+  let totalRemoval = 0;
+  const cappedRemovals = [];
+  const byDuration = [...removals].sort((a, b) => b.end - b.start - (a.end - a.start));
+  for (const r of byDuration) {
+    const dur = r.end - r.start;
+    if (totalRemoval + dur <= maxRemoval) {
+      cappedRemovals.push(r);
+      totalRemoval += dur;
+    }
+  }
+  if (cappedRemovals.length < removals.length) {
+    logger_default.warn(`[SilenceRemoval] Capped from ${removals.length} to ${cappedRemovals.length} regions (${totalRemoval.toFixed(1)}s) to stay under 20% threshold`);
+  }
+  removals = cappedRemovals;
+  if (removals.length === 0) {
+    logger_default.info("[SilenceRemoval] All removals exceeded 20% cap \u2014 skipping edit");
+    return noEdit;
+  }
+  const videoDuration = await getVideoDuration2(video.repoPath);
+  const sortedRemovals = [...removals].sort((a, b) => a.start - b.start);
+  const keepSegments = [];
+  let cursor = 0;
+  for (const removal of sortedRemovals) {
+    if (removal.start > cursor) {
+      keepSegments.push({ start: cursor, end: removal.start });
+    }
+    cursor = Math.max(cursor, removal.end);
+  }
+  if (cursor < videoDuration) {
+    keepSegments.push({ start: cursor, end: videoDuration });
+  }
+  if (keepSegments.length === 0) {
+    logger_default.warn("[SilenceRemoval] No segments to keep \u2014 returning original");
+    return noEdit;
+  }
+  const editedPath = path16.join(video.videoDir, `${video.slug}-edited.mp4`);
+  await singlePassEdit(video.repoPath, keepSegments, editedPath);
+  const effectiveRemovals = [];
+  let prevEnd = 0;
+  for (const seg of keepSegments) {
+    if (seg.start > prevEnd) {
+      effectiveRemovals.push({ start: prevEnd, end: seg.start });
+    }
+    prevEnd = seg.end;
+  }
+  const actualRemoved = effectiveRemovals.reduce((sum, r) => sum + (r.end - r.start), 0);
+  logger_default.info(
+    `[SilenceRemoval] Removed ${effectiveRemovals.length} silence regions (${actualRemoved.toFixed(1)}s). Output: ${editedPath}`
+  );
+  return {
+    editedPath,
+    removals: effectiveRemovals,
+    keepSegments,
+    wasEdited: true
+  };
+}
+
+// src/pipeline.ts
+async function runStage(stageName, fn, stageResults) {
+  costTracker.setStage(stageName);
+  const start = Date.now();
+  try {
+    const result = await fn();
+    const duration = Date.now() - start;
+    stageResults.push({ stage: stageName, success: true, duration });
+    logger_default.info(`Stage ${stageName} completed in ${duration}ms`);
+    return result;
+  } catch (err) {
+    const duration = Date.now() - start;
+    const message = err instanceof Error ? err.message : String(err);
+    stageResults.push({ stage: stageName, success: false, error: message, duration });
+    logger_default.error(`Stage ${stageName} failed after ${duration}ms: ${message}`);
+    return void 0;
+  }
+}
+function adjustTranscript(transcript, removals) {
+  const sorted = [...removals].sort((a, b) => a.start - b.start);
+  function adjustTime(t) {
+    let offset = 0;
+    for (const r of sorted) {
+      if (t <= r.start) break;
+      if (t >= r.end) {
+        offset += r.end - r.start;
+      } else {
+        offset += t - r.start;
+      }
+    }
+    return t - offset;
+  }
+  return {
+    ...transcript,
+    duration: adjustTime(transcript.duration),
+    segments: transcript.segments.filter((seg) => !sorted.some((r) => seg.start >= r.start && seg.end <= r.end)).map((seg) => ({
+      ...seg,
+      start: adjustTime(seg.start),
+      end: adjustTime(seg.end)
+    })),
+    words: transcript.words.filter((w) => !sorted.some((r) => w.start >= r.start && w.end <= r.end)).map((w) => ({
+      ...w,
+      start: adjustTime(w.start),
+      end: adjustTime(w.end)
+    }))
+  };
+}
+async function processVideo(videoPath) {
+  const pipelineStart = Date.now();
+  const stageResults = [];
+  const cfg = getConfig();
+  costTracker.reset();
+  logger_default.info(`Pipeline starting for: ${videoPath}`);
+  const video = await runStage("ingestion" /* Ingestion */, () => ingestVideo(videoPath), stageResults);
+  if (!video) {
+    const totalDuration2 = Date.now() - pipelineStart;
+    logger_default.error("Ingestion failed \u2014 cannot proceed without video metadata");
+    return { video: { originalPath: videoPath, repoPath: "", videoDir: "", slug: "", filename: "", duration: 0, size: 0, createdAt: /* @__PURE__ */ new Date() }, transcript: void 0, editedVideoPath: void 0, captions: void 0, captionedVideoPath: void 0, summary: void 0, shorts: [], mediumClips: [], socialPosts: [], blogPost: void 0, stageResults, totalDuration: totalDuration2 };
+  }
+  let transcript;
+  transcript = await runStage("transcription" /* Transcription */, () => transcribeVideo(video), stageResults);
+  let editedVideoPath;
+  let adjustedTranscript;
+  let silenceRemovals = [];
+  let silenceKeepSegments;
+  if (transcript && !cfg.SKIP_SILENCE_REMOVAL) {
+    const result = await runStage("silence-removal" /* SilenceRemoval */, () => removeDeadSilence(video, transcript), stageResults);
+    if (result && result.wasEdited) {
+      editedVideoPath = result.editedPath;
+      silenceRemovals = result.removals;
+      silenceKeepSegments = result.keepSegments;
+      adjustedTranscript = adjustTranscript(transcript, silenceRemovals);
+      const totalRemoved = silenceRemovals.reduce((sum, r) => sum + (r.end - r.start), 0);
+      const expectedDuration = transcript.duration - totalRemoved;
+      const adjustedDuration = adjustedTranscript.duration;
+      const drift = Math.abs(expectedDuration - adjustedDuration);
+      logger_default.info(`[Pipeline] Silence removal: original=${transcript.duration.toFixed(1)}s, removed=${totalRemoved.toFixed(1)}s, expected=${expectedDuration.toFixed(1)}s, adjusted=${adjustedDuration.toFixed(1)}s, drift=${drift.toFixed(1)}s`);
+      await fs19.writeFile(
+        path17.join(video.videoDir, "transcript-edited.json"),
+        JSON.stringify(adjustedTranscript, null, 2)
+      );
+    }
+  }
+  const captionTranscript = adjustedTranscript ?? transcript;
+  let captions;
+  if (captionTranscript && !cfg.SKIP_CAPTIONS) {
+    captions = await runStage("captions" /* Captions */, () => generateCaptions(video, captionTranscript), stageResults);
+  }
+  let captionedVideoPath;
+  if (captions && !cfg.SKIP_CAPTIONS) {
+    const assFile = captions.find((p) => p.endsWith(".ass"));
+    if (assFile && silenceKeepSegments) {
+      const captionedOutput = path17.join(video.videoDir, `${video.slug}-captioned.mp4`);
+      captionedVideoPath = await runStage(
+        "caption-burn" /* CaptionBurn */,
+        () => singlePassEditAndCaption(video.repoPath, silenceKeepSegments, assFile, captionedOutput),
+        stageResults
+      );
+    } else if (assFile) {
+      const videoToBurn = editedVideoPath ?? video.repoPath;
+      const captionedOutput = path17.join(video.videoDir, `${video.slug}-captioned.mp4`);
+      captionedVideoPath = await runStage(
+        "caption-burn" /* CaptionBurn */,
+        () => burnCaptions(videoToBurn, assFile, captionedOutput),
+        stageResults
+      );
+    }
+  }
+  let shorts = [];
+  if (transcript && !cfg.SKIP_SHORTS) {
+    const result = await runStage("shorts" /* Shorts */, () => generateShorts(video, transcript), stageResults);
+    if (result) shorts = result;
+  }
+  let mediumClips = [];
+  if (transcript && !cfg.SKIP_MEDIUM_CLIPS) {
+    const result = await runStage("medium-clips" /* MediumClips */, () => generateMediumClips(video, transcript), stageResults);
+    if (result) mediumClips = result;
+  }
+  let chapters;
+  if (transcript) {
+    chapters = await runStage("chapters" /* Chapters */, () => generateChapters(video, transcript), stageResults);
+  }
+  let summary;
+  if (transcript) {
+    summary = await runStage("summary" /* Summary */, () => generateSummary(video, transcript, shorts, chapters), stageResults);
+  }
+  let socialPosts = [];
+  if (transcript && summary && !cfg.SKIP_SOCIAL) {
+    const result = await runStage(
+      "social-media" /* SocialMedia */,
+      () => generateSocialPosts(video, transcript, summary, path17.join(video.videoDir, "social-posts")),
+      stageResults
+    );
+    if (result) socialPosts = result;
+  }
+  if (transcript && shorts.length > 0 && !cfg.SKIP_SOCIAL) {
+    await runStage(
+      "short-posts" /* ShortPosts */,
+      async () => {
+        for (const short of shorts) {
+          const posts = await generateShortPosts(video, short, transcript);
+          socialPosts.push(...posts);
+        }
+      },
+      stageResults
+    );
+  }
+  if (transcript && mediumClips.length > 0 && !cfg.SKIP_SOCIAL) {
+    await runStage(
+      "medium-clip-posts" /* MediumClipPosts */,
+      async () => {
+        for (const clip of mediumClips) {
+          const asShortClip = {
+            id: clip.id,
+            title: clip.title,
+            slug: clip.slug,
+            segments: clip.segments,
+            totalDuration: clip.totalDuration,
+            outputPath: clip.outputPath,
+            captionedPath: clip.captionedPath,
+            description: clip.description,
+            tags: clip.tags
+          };
+          const posts = await generateShortPosts(video, asShortClip, transcript);
+          const clipsDir = path17.join(path17.dirname(video.repoPath), "medium-clips");
+          const postsDir = path17.join(clipsDir, clip.slug, "posts");
+          await fs19.mkdir(postsDir, { recursive: true });
+          for (const post of posts) {
+            const destPath = path17.join(postsDir, path17.basename(post.outputPath));
+            await fs19.copyFile(post.outputPath, destPath);
+            await fs19.unlink(post.outputPath).catch(() => {
+            });
+            post.outputPath = destPath;
+          }
+          socialPosts.push(...posts);
+        }
+      },
+      stageResults
+    );
+  }
+  let blogPost;
+  if (transcript && summary) {
+    blogPost = await runStage(
+      "blog" /* Blog */,
+      () => generateBlogPost(video, transcript, summary),
+      stageResults
+    );
+  }
+  if (!cfg.SKIP_GIT) {
+    await runStage("git-push" /* GitPush */, () => commitAndPush(video.slug), stageResults);
+  }
+  const totalDuration = Date.now() - pipelineStart;
+  const report = costTracker.getReport();
+  if (report.records.length > 0) {
+    logger_default.info(costTracker.formatReport());
+    const costMd = generateCostMarkdown(report);
+    const costPath = path17.join(video.videoDir, "cost-report.md");
+    await fs19.writeFile(costPath, costMd, "utf-8");
+    logger_default.info(`Cost report saved: ${costPath}`);
+  }
+  logger_default.info(`Pipeline completed in ${totalDuration}ms`);
+  return {
+    video,
+    transcript,
+    editedVideoPath,
+    captions,
+    captionedVideoPath,
+    summary,
+    chapters,
+    shorts,
+    mediumClips,
+    socialPosts,
+    blogPost,
+    stageResults,
+    totalDuration
+  };
+}
+function generateCostMarkdown(report) {
+  let md = "# Pipeline Cost Report\n\n";
+  md += `| Metric | Value |
+|--------|-------|
+`;
+  md += `| Total Cost | $${report.totalCostUSD.toFixed(4)} USD |
+`;
+  if (report.totalPRUs > 0) md += `| Total PRUs | ${report.totalPRUs} |
+`;
+  md += `| Input Tokens | ${report.totalTokens.input.toLocaleString()} |
+`;
+  md += `| Output Tokens | ${report.totalTokens.output.toLocaleString()} |
+`;
+  md += `| LLM Calls | ${report.records.length} |
+
+`;
+  if (Object.keys(report.byAgent).length > 0) {
+    md += "## By Agent\n\n| Agent | Cost | PRUs | Calls |\n|-------|------|------|-------|\n";
+    for (const [agent, data] of Object.entries(report.byAgent)) {
+      md += `| ${agent} | $${data.costUSD.toFixed(4)} | ${data.prus} | ${data.calls} |
+`;
+    }
+    md += "\n";
+  }
+  if (Object.keys(report.byModel).length > 1) {
+    md += "## By Model\n\n| Model | Cost | PRUs | Calls |\n|-------|------|------|-------|\n";
+    for (const [model, data] of Object.entries(report.byModel)) {
+      md += `| ${model} | $${data.costUSD.toFixed(4)} | ${data.prus} | ${data.calls} |
+`;
+    }
+    md += "\n";
+  }
+  return md;
+}
+async function processVideoSafe(videoPath) {
+  try {
+    return await processVideo(videoPath);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger_default.error(`Pipeline failed with uncaught error: ${message}`);
+    return null;
+  }
+}
+
+// src/commands/doctor.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import path18 from "path";
+var require3 = createRequire2(import.meta.url);
+function normalizeProviderName(raw) {
+  return (raw || "copilot").trim().toLowerCase();
+}
+function resolveFFmpegPath() {
+  if (process.env.FFMPEG_PATH) {
+    return { path: process.env.FFMPEG_PATH, source: "FFMPEG_PATH env" };
+  }
+  try {
+    const staticPath = require3("ffmpeg-static");
+    if (staticPath && existsSync2(staticPath)) {
+      return { path: staticPath, source: "ffmpeg-static" };
+    }
+  } catch {
+  }
+  return { path: "ffmpeg", source: "system PATH" };
+}
+function resolveFFprobePath() {
+  if (process.env.FFPROBE_PATH) {
+    return { path: process.env.FFPROBE_PATH, source: "FFPROBE_PATH env" };
+  }
+  try {
+    const { path: probePath } = require3("@ffprobe-installer/ffprobe");
+    if (probePath && existsSync2(probePath)) {
+      return { path: probePath, source: "@ffprobe-installer/ffprobe" };
+    }
+  } catch {
+  }
+  return { path: "ffprobe", source: "system PATH" };
+}
+function parseVersionFromOutput(output) {
+  const match = output.match(/(\d+\.\d+(?:\.\d+)?)/);
+  return match ? match[1] : "unknown";
+}
+function getFFmpegInstallHint() {
+  const platform = process.platform;
+  const lines = ["Install FFmpeg:"];
+  if (platform === "win32") {
+    lines.push("  winget install Gyan.FFmpeg");
+    lines.push("  choco install ffmpeg        (alternative)");
+  } else if (platform === "darwin") {
+    lines.push("  brew install ffmpeg");
+  } else {
+    lines.push("  sudo apt install ffmpeg     (Debian/Ubuntu)");
+    lines.push("  sudo dnf install ffmpeg     (Fedora)");
+    lines.push("  sudo pacman -S ffmpeg       (Arch)");
+  }
+  lines.push("  Or set FFMPEG_PATH to a custom binary location");
+  return lines.join("\n          ");
+}
+function checkNode() {
+  const raw = process.version;
+  const major = parseInt(raw.slice(1), 10);
+  const ok = major >= 20;
+  return {
+    label: "Node.js",
+    ok,
+    required: true,
+    message: ok ? `Node.js ${raw} (required: \u226520)` : `Node.js ${raw} \u2014 version \u226520 required`
+  };
+}
+function checkFFmpeg() {
+  const { path: binPath, source } = resolveFFmpegPath();
+  try {
+    const result = spawnSync(binPath, ["-version"], { encoding: "utf-8", timeout: 1e4 });
+    if (result.status === 0 && result.stdout) {
+      const ver = parseVersionFromOutput(result.stdout);
+      return { label: "FFmpeg", ok: true, required: true, message: `FFmpeg ${ver} (source: ${source})` };
+    }
+  } catch {
+  }
+  return {
+    label: "FFmpeg",
+    ok: false,
+    required: true,
+    message: `FFmpeg not found \u2014 ${getFFmpegInstallHint()}`
+  };
+}
+function checkFFprobe() {
+  const { path: binPath, source } = resolveFFprobePath();
+  try {
+    const result = spawnSync(binPath, ["-version"], { encoding: "utf-8", timeout: 1e4 });
+    if (result.status === 0 && result.stdout) {
+      const ver = parseVersionFromOutput(result.stdout);
+      return { label: "FFprobe", ok: true, required: true, message: `FFprobe ${ver} (source: ${source})` };
+    }
+  } catch {
+  }
+  return {
+    label: "FFprobe",
+    ok: false,
+    required: true,
+    message: `FFprobe not found \u2014 usually included with FFmpeg.
+          ${getFFmpegInstallHint()}`
+  };
+}
+function checkOpenAIKey() {
+  const set = !!process.env.OPENAI_API_KEY;
+  return {
+    label: "OPENAI_API_KEY",
+    ok: set,
+    required: true,
+    message: set ? "OPENAI_API_KEY is set" : "OPENAI_API_KEY not set \u2014 get one at https://platform.openai.com/api-keys"
+  };
+}
+function checkExaKey() {
+  const set = !!process.env.EXA_API_KEY;
+  return {
+    label: "EXA_API_KEY",
+    ok: set,
+    required: false,
+    message: set ? "EXA_API_KEY is set" : "EXA_API_KEY not set (optional \u2014 web search in social posts)"
+  };
+}
+function checkGit() {
+  try {
+    const result = spawnSync("git", ["--version"], { encoding: "utf-8", timeout: 1e4 });
+    if (result.status === 0 && result.stdout) {
+      const ver = parseVersionFromOutput(result.stdout);
+      return { label: "Git", ok: true, required: false, message: `Git ${ver}` };
     }
-    while (processing) {
-        await new Promise((resolve) => setTimeout(resolve, 500));
+  } catch {
+  }
+  return {
+    label: "Git",
+    ok: false,
+    required: false,
+    message: "Git not found (optional \u2014 needed for auto-commit stage)"
+  };
+}
+function checkWatchFolder() {
+  const watchDir = process.env.WATCH_FOLDER || path18.join(process.cwd(), "watch");
+  const exists = existsSync2(watchDir);
+  return {
+    label: "Watch folder",
+    ok: exists,
+    required: false,
+    message: exists ? `Watch folder exists: ${watchDir}` : `Watch folder missing: ${watchDir}`
+  };
+}
+function runDoctor() {
+  console.log("\n\u{1F50D} VidPipe Doctor \u2014 Checking prerequisites...\n");
+  const results = [
+    checkNode(),
+    checkFFmpeg(),
+    checkFFprobe(),
+    checkOpenAIKey(),
+    checkExaKey(),
+    checkGit(),
+    checkWatchFolder()
+  ];
+  for (const r of results) {
+    const icon = r.ok ? "\u2705" : r.required ? "\u274C" : "\u2B1A";
+    console.log(`  ${icon} ${r.message}`);
+  }
+  console.log("\nLLM Provider");
+  const providerName = normalizeProviderName(process.env.LLM_PROVIDER);
+  const isDefault = !process.env.LLM_PROVIDER;
+  const providerLabel = isDefault ? `${providerName} (default)` : providerName;
+  const validProviders = ["copilot", "openai", "claude"];
+  if (!validProviders.includes(providerName)) {
+    console.log(`  \u274C Provider: ${providerLabel} \u2014 unknown provider`);
+    results.push({ label: "LLM Provider", ok: false, required: true, message: `Unknown provider: ${providerName}` });
+  } else if (providerName === "copilot") {
+    console.log(`  \u2705 Provider: ${providerLabel}`);
+    console.log("  \u2705 Copilot \u2014 uses GitHub auth");
+  } else if (providerName === "openai") {
+    console.log(`  \u2705 Provider: ${providerLabel}`);
+    if (process.env.OPENAI_API_KEY) {
+      console.log("  \u2705 OPENAI_API_KEY is set (also used for Whisper)");
+    } else {
+      console.log("  \u274C OPENAI_API_KEY not set (required for openai provider)");
+      results.push({ label: "LLM Provider", ok: false, required: true, message: "OPENAI_API_KEY not set for OpenAI LLM" });
+    }
+  } else if (providerName === "claude") {
+    console.log(`  \u2705 Provider: ${providerLabel}`);
+    if (process.env.ANTHROPIC_API_KEY) {
+      console.log("  \u2705 ANTHROPIC_API_KEY is set");
+    } else {
+      console.log("  \u274C ANTHROPIC_API_KEY not set (required for claude provider)");
+      results.push({ label: "LLM Provider", ok: false, required: true, message: "ANTHROPIC_API_KEY not set for Claude LLM" });
     }
-    logger.info('Goodbye.');
+  }
+  const defaultModels = {
+    copilot: "Claude Opus 4.6",
+    openai: "gpt-4o",
+    claude: "claude-opus-4.6"
+  };
+  if (validProviders.includes(providerName)) {
+    const defaultModel = defaultModels[providerName];
+    const modelOverride = process.env.LLM_MODEL;
+    if (modelOverride) {
+      console.log(`  \u2139\uFE0F  Model override: ${modelOverride} (default: ${defaultModel})`);
+    } else {
+      console.log(`  \u2139\uFE0F  Default model: ${defaultModel}`);
+    }
+  }
+  const failedRequired = results.filter((r) => r.required && !r.ok);
+  console.log();
+  if (failedRequired.length === 0) {
+    console.log("  All required checks passed! \u2705\n");
     process.exit(0);
+  } else {
+    console.log(`  ${failedRequired.length} required check${failedRequired.length > 1 ? "s" : ""} failed \u274C
+`);
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+import path19 from "path";
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __dirname3 = path19.dirname(fileURLToPath3(import.meta.url));
+var pkg = JSON.parse(readFileSync(path19.resolve(__dirname3, "..", "package.json"), "utf-8"));
+var BANNER = `
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551   VidPipe  v${pkg.version.padEnd(24)}\u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`;
+var program = new Command();
+program.name("vidpipe").description("AI-powered video content pipeline: transcribe, summarize, generate shorts, captions, and social posts").version(pkg.version, "-V, --version").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("--once", "Process a single video and exit (no watching)").option("--brand <path>", "Path to brand.json config (default: ./brand.json)").option("--no-git", "Skip git commit/push stage").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("-v, --verbose", "Verbose logging").option("--doctor", "Check all prerequisites and exit");
+program.parse();
+var opts = program.opts();
+if (opts.doctor) {
+  runDoctor();
+  process.exit(0);
+}
+var videoArg = program.args[0];
+var onceMode = opts.once || !!videoArg;
+var cliOptions = {
+  watchDir: opts.watchDir,
+  outputDir: opts.outputDir,
+  openaiKey: opts.openaiKey,
+  exaKey: opts.exaKey,
+  brand: opts.brand,
+  verbose: opts.verbose,
+  git: opts.git,
+  silenceRemoval: opts.silenceRemoval,
+  shorts: opts.shorts,
+  mediumClips: opts.mediumClips,
+  social: opts.social,
+  captions: opts.captions
+};
+var queue = [];
+var processing = false;
+var shutdownRequested = false;
+var watcher = null;
+async function processQueue() {
+  if (processing || queue.length === 0) return;
+  processing = true;
+  try {
+    while (queue.length > 0) {
+      const videoPath = queue.shift();
+      logger_default.info(`Processing video: ${videoPath}`);
+      await processVideoSafe(videoPath);
+      if (onceMode) {
+        logger_default.info("--once flag set, exiting after first video.");
+        await shutdown();
+        return;
+      }
+      if (shutdownRequested) break;
+    }
+  } finally {
+    processing = false;
+  }
+}
+function enqueue(videoPath) {
+  queue.push(videoPath);
+  logger_default.info(`Queued video: ${videoPath} (queue length: ${queue.length})`);
+  processQueue().catch((err) => logger_default.error("Queue processing error:", err));
+}
+async function shutdown() {
+  if (shutdownRequested) return;
+  shutdownRequested = true;
+  logger_default.info("Shutting down...");
+  if (watcher) {
+    watcher.stop();
+  }
+  while (processing) {
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  logger_default.info("Goodbye.");
+  process.exit(0);
 }
 async function main() {
-    logger.info(BANNER);
-    initConfig(cliOptions);
-    if (opts.verbose)
-        setVerbose();
-    validateRequiredKeys();
-    const config = getConfig();
-    logger.info(`Watch folder: ${config.WATCH_FOLDER}`);
-    logger.info(`Output dir:   ${config.OUTPUT_DIR}`);
-    // Direct file mode: process a specific video and exit
-    if (videoArg) {
-        const resolvedPath = path.resolve(videoArg);
-        logger.info(`Processing single video: ${resolvedPath}`);
-        await processVideoSafe(resolvedPath);
-        logger.info('Done.');
-        process.exit(0);
-    }
-    // Watch mode
-    watcher = new FileWatcher();
-    watcher.on('new-video', (filePath) => {
-        enqueue(filePath);
-    });
-    watcher.start();
-    if (onceMode) {
-        logger.info('Running in --once mode. Will exit after processing the next video.');
-    }
-    else {
-        logger.info('Watching for new videos. Press Ctrl+C to stop.');
-    }
-}
-process.on('SIGINT', () => shutdown());
-process.on('SIGTERM', () => shutdown());
+  logger_default.info(BANNER);
+  initConfig(cliOptions);
+  if (opts.verbose) setVerbose();
+  validateRequiredKeys();
+  const config2 = getConfig();
+  logger_default.info(`Watch folder: ${config2.WATCH_FOLDER}`);
+  logger_default.info(`Output dir:   ${config2.OUTPUT_DIR}`);
+  if (videoArg) {
+    const resolvedPath = path19.resolve(videoArg);
+    logger_default.info(`Processing single video: ${resolvedPath}`);
+    await processVideoSafe(resolvedPath);
+    logger_default.info("Done.");
+    process.exit(0);
+  }
+  watcher = new FileWatcher();
+  watcher.on("new-video", (filePath) => {
+    enqueue(filePath);
+  });
+  watcher.start();
+  if (onceMode) {
+    logger_default.info("Running in --once mode. Will exit after processing the next video.");
+  } else {
+    logger_default.info("Watching for new videos. Press Ctrl+C to stop.");
+  }
+}
+process.on("SIGINT", () => shutdown());
+process.on("SIGTERM", () => shutdown());
 main().catch((err) => {
-    logger.error(`Fatal error: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
+  logger_default.error(`Fatal error: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
 });
 //# sourceMappingURL=index.js.map