vidpipe 1.3.23 → 1.3.24

package/dist/index.js

@@ -206,6 +206,7 @@ var init_types2 = __esm({
       PipelineStage2["MediumClipPosts"] = "medium-clip-posts";
       PipelineStage2["Blog"] = "blog";
       PipelineStage2["QueueBuild"] = "queue-build";
+      PipelineStage2["CloudUpload"] = "cloud-upload";
       return PipelineStage2;
     })(PipelineStage || {});
     PIPELINE_STAGES = [
@@ -225,7 +226,8 @@ var init_types2 = __esm({
       { stage: "short-posts" /* ShortPosts */, name: "Short Posts", stageNumber: 14 },
       { stage: "medium-clip-posts" /* MediumClipPosts */, name: "Medium Clip Posts", stageNumber: 15 },
       { stage: "queue-build" /* QueueBuild */, name: "Queue Build", stageNumber: 16 },
-      { stage: "blog" /* Blog */, name: "Blog", stageNumber: 17 }
+      { stage: "blog" /* Blog */, name: "Blog", stageNumber: 17 },
+      { stage: "cloud-upload" /* CloudUpload */, name: "Cloud Upload", stageNumber: 18 }
     ];
     TOTAL_STAGES = PIPELINE_STAGES.length;
     PLATFORM_CHAR_LIMITS = {
@@ -755,7 +757,22 @@ function resolveConfig(cliOptions = {}) {
       process.env.GITHUB_TOKEN,
       globalConfig.credentials.githubToken
     ),
-    MODEL_OVERRIDES: resolveModelOverrides()
+    MODEL_OVERRIDES: resolveModelOverrides(),
+    AZURE_STORAGE_ACCOUNT_NAME: resolveString(
+      cliOptions.azureStorageAccountName,
+      process.env.AZURE_STORAGE_ACCOUNT_NAME,
+      globalConfig.credentials.azureStorageAccountName
+    ),
+    AZURE_STORAGE_ACCOUNT_KEY: resolveString(
+      cliOptions.azureStorageAccountKey,
+      process.env.AZURE_STORAGE_ACCOUNT_KEY,
+      globalConfig.credentials.azureStorageAccountKey
+    ),
+    AZURE_CONTAINER_NAME: resolveString(
+      cliOptions.azureContainerName,
+      process.env.AZURE_CONTAINER_NAME,
+      "vidpipe"
+    )
   };
 }
 function resolveModelOverrides() {
@@ -969,9 +986,7 @@ function getErrorStatus(error) {
   return void 0;
 }
 function getErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
+  if (error instanceof Error) return error.message;
   if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
     return error.message ?? "Unknown GitHub API error";
   }
@@ -980,8 +995,8 @@ function getErrorMessage(error) {
 function normalizeLabels(labels) {
   return Array.from(new Set(labels.map((label) => label.trim()).filter((label) => label.length > 0)));
 }
-function isIssueResponse(value) {
-  return !("pull_request" in value);
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function getGitHubClient() {
   const config2 = getConfig();
@@ -992,13 +1007,32 @@ function getGitHubClient() {
   }
   return clientInstance;
 }
-var DEFAULT_PER_PAGE, GitHubClientError, GitHubClient, clientInstance, clientKey;
+var CACHE_TTL_MS, MAX_CONCURRENT, THROTTLE_WARN_REMAINING, THROTTLE_SLOW_REMAINING, THROTTLE_CRITICAL_REMAINING, MAX_RETRIES, ISSUE_WITH_COMMENTS_FRAGMENT, GitHubClientError, Semaphore, GitHubClient, clientInstance, clientKey;
 var init_githubClient = __esm({
   "src/L2-clients/github/githubClient.ts"() {
     "use strict";
     init_environment();
     init_configLogger();
-    DEFAULT_PER_PAGE = 100;
+    CACHE_TTL_MS = 5 * 60 * 1e3;
+    MAX_CONCURRENT = 4;
+    THROTTLE_WARN_REMAINING = 200;
+    THROTTLE_SLOW_REMAINING = 100;
+    THROTTLE_CRITICAL_REMAINING = 50;
+    MAX_RETRIES = 3;
+    ISSUE_WITH_COMMENTS_FRAGMENT = `
+  number
+  title
+  body
+  state
+  labels(first: 50) { nodes { name } }
+  comments(first: 100) {
+    nodes { databaseId body createdAt updatedAt url }
+    pageInfo { hasNextPage endCursor }
+  }
+  createdAt
+  updatedAt
+  url
+`;
     GitHubClientError = class extends Error {
       constructor(message, status) {
         super(message);
@@ -1006,10 +1040,40 @@ var init_githubClient = __esm({
         this.name = "GitHubClientError";
       }
     };
+    Semaphore = class {
+      constructor(limit) {
+        this.limit = limit;
+      }
+      queue = [];
+      running = 0;
+      async acquire() {
+        if (this.running < this.limit) {
+          this.running++;
+          return;
+        }
+        return new Promise((resolve3) => {
+          this.queue.push(() => {
+            this.running++;
+            resolve3();
+          });
+        });
+      }
+      release() {
+        this.running--;
+        const next = this.queue.shift();
+        if (next) next();
+      }
+    };
     GitHubClient = class {
       octokit;
       owner;
       repo;
+      // Rate limiting
+      rateLimitRemaining = 5e3;
+      rateLimitReset = 0;
+      semaphore = new Semaphore(MAX_CONCURRENT);
+      // Response cache — keyed by "type:identifier"
+      cache = /* @__PURE__ */ new Map();
       constructor(token, repoFullName) {
         const config2 = getConfig();
         const authToken = token || config2.GITHUB_TOKEN;
@@ -1025,87 +1089,184 @@ var init_githubClient = __esm({
         this.repo = repo;
         this.octokit = new Octokit({ auth: authToken });
       }
-      async createIssue(input) {
-        logger_default.debug(`[GitHubClient] Creating issue in ${this.owner}/${this.repo}: ${input.title}`);
-        try {
-          const response = await this.octokit.rest.issues.create({
-            owner: this.owner,
-            repo: this.repo,
-            title: input.title,
-            body: input.body,
-            labels: input.labels ? normalizeLabels(input.labels) : void 0
-          });
-          const issue = this.mapIssue(response.data);
-          logger_default.info(`[GitHubClient] Created issue #${issue.number}: ${input.title}`);
-          return issue;
-        } catch (error) {
-          this.logError("create issue", error);
-          throw new GitHubClientError(`Failed to create GitHub issue: ${getErrorMessage(error)}`, getErrorStatus(error));
+      // ── Cache helpers ────────────────────────────────────────────────────
+      getCached(key) {
+        const entry = this.cache.get(key);
+        if (!entry) return void 0;
+        if (Date.now() - entry.cachedAt > CACHE_TTL_MS) {
+          this.cache.delete(key);
+          return void 0;
         }
+        return entry.data;
       }
-      async updateIssue(issueNumber, input) {
-        logger_default.debug(`[GitHubClient] Updating issue #${issueNumber} in ${this.owner}/${this.repo}`);
+      setCache(key, data) {
+        this.cache.set(key, { data, cachedAt: Date.now() });
+      }
+      invalidateIssue(issueNumber) {
+        this.cache.delete(`issue:${issueNumber}`);
+        this.cache.delete(`comments:${issueNumber}`);
+        for (const key of this.cache.keys()) {
+          if (key.startsWith("issues:") || key.startsWith("search:")) {
+            this.cache.delete(key);
+          }
+        }
+      }
+      /** Clear all cached data. Useful after bulk writes. */
+      clearCache() {
+        this.cache.clear();
+      }
+      // ── Throttle / rate limit ────────────────────────────────────────────
+      async throttle() {
+        if (this.rateLimitRemaining < THROTTLE_CRITICAL_REMAINING) {
+          const waitMs = Math.max(0, this.rateLimitReset * 1e3 - Date.now()) + 1e3;
+          logger_default.warn(`[GitHubClient] Rate limit critical (${this.rateLimitRemaining} remaining) \u2014 waiting ${Math.round(waitMs / 1e3)}s`);
+          await sleep(Math.min(waitMs, 6e4));
+        } else if (this.rateLimitRemaining < THROTTLE_SLOW_REMAINING) {
+          await sleep(500);
+        } else if (this.rateLimitRemaining < THROTTLE_WARN_REMAINING) {
+          await sleep(100);
+        }
+      }
+      updateRateLimit(headers) {
+        const remaining = headers["x-ratelimit-remaining"];
+        const reset = headers["x-ratelimit-reset"];
+        if (remaining !== void 0) this.rateLimitRemaining = parseInt(remaining, 10) || 0;
+        if (reset !== void 0) this.rateLimitReset = parseInt(reset, 10) || 0;
+      }
+      // ── GraphQL transport ────────────────────────────────────────────────
+      async graphql(query, variables = {}) {
+        await this.semaphore.acquire();
         try {
-          const response = await this.octokit.rest.issues.update({
-            owner: this.owner,
-            repo: this.repo,
-            issue_number: issueNumber,
-            title: input.title,
-            body: input.body,
-            state: input.state,
-            labels: input.labels ? normalizeLabels(input.labels) : void 0
-          });
-          return this.mapIssue(response.data);
-        } catch (error) {
-          this.logError(`update issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to update GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
+          await this.throttle();
+          let lastError;
+          for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            try {
+              const response = await this.octokit.request("POST /graphql", { query, variables });
+              this.updateRateLimit(response.headers);
+              const body = response.data;
+              if (body.errors?.length) {
+                const rateLimited = body.errors.some((e) => e.type === "RATE_LIMITED");
+                if (rateLimited && attempt < MAX_RETRIES - 1) {
+                  const waitMs = Math.max(0, this.rateLimitReset * 1e3 - Date.now()) + 1e3;
+                  logger_default.warn(`[GitHubClient] GraphQL rate limited \u2014 retrying in ${Math.round(waitMs / 1e3)}s`);
+                  await sleep(Math.min(waitMs, 6e4));
+                  continue;
+                }
+                throw new GitHubClientError(`GraphQL error: ${body.errors.map((e) => e.message).join("; ")}`);
+              }
+              if (!body.data) throw new GitHubClientError("GraphQL returned no data");
+              return body.data;
+            } catch (error) {
+              lastError = error;
+              if (error instanceof GitHubClientError) throw error;
+              const status = getErrorStatus(error);
+              if (status === 403 && attempt < MAX_RETRIES - 1) {
+                const backoff = Math.pow(2, attempt) * 1e3;
+                logger_default.warn(`[GitHubClient] 403 \u2014 retrying in ${backoff}ms (attempt ${attempt + 1}/${MAX_RETRIES})`);
+                await sleep(backoff);
+                continue;
+              }
+              throw error;
+            }
+          }
+          throw lastError;
+        } finally {
+          this.semaphore.release();
         }
       }
+      // ── GraphQL mappers ──────────────────────────────────────────────────
+      mapGqlIssue(node) {
+        return {
+          number: node.number,
+          title: node.title,
+          body: node.body ?? "",
+          state: node.state === "OPEN" ? "open" : "closed",
+          labels: node.labels.nodes.map((l) => l.name).filter(Boolean),
+          created_at: node.createdAt,
+          updated_at: node.updatedAt,
+          html_url: node.url
+        };
+      }
+      mapGqlComment(node) {
+        return {
+          id: node.databaseId,
+          body: node.body ?? "",
+          created_at: node.createdAt,
+          updated_at: node.updatedAt,
+          html_url: node.url
+        };
+      }
+      mapGqlComments(node) {
+        return node.comments.nodes.map((c) => this.mapGqlComment(c));
+      }
+      // ── Read operations (GraphQL) ────────────────────────────────────────
       async getIssue(issueNumber) {
+        const cached = this.getCached(`issue:${issueNumber}`);
+        if (cached) return cached;
         logger_default.debug(`[GitHubClient] Fetching issue #${issueNumber} from ${this.owner}/${this.repo}`);
         try {
-          const response = await this.octokit.rest.issues.get({
-            owner: this.owner,
-            repo: this.repo,
-            issue_number: issueNumber
-          });
-          return this.mapIssue(response.data);
+          const data = await this.graphql(
+            `query($owner: String!, $repo: String!, $number: Int!) {
+          repository(owner: $owner, name: $repo) {
+            issue(number: $number) { ${ISSUE_WITH_COMMENTS_FRAGMENT} }
+          }
+        }`,
+            { owner: this.owner, repo: this.repo, number: issueNumber }
+          );
+          if (!data.repository.issue) {
+            throw new GitHubClientError(`Issue #${issueNumber} not found`, 404);
+          }
+          const issue = this.mapGqlIssue(data.repository.issue);
+          const comments = this.mapGqlComments(data.repository.issue);
+          this.setCache(`issue:${issueNumber}`, issue);
+          this.setCache(`comments:${issueNumber}`, comments);
+          return issue;
         } catch (error) {
           this.logError(`get issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to fetch GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
+          throw error instanceof GitHubClientError ? error : new GitHubClientError(`Failed to fetch GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
       }
       async listIssues(options = {}) {
+        const labels = options.labels && options.labels.length > 0 ? normalizeLabels(options.labels) : [];
+        const stateFilter = options.state ?? "all";
+        const cacheKey = `issues:${labels.sort().join(",")}:${stateFilter}`;
+        const cached = this.getCached(cacheKey);
+        if (cached) return options.maxResults ? cached.slice(0, options.maxResults) : cached;
         logger_default.debug(`[GitHubClient] Listing issues for ${this.owner}/${this.repo}`);
-        const issues = [];
-        let page;
         const maxResults = options.maxResults ?? Number.POSITIVE_INFINITY;
+        const gqlStates = stateFilter === "all" ? "[OPEN, CLOSED]" : stateFilter === "open" ? "[OPEN]" : "[CLOSED]";
+        const labelsArg = labels.length > 0 ? `, labels: ${JSON.stringify(labels)}` : "";
         try {
-          while (issues.length < maxResults) {
-            const response = await this.octokit.rest.issues.listForRepo({
-              owner: this.owner,
-              repo: this.repo,
-              state: options.state ?? "all",
-              labels: options.labels && options.labels.length > 0 ? normalizeLabels(options.labels).join(",") : void 0,
-              sort: void 0,
-              direction: void 0,
-              per_page: DEFAULT_PER_PAGE,
-              page
-            });
-            const pageItems = response.data.filter(isIssueResponse).map((issue) => this.mapIssue(issue));
-            issues.push(...pageItems);
-            if (pageItems.length < DEFAULT_PER_PAGE) {
-              break;
+          const allIssues = [];
+          let cursor = null;
+          let hasNext = true;
+          while (hasNext && allIssues.length < maxResults) {
+            const afterArg = cursor ? `, after: "${cursor}"` : "";
+            const data = await this.graphql(
+              `query($owner: String!, $repo: String!) {
+            repository(owner: $owner, name: $repo) {
+              issues(first: 100, states: ${gqlStates}${labelsArg}${afterArg}, orderBy: {field: UPDATED_AT, direction: DESC}) {
+                nodes { ${ISSUE_WITH_COMMENTS_FRAGMENT} }
+                pageInfo { hasNextPage endCursor }
+              }
             }
-            page = (page ?? 1) + 1;
+          }`,
+              { owner: this.owner, repo: this.repo }
+            );
+            const pageData = data.repository.issues;
+            for (const node of pageData.nodes) {
+              const issue = this.mapGqlIssue(node);
+              const comments = this.mapGqlComments(node);
+              allIssues.push(issue);
+              this.setCache(`issue:${issue.number}`, issue);
+              this.setCache(`comments:${issue.number}`, comments);
+            }
+            hasNext = pageData.pageInfo.hasNextPage;
+            cursor = pageData.pageInfo.endCursor;
           }
-          return issues.slice(0, maxResults);
+          const result = allIssues.slice(0, maxResults);
+          this.setCache(cacheKey, result);
+          return result;
         } catch (error) {
           this.logError("list issues", error);
           throw new GitHubClientError(`Failed to list GitHub issues: ${getErrorMessage(error)}`, getErrorStatus(error));
@@ -1113,22 +1274,89 @@ var init_githubClient = __esm({
       }
       async searchIssues(query, options = {}) {
         const searchQuery = `repo:${this.owner}/${this.repo} is:issue ${query}`.trim();
+        const cacheKey = `search:${searchQuery}`;
+        const cached = this.getCached(cacheKey);
+        if (cached) return options.maxResults ? cached.slice(0, options.maxResults) : cached;
         logger_default.debug(`[GitHubClient] Searching issues in ${this.owner}/${this.repo}: ${query}`);
         try {
-          const items = await this.octokit.paginate(this.octokit.rest.search.issuesAndPullRequests, {
-            q: searchQuery,
-            per_page: DEFAULT_PER_PAGE
+          const data = await this.graphql(
+            `query($q: String!) {
+          search(query: $q, type: ISSUE, first: 100) {
+            nodes {
+              ... on Issue { __typename ${ISSUE_WITH_COMMENTS_FRAGMENT} }
+            }
+          }
+        }`,
+            { q: searchQuery }
+          );
+          const issues = data.search.nodes.filter((n) => n.__typename === "Issue").map((node) => {
+            const issue = this.mapGqlIssue(node);
+            const comments = this.mapGqlComments(node);
+            this.setCache(`issue:${issue.number}`, issue);
+            this.setCache(`comments:${issue.number}`, comments);
+            return issue;
           });
-          return items.filter(isIssueResponse).map((issue) => this.mapIssue(issue)).slice(0, options.maxResults ?? Number.POSITIVE_INFINITY);
+          const result = issues.slice(0, options.maxResults ?? Number.POSITIVE_INFINITY);
+          this.setCache(cacheKey, result);
+          return result;
         } catch (error) {
           this.logError("search issues", error);
           throw new GitHubClientError(`Failed to search GitHub issues: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
       }
-      async addLabels(issueNumber, labels) {
-        if (labels.length === 0) {
-          return;
+      async listComments(issueNumber) {
+        const cached = this.getCached(`comments:${issueNumber}`);
+        if (cached) return cached;
+        logger_default.debug(`[GitHubClient] Listing comments for issue #${issueNumber} in ${this.owner}/${this.repo}`);
+        try {
+          await this.getIssue(issueNumber);
+          return this.getCached(`comments:${issueNumber}`) ?? [];
+        } catch (error) {
+          this.logError(`list comments for issue #${issueNumber}`, error);
+          throw error instanceof GitHubClientError ? error : new GitHubClientError(`Failed to list comments for GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
+        }
+      }
+      // ── Write operations (REST — infrequent, keep on separate quota) ─────
+      async createIssue(input) {
+        logger_default.debug(`[GitHubClient] Creating issue in ${this.owner}/${this.repo}: ${input.title}`);
+        try {
+          const response = await this.octokit.rest.issues.create({
+            owner: this.owner,
+            repo: this.repo,
+            title: input.title,
+            body: input.body,
+            labels: input.labels ? normalizeLabels(input.labels) : void 0
+          });
+          const issue = this.mapRestIssue(response.data);
+          logger_default.info(`[GitHubClient] Created issue #${issue.number}: ${input.title}`);
+          return issue;
+        } catch (error) {
+          this.logError("create issue", error);
+          throw new GitHubClientError(`Failed to create GitHub issue: ${getErrorMessage(error)}`, getErrorStatus(error));
+        }
+      }
+      async updateIssue(issueNumber, input) {
+        logger_default.debug(`[GitHubClient] Updating issue #${issueNumber} in ${this.owner}/${this.repo}`);
+        try {
+          const response = await this.octokit.rest.issues.update({
+            owner: this.owner,
+            repo: this.repo,
+            issue_number: issueNumber,
+            title: input.title,
+            body: input.body,
+            state: input.state,
+            labels: input.labels ? normalizeLabels(input.labels) : void 0
+          });
+          const issue = this.mapRestIssue(response.data);
+          this.invalidateIssue(issueNumber);
+          return issue;
+        } catch (error) {
+          this.logError(`update issue #${issueNumber}`, error);
+          throw new GitHubClientError(`Failed to update GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
+      }
+      async addLabels(issueNumber, labels) {
+        if (labels.length === 0) return;
         logger_default.debug(`[GitHubClient] Adding labels to issue #${issueNumber} in ${this.owner}/${this.repo}`);
         try {
           await this.octokit.rest.issues.addLabels({
@@ -1137,12 +1365,10 @@ var init_githubClient = __esm({
             issue_number: issueNumber,
             labels
           });
+          this.invalidateIssue(issueNumber);
         } catch (error) {
           this.logError(`add labels to issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to add labels to GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
+          throw new GitHubClientError(`Failed to add labels to GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
       }
       async removeLabel(issueNumber, label) {
@@ -1154,15 +1380,11 @@ var init_githubClient = __esm({
             issue_number: issueNumber,
             name: label
           });
+          this.invalidateIssue(issueNumber);
         } catch (error) {
-          if (getErrorStatus(error) === 404) {
-            return;
-          }
+          if (getErrorStatus(error) === 404) return;
           this.logError(`remove label from issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to remove label from GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
+          throw new GitHubClientError(`Failed to remove label from GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
       }
       async setLabels(issueNumber, labels) {
@@ -1174,12 +1396,10 @@ var init_githubClient = __esm({
             issue_number: issueNumber,
             labels
           });
+          this.invalidateIssue(issueNumber);
         } catch (error) {
           this.logError(`set labels on issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to set labels on GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
+          throw new GitHubClientError(`Failed to set labels on GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
       }
       async addComment(issueNumber, body) {
@@ -1191,52 +1411,34 @@ var init_githubClient = __esm({
             issue_number: issueNumber,
             body
           });
-          return this.mapComment(response.data);
+          this.invalidateIssue(issueNumber);
+          return this.mapRestComment(response.data);
         } catch (error) {
           this.logError(`add comment to issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to add comment to GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
+          throw new GitHubClientError(`Failed to add comment to GitHub issue #${issueNumber}: ${getErrorMessage(error)}`, getErrorStatus(error));
         }
       }
-      async listComments(issueNumber) {
-        logger_default.debug(`[GitHubClient] Listing comments for issue #${issueNumber} in ${this.owner}/${this.repo}`);
-        try {
-          const comments = await this.octokit.paginate(this.octokit.rest.issues.listComments, {
-            owner: this.owner,
-            repo: this.repo,
-            issue_number: issueNumber,
-            per_page: DEFAULT_PER_PAGE
-          });
-          return comments.map((comment) => this.mapComment(comment));
-        } catch (error) {
-          this.logError(`list comments for issue #${issueNumber}`, error);
-          throw new GitHubClientError(
-            `Failed to list comments for GitHub issue #${issueNumber}: ${getErrorMessage(error)}`,
-            getErrorStatus(error)
-          );
-        }
-      }
-      mapIssue(issue) {
+      // ── REST mappers (for write operations) ──────────────────────────────
+      mapRestIssue(data) {
+        const labels = Array.isArray(data.labels) ? data.labels : [];
         return {
-          number: issue.number,
-          title: issue.title,
-          body: issue.body ?? "",
-          state: issue.state,
-          labels: issue.labels.map((label) => typeof label === "string" ? label : label.name ?? "").map((label) => label.trim()).filter((label) => label.length > 0),
-          created_at: issue.created_at,
-          updated_at: issue.updated_at,
-          html_url: issue.html_url
+          number: data.number,
+          title: data.title,
+          body: data.body ?? "",
+          state: data.state,
+          labels: labels.map((l) => typeof l === "string" ? l : l?.name ?? "").map((l) => l.trim()).filter((l) => l.length > 0),
+          created_at: data.created_at,
+          updated_at: data.updated_at,
+          html_url: data.html_url
         };
       }
-      mapComment(comment) {
+      mapRestComment(data) {
         return {
-          id: comment.id,
-          body: comment.body ?? "",
-          created_at: comment.created_at,
-          updated_at: comment.updated_at,
-          html_url: comment.html_url
+          id: data.id,
+          body: data.body ?? "",
+          created_at: data.created_at,
+          updated_at: data.updated_at,
+          html_url: data.html_url
         };
       }
       logError(action, error) {
@@ -2798,7 +3000,7 @@ var require_semaphore = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Semaphore = void 0;
     var ral_1 = require_ral();
-    var Semaphore = class {
+    var Semaphore2 = class {
       constructor(capacity = 1) {
         if (capacity <= 0) {
           throw new Error("Capacity must be greater than 0");
@@ -2855,7 +3057,7 @@ var require_semaphore = __commonJS({
         }
       }
     };
-    exports.Semaphore = Semaphore;
+    exports.Semaphore = Semaphore2;
   }
 });
 
@@ -7949,6 +8151,14 @@ var init_providerFactory = __esm({
   }
 });
 
+// src/L1-infra/http/network.ts
+import { Readable } from "stream";
+var init_network = __esm({
+  "src/L1-infra/http/network.ts"() {
+    "use strict";
+  }
+});
+
 // src/L1-infra/http/httpClient.ts
 async function fetchRaw(url, options) {
   return fetch(url, options);
@@ -7959,6 +8169,330 @@ var init_httpClient = __esm({
   }
 });
 
+// src/L2-clients/late/lateApi.ts
+var LateApiClient;
+var init_lateApi = __esm({
+  "src/L2-clients/late/lateApi.ts"() {
+    "use strict";
+    init_environment();
+    init_configLogger();
+    init_fileSystem();
+    init_network();
+    init_paths();
+    init_httpClient();
+    LateApiClient = class {
+      baseUrl = "https://getlate.dev/api/v1";
+      apiKey;
+      constructor(apiKey) {
+        this.apiKey = apiKey ?? getConfig().LATE_API_KEY;
+        if (!this.apiKey) {
+          throw new Error("LATE_API_KEY is required \u2014 set it in environment or pass to constructor");
+        }
+      }
+      // ── Private request helper ───────────────────────────────────────────
+      async request(endpoint, options = {}, retries = 3) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const headers = {
+          Authorization: `Bearer ${this.apiKey}`,
+          ...options.headers
+        };
+        if (!(options.body instanceof FormData)) {
+          headers["Content-Type"] = "application/json";
+        }
+        logger_default.debug(`Late API ${options.method ?? "GET"} ${endpoint}`);
+        for (let attempt = 1; attempt <= retries; attempt++) {
+          const response = await fetchRaw(url, { ...options, headers });
+          if (response.ok) {
+            if (response.status === 204) return void 0;
+            return await response.json();
+          }
+          if (response.status === 429 && attempt < retries) {
+            const retryAfter = Number(response.headers.get("Retry-After")) || 2;
+            logger_default.warn(`Late API rate limited, retrying in ${retryAfter}s (attempt ${attempt}/${retries})`);
+            await new Promise((r) => setTimeout(r, retryAfter * 1e3));
+            continue;
+          }
+          if (response.status === 401) {
+            throw new Error(
+              "Late API authentication failed (401). Check that LATE_API_KEY is valid."
+            );
+          }
+          const body = await response.text().catch(() => "<no body>");
+          throw new Error(
+            `Late API error ${response.status} ${options.method ?? "GET"} ${endpoint}: ${body}`
+          );
+        }
+        throw new Error(`Late API request failed after ${retries} retries`);
+      }
+      // ── Core methods ─────────────────────────────────────────────────────
+      async listProfiles() {
+        const data = await this.request("/profiles");
+        return data.profiles ?? [];
+      }
+      async listAccounts() {
+        const data = await this.request("/accounts");
+        return data.accounts ?? [];
+      }
+      async getScheduledPosts(platform) {
+        return this.listPosts({ status: "scheduled", platform });
+      }
+      async getDraftPosts(platform) {
+        return this.listPosts({ status: "draft", platform });
+      }
+      async createPost(params) {
+        const data = await this.request("/posts", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
+        return data.post;
+      }
+      async deletePost(postId) {
+        await this.request(`/posts/${encodeURIComponent(postId)}`, {
+          method: "DELETE"
+        });
+      }
+      async updatePost(postId, updates) {
+        const data = await this.request(`/posts/${encodeURIComponent(postId)}`, {
+          method: "PUT",
+          body: JSON.stringify(updates)
+        });
+        return data.post;
+      }
+      /** Reschedule a post and ensure it transitions out of draft status. */
+      async schedulePost(postId, scheduledFor) {
+        return this.updatePost(postId, { scheduledFor, isDraft: false });
+      }
+      async uploadMedia(filePath) {
+        const fileStats = await getFileStats(filePath);
+        const fileName = basename(filePath);
+        const ext = extname(fileName).toLowerCase();
+        const contentType = ext === ".mp4" ? "video/mp4" : ext === ".webm" ? "video/webm" : ext === ".mov" ? "video/quicktime" : "video/mp4";
+        logger_default.info(`Late API uploading ${String(fileName).replace(/[\r\n]/g, "")} (${(fileStats.size / 1024 / 1024).toFixed(1)} MB)`);
+        const presign = await this.request("/media/presign", {
+          method: "POST",
+          body: JSON.stringify({ filename: fileName, contentType })
+        });
+        logger_default.debug(`Late API presigned URL obtained for ${String(fileName).replace(/[\r\n]/g, "")} (expires in ${presign.expiresIn}s)`);
+        const nodeStream = openReadStream(filePath);
+        try {
+          const webStream = Readable.toWeb(nodeStream);
+          const uploadResp = await fetchRaw(presign.uploadUrl, {
+            method: "PUT",
+            headers: {
+              "Content-Type": contentType,
+              "Content-Length": String(fileStats.size)
+            },
+            body: webStream,
+            // Node.js-specific property for streaming request bodies (not in standard RequestInit type)
+            duplex: "half"
+          });
+          if (!uploadResp.ok) {
+            throw new Error(`Late media upload failed: ${uploadResp.status} ${uploadResp.statusText}`);
+          }
+        } finally {
+          nodeStream.destroy();
+        }
+        logger_default.debug(`Late API media uploaded \u2192 ${presign.publicUrl}`);
+        const type = contentType.startsWith("image/") ? "image" : "video";
+        return { url: presign.publicUrl, type };
+      }
+      /**
+       * Fetch posts with pagination, iterating pages until all results are collected.
+       * Supports filtering by status and platform.
+       */
+      async listPosts(options = {}) {
+        const limit = options.limit ?? 100;
+        const allPosts = [];
+        let page = 1;
+        while (true) {
+          const params = new URLSearchParams();
+          if (options.status) params.set("status", options.status);
+          if (options.platform) params.set("platform", options.platform);
+          params.set("limit", String(limit));
+          params.set("page", String(page));
+          const data = await this.request(
+            `/posts?${params}`
+          );
+          const posts = data.posts ?? data.data ?? [];
+          allPosts.push(...posts);
+          if (posts.length < limit) break;
+          page++;
+        }
+        return allPosts;
+      }
+      // ── Queue management ─────────────────────────────────────────────────
+      async listQueues(profileId, all = false) {
+        const params = new URLSearchParams({ profileId });
+        if (all) params.set("all", "true");
+        return this.request(`/queue/slots?${params}`);
+      }
+      async createQueue(params) {
+        return this.request("/queue/slots", { method: "POST", body: JSON.stringify(params) });
+      }
+      async updateQueue(params) {
+        return this.request("/queue/slots", { method: "PUT", body: JSON.stringify(params) });
+      }
+      async deleteQueue(profileId, queueId) {
+        return this.request(`/queue/slots?profileId=${profileId}&queueId=${queueId}`, { method: "DELETE" });
+      }
+      async previewQueue(profileId, queueId, count = 20) {
+        const params = new URLSearchParams({ profileId, count: String(count) });
+        if (queueId) params.set("queueId", queueId);
+        return this.request(`/queue/preview?${params}`);
+      }
+      async getNextQueueSlot(profileId, queueId) {
+        const params = new URLSearchParams({ profileId });
+        if (queueId) params.set("queueId", queueId);
+        return this.request(`/queue/next-slot?${params}`);
+      }
+      // ── Helper ───────────────────────────────────────────────────────────
+      async validateConnection() {
+        try {
+          const profiles = await this.listProfiles();
+          const name = profiles[0]?.name;
+          logger_default.info(`Late API connection valid \u2014 profile: ${name ?? "unknown"}`);
+          return { valid: true, profileName: name };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          logger_default.error(`Late API connection failed: ${message}`);
+          return { valid: false, error: message };
+        }
+      }
+    };
+  }
+});
+
+// src/L3-services/queueMapping/queueMapping.ts
+function cachePath() {
+  return join(process.cwd(), CACHE_FILE);
+}
+function isCacheValid(cache) {
+  const fetchedAtTime = new Date(cache.fetchedAt).getTime();
+  if (Number.isNaN(fetchedAtTime)) {
+    logger_default.warn("Invalid fetchedAt in queue cache; treating as stale", {
+      fetchedAt: cache.fetchedAt
+    });
+    return false;
+  }
+  const age = Date.now() - fetchedAtTime;
+  return age < CACHE_TTL_MS2;
+}
+async function readFileCache() {
+  try {
+    const raw = await readTextFile(cachePath());
+    const cache = JSON.parse(raw);
+    if (cache.mappings && cache.profileId && cache.fetchedAt && isCacheValid(cache)) {
+      return cache;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function writeFileCache(cache) {
+  try {
+    if (!cache || typeof cache !== "object" || !cache.mappings || !cache.profileId || !cache.fetchedAt) {
+      logger_default.warn("Invalid queue cache structure, skipping write");
+      return;
+    }
+    const sanitized = {
+      mappings: typeof cache.mappings === "object" ? { ...cache.mappings } : {},
+      profileId: String(cache.profileId),
+      fetchedAt: String(cache.fetchedAt)
+    };
+    for (const [name, id] of Object.entries(sanitized.mappings)) {
+      if (typeof name !== "string" || typeof id !== "string" || /[\x00-\x1f]/.test(name) || /[\x00-\x1f]/.test(id)) {
+        logger_default.warn("Invalid queue mapping data from API, skipping cache write");
+        return;
+      }
+    }
+    const resolvedCachePath = resolve(cachePath());
+    if (!resolvedCachePath.startsWith(resolve(process.cwd()) + sep)) {
+      throw new Error("Cache path outside working directory");
+    }
+    await writeTextFile(resolvedCachePath, JSON.stringify(sanitized, null, 2));
+  } catch (err) {
+    logger_default.warn("Failed to write queue cache file", { error: err });
+  }
+}
+async function fetchAndCache() {
+  const client = new LateApiClient();
+  const profiles = await client.listProfiles();
+  if (profiles.length === 0) {
+    logger_default.warn("No Late API profiles found \u2014 queue mappings will be empty");
+    const emptyCache = {
+      mappings: {},
+      profileId: "",
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    memoryCache = emptyCache;
+    return emptyCache;
+  }
+  const profileId = profiles[0]._id;
+  const { queues } = await client.listQueues(profileId, true);
+  if (queues.length === 0) {
+    logger_default.warn(
+      "No queues found in Late API \u2014 run `vidpipe sync-queues` to create platform queues"
+    );
+  }
+  const mappings = {};
+  for (const queue of queues) {
+    mappings[queue.name] = queue._id;
+  }
+  const cache = {
+    mappings,
+    profileId,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  memoryCache = cache;
+  await writeFileCache(cache);
+  logger_default.info("Refreshed Late queue mappings", {
+    queueCount: queues.length,
+    queues: Object.keys(mappings)
+  });
+  return cache;
+}
+async function ensureMappings() {
+  if (memoryCache && isCacheValid(memoryCache)) {
+    return memoryCache;
+  }
+  const fileCache = await readFileCache();
+  if (fileCache) {
+    memoryCache = fileCache;
+    return fileCache;
+  }
+  try {
+    return await fetchAndCache();
+  } catch (err) {
+    logger_default.error("Failed to fetch Late queue mappings", { error: err });
+    return { mappings: {}, profileId: "", fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function getQueueId(platform, clipType) {
+  const cache = await ensureMappings();
+  const normalizedPlatform = platform === "twitter" ? "x" : platform;
+  const normalizedClipType = clipType === "medium-clip" ? "medium" : clipType;
+  const queueName = `${normalizedPlatform}-${normalizedClipType}`;
+  return cache.mappings[queueName] ?? null;
+}
+async function getProfileId() {
+  const cache = await ensureMappings();
+  return cache.profileId;
+}
+var CACHE_FILE, CACHE_TTL_MS2, memoryCache;
+var init_queueMapping = __esm({
+  "src/L3-services/queueMapping/queueMapping.ts"() {
+    "use strict";
+    init_lateApi();
+    init_configLogger();
+    init_fileSystem();
+    init_paths();
+    CACHE_FILE = ".vidpipe-queue-cache.json";
+    CACHE_TTL_MS2 = 24 * 60 * 60 * 1e3;
+    memoryCache = null;
+  }
+});
+
 // src/L2-clients/ffmpeg/audioExtraction.ts
 async function extractAudio(videoPath, outputPath, options = {}) {
   const { format = "mp3" } = options;
@@ -8922,7 +9456,8 @@ async function convertWithSmartLayout(inputPath, outputPath, config2, webcamOver
   const webcam = webcamOverride !== void 0 ? webcamOverride : await detectWebcamRegion(inputPath);
   if (!webcam) {
     logger_default.info(`[${label}] No webcam found, falling back to center-crop`);
-    return convertAspectRatio(inputPath, outputPath, fallbackRatio);
+    const path = await convertAspectRatio(inputPath, outputPath, fallbackRatio);
+    return { path, isSplitScreen: false };
   }
   const resolution = await getVideoResolution(inputPath);
   const margin = Math.round(resolution.width * 0.02);
@@ -8987,7 +9522,7 @@ async function convertWithSmartLayout(inputPath, outputPath, config2, webcamOver
         return;
       }
       logger_default.info(`[${label}] Complete: ${outputPath}`);
-      resolve3(outputPath);
+      resolve3({ path: outputPath, isSplitScreen: true });
     });
   });
 }
@@ -9033,21 +9568,25 @@ async function generatePlatformVariants(inputPath, outputDir, slug, platforms =
     const suffix = ratio === "9:16" ? "portrait" : ratio === "4:5" ? "feed" : "square";
     const outPath = join(outputDir, `${slug}-${suffix}.mp4`);
     try {
+      let isSplitScreen = false;
       if (ratio === "9:16") {
         if (options.useAgent) {
           logger_default.warn(`[generatePlatformVariants] LayoutAgent is disabled, falling back to ONNX pipeline`);
         }
-        await convertToPortraitSmart(inputPath, outPath, options.webcamOverride);
+        const result = await convertToPortraitSmart(inputPath, outPath, options.webcamOverride);
+        isSplitScreen = result.isSplitScreen;
       } else if (ratio === "1:1") {
-        await convertToSquareSmart(inputPath, outPath, options.webcamOverride);
+        const result = await convertToSquareSmart(inputPath, outPath, options.webcamOverride);
+        isSplitScreen = result.isSplitScreen;
       } else if (ratio === "4:5") {
-        await convertToFeedSmart(inputPath, outPath, options.webcamOverride);
+        const result = await convertToFeedSmart(inputPath, outPath, options.webcamOverride);
+        isSplitScreen = result.isSplitScreen;
       } else {
         await convertAspectRatio(inputPath, outPath, ratio);
       }
       const dims = DIMENSIONS[ratio];
       for (const p of associatedPlatforms) {
-        variants.push({ platform: p, aspectRatio: ratio, path: outPath, width: dims.width, height: dims.height });
+        variants.push({ platform: p, aspectRatio: ratio, path: outPath, width: dims.width, height: dims.height, isSplitScreen });
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -9635,9 +10174,9 @@ var init_BaseAgent = __esm({
       getUserInputHandler() {
         return void 0;
       }
-      /** Timeout for sendAndWait calls. Override in interactive agents that need longer timeouts. */
+      /** Timeout for sendAndWait calls. 0 = no timeout. Override in subclasses if needed. */
       getTimeoutMs() {
-        return 3e5;
+        return 0;
       }
       /**
        * Reset agent-specific state before a retry attempt.
@@ -10159,15 +10698,564 @@ var init_ThumbnailAgent = __esm({
 - **Title:** ${context.title}
 - **Description:** ${context.description}${hookStr}${topicsStr}${platformStr}
 
-Call the generate_thumbnail tool with a detailed, vivid prompt that will create a click-worthy thumbnail. Remember to include text overlay in your prompt (3-5 words max).`;
-        await this.run(userMessage);
-        return this.generatedThumbnails;
-      }
-      /** Clean up the LLM session. */
-      async destroy() {
-        await super.destroy();
-      }
-    };
+Call the generate_thumbnail tool with a detailed, vivid prompt that will create a click-worthy thumbnail. Remember to include text overlay in your prompt (3-5 words max).`;
+        await this.run(userMessage);
+        return this.generatedThumbnails;
+      }
+      /** Clean up the LLM session. */
+      async destroy() {
+        await super.destroy();
+      }
+    };
+  }
+});
+
+// src/L2-clients/azure/blobClient.ts
+import { BlobServiceClient, StorageSharedKeyCredential } from "@azure/storage-blob";
+import { Readable as Readable2 } from "stream";
+import { createReadStream as createReadStream2 } from "fs";
+import { stat } from "fs/promises";
+function getClient() {
+  const config2 = getConfig();
+  const accountName = config2.AZURE_STORAGE_ACCOUNT_NAME;
+  const accountKey = config2.AZURE_STORAGE_ACCOUNT_KEY;
+  const containerName = config2.AZURE_CONTAINER_NAME;
+  if (!accountName || !accountKey) {
+    throw new Error("Azure Storage credentials not configured. Set AZURE_STORAGE_ACCOUNT_NAME and AZURE_STORAGE_ACCOUNT_KEY.");
+  }
+  const credential = new StorageSharedKeyCredential(accountName, accountKey);
+  const blobService = new BlobServiceClient(`https://${accountName}.blob.core.windows.net`, credential);
+  const container = blobService.getContainerClient(containerName);
+  return { blobService, container };
+}
+async function uploadFile(blobPath, localFilePath, contentType) {
+  const { container } = getClient();
+  const blockBlob = container.getBlockBlobClient(blobPath);
+  const fileStat = await stat(localFilePath);
+  await blockBlob.uploadStream(
+    createReadStream2(localFilePath),
+    4 * 1024 * 1024,
+    // 4MB buffer size
+    5,
+    // max concurrency
+    {
+      blobHTTPHeaders: contentType ? { blobContentType: contentType } : void 0
+    }
+  );
+  logger_default.debug(`Uploaded file to blob: ${blobPath} (${fileStat.size} bytes)`);
+  return blockBlob.url;
+}
+async function downloadToFile(blobPath, localPath) {
+  const { container } = getClient();
+  const blockBlob = container.getBlockBlobClient(blobPath);
+  await blockBlob.downloadToFile(localPath);
+  logger_default.debug(`Downloaded blob to file: ${blobPath} \u2192 ${localPath}`);
+}
+async function downloadStream(blobPath) {
+  const { container } = getClient();
+  const blockBlob = container.getBlockBlobClient(blobPath);
+  const response = await blockBlob.download(0);
+  if (!response.readableStreamBody) {
+    throw new Error(`Failed to get readable stream for blob: ${blobPath}`);
+  }
+  return Readable2.from(response.readableStreamBody);
+}
+async function listBlobs(prefix) {
+  const { container } = getClient();
+  const blobs = [];
+  for await (const blob of container.listBlobsFlat({ prefix })) {
+    blobs.push(blob.name);
+  }
+  return blobs;
+}
+function isAzureConfigured() {
+  const config2 = getConfig();
+  return Boolean(config2.AZURE_STORAGE_ACCOUNT_NAME && config2.AZURE_STORAGE_ACCOUNT_KEY);
+}
+var init_blobClient = __esm({
+  "src/L2-clients/azure/blobClient.ts"() {
+    "use strict";
+    init_configLogger();
+    init_environment();
+  }
+});
+
+// src/L2-clients/azure/tableClient.ts
+import { TableClient as AzureTableClient, AzureNamedKeyCredential } from "@azure/data-tables";
+function getTableClient(tableName) {
+  const config2 = getConfig();
+  const accountName = config2.AZURE_STORAGE_ACCOUNT_NAME;
+  const accountKey = config2.AZURE_STORAGE_ACCOUNT_KEY;
+  if (!accountName || !accountKey) {
+    throw new Error("Azure Storage credentials not configured. Set AZURE_STORAGE_ACCOUNT_NAME and AZURE_STORAGE_ACCOUNT_KEY.");
+  }
+  const credential = new AzureNamedKeyCredential(accountName, accountKey);
+  const url = `https://${accountName}.table.core.windows.net`;
+  return new AzureTableClient(url, tableName, credential);
+}
+async function upsertEntity(tableName, partitionKey, rowKey, properties) {
+  const client = getTableClient(tableName);
+  const entity = { partitionKey, rowKey, ...properties };
+  await client.upsertEntity(entity, "Merge");
+  logger_default.debug(`Upserted entity: ${tableName}/${partitionKey}/${rowKey}`);
+}
+async function getEntity(tableName, partitionKey, rowKey) {
+  const client = getTableClient(tableName);
+  try {
+    return await client.getEntity(partitionKey, rowKey);
+  } catch (error) {
+    if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function queryEntities(tableName, filter) {
+  const client = getTableClient(tableName);
+  const entities = [];
+  for await (const entity of client.listEntities({ queryOptions: { filter } })) {
+    entities.push(entity);
+  }
+  return entities;
+}
+async function updateEntity(tableName, partitionKey, rowKey, properties) {
+  const client = getTableClient(tableName);
+  const entity = { partitionKey, rowKey, ...properties };
+  await client.updateEntity(entity, "Merge");
+  logger_default.debug(`Updated entity: ${tableName}/${partitionKey}/${rowKey}`);
+}
+var init_tableClient = __esm({
+  "src/L2-clients/azure/tableClient.ts"() {
+    "use strict";
+    init_configLogger();
+    init_environment();
+  }
+});
+
+// src/L3-services/azureStorage/azureStorageService.ts
+var azureStorageService_exports = {};
+__export(azureStorageService_exports, {
+  downloadBlobToFile: () => downloadBlobToFile,
+  downloadContentMedia: () => downloadContentMedia,
+  findContentItemByRowKey: () => findContentItemByRowKey,
+  getContentItem: () => getContentItem,
+  getContentItems: () => getContentItems,
+  getRunId: () => getRunId,
+  getVideoRecord: () => getVideoRecord,
+  isAzureConfigured: () => isAzureConfigured2,
+  listVideos: () => listVideos,
+  migrateLocalContent: () => migrateLocalContent,
+  updateContentStatus: () => updateContentStatus,
+  uploadContentItem: () => uploadContentItem,
+  uploadPublishQueue: () => uploadPublishQueue,
+  uploadRawVideo: () => uploadRawVideo,
+  uploadVideoFile: () => uploadVideoFile
+});
+import { readdir, readFile } from "fs/promises";
+import { join as join8 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+async function uploadVideoFile(localPath, blobPath) {
+  logger_default.info(`Uploading video to Azure blob: ${blobPath}`);
+  return uploadFile(blobPath, localPath, "video/mp4");
+}
+async function downloadBlobToFile(blobPath, localPath) {
+  return downloadToFile(blobPath, localPath);
+}
+function isAzureConfigured2() {
+  return isAzureConfigured();
+}
+function getRunId() {
+  return process.env.GITHUB_RUN_ID || randomUUID2();
+}
+async function uploadRawVideo(localPath, runId, metadata) {
+  const blobPath = `raw/${runId}-${metadata.originalFilename}`;
+  logger_default.info(`Uploading raw video to Azure: ${blobPath}`);
+  await uploadFile(blobPath, localPath, "video/mp4");
+  await upsertEntity(VIDEOS_TABLE, "video", runId, {
+    originalFilename: metadata.originalFilename,
+    slug: metadata.slug,
+    blobPath,
+    sourceUrl: metadata.sourceUrl || "",
+    duration: metadata.duration || 0,
+    size: metadata.size,
+    status: "completed",
+    contentCount: 0,
+    processedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  logger_default.info(`Created video record: ${runId}`);
+  return blobPath;
+}
+async function uploadContentItem(localItemDir, itemId, videoSlug, runId, metadata) {
+  const blobBasePath = `content/${itemId}/`;
+  const files = await readdir(localItemDir);
+  for (const file of files) {
+    const localFilePath = join8(localItemDir, file);
+    const blobPath = `${blobBasePath}${file}`;
+    const contentType = getContentType(file);
+    await uploadFile(blobPath, localFilePath, contentType);
+  }
+  let itemMetadata = {};
+  const metadataPath = join8(localItemDir, "metadata.json");
+  try {
+    const metadataContent = await readFile(metadataPath, "utf8");
+    itemMetadata = JSON.parse(metadataContent);
+  } catch {
+  }
+  let postContent = "";
+  const postPath = join8(localItemDir, "post.md");
+  try {
+    postContent = await readFile(postPath, "utf8");
+  } catch {
+  }
+  const mediaFilename = files.find((f) => f.startsWith("media.")) || "";
+  const thumbnailFilename = files.find((f) => f.startsWith("thumbnail.")) || "";
+  const record = {
+    platform: String(itemMetadata.platform || metadata?.platform || ""),
+    clipType: String(itemMetadata.clipType || metadata?.clipType || ""),
+    status: metadata?.status || "pending_review",
+    blobBasePath,
+    mediaType: String(itemMetadata.mediaType || metadata?.mediaType || "video"),
+    mediaFilename,
+    postContent,
+    hashtags: Array.isArray(itemMetadata.hashtags) ? itemMetadata.hashtags.join(",") : metadata?.hashtags || "",
+    characterCount: Number(itemMetadata.characterCount || metadata?.characterCount || postContent.length),
+    scheduledFor: String(itemMetadata.scheduledFor || metadata?.scheduledFor || ""),
+    latePostId: String(itemMetadata.latePostId || metadata?.latePostId || ""),
+    publishedUrl: String(itemMetadata.publishedUrl || metadata?.publishedUrl || ""),
+    sourceVideoRunId: runId,
+    thumbnailFilename,
+    ideaIds: Array.isArray(itemMetadata.ideaIds) ? itemMetadata.ideaIds.join(",") : metadata?.ideaIds || "",
+    createdAt: String(itemMetadata.createdAt || (/* @__PURE__ */ new Date()).toISOString()),
+    reviewedAt: String(itemMetadata.reviewedAt || metadata?.reviewedAt || ""),
+    publishedAt: String(itemMetadata.publishedAt || metadata?.publishedAt || "")
+  };
+  await upsertEntity(CONTENT_TABLE, videoSlug, itemId, record);
+  logger_default.info(`Uploaded content item: ${itemId} (${record.platform}/${record.clipType}) \u2014 blob + table record created`);
+  return blobBasePath;
+}
+async function uploadPublishQueue(publishQueueDir, videoSlug, runId) {
+  const errors = [];
+  let uploaded = 0;
+  let items;
+  try {
+    items = await readdir(publishQueueDir);
+  } catch {
+    logger_default.warn(`Publish queue directory not found: ${publishQueueDir}`);
+    return { uploaded: 0, errors: ["Publish queue directory not found"] };
+  }
+  for (const itemId of items) {
+    const itemDir = join8(publishQueueDir, itemId);
+    try {
+      const metaPath = join8(itemDir, "metadata.json");
+      const metaContent = await readFile(metaPath, "utf8");
+      const meta = JSON.parse(metaContent);
+      const sourceVideo = String(meta.sourceVideo || "");
+      if (sourceVideo && !sourceVideo.endsWith(videoSlug)) {
+        continue;
+      }
+    } catch {
+      continue;
+    }
+    try {
+      await uploadContentItem(itemDir, itemId, videoSlug, runId);
+      uploaded++;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      errors.push(`${itemId}: ${msg}`);
+      logger_default.error(`Failed to upload content item ${itemId}: ${msg}`);
+    }
+  }
+  await updateEntity(VIDEOS_TABLE, "video", runId, {
+    contentCount: uploaded
+  });
+  logger_default.info(`Uploaded ${uploaded} content items to Azure (${errors.length} errors)`);
+  return { uploaded, errors };
+}
+async function migrateLocalContent(outputDir) {
+  const errors = [];
+  let uploaded = 0;
+  const runId = `migration-${Date.now()}`;
+  const publishQueueDir = join8(outputDir, "publish-queue");
+  try {
+    const items = await readdir(publishQueueDir);
+    for (const itemId of items) {
+      try {
+        const videoSlug = extractVideoSlug(itemId);
+        await uploadContentItem(
+          join8(publishQueueDir, itemId),
+          itemId,
+          videoSlug,
+          runId,
+          { status: "pending_review" }
+        );
+        uploaded++;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        errors.push(`publish-queue/${itemId}: ${msg}`);
+      }
+    }
+  } catch {
+    logger_default.info("No publish-queue directory found for migration");
+  }
+  const publishedDir = join8(outputDir, "published");
+  try {
+    const items = await readdir(publishedDir);
+    for (const itemId of items) {
+      try {
+        const videoSlug = extractVideoSlug(itemId);
+        await uploadContentItem(
+          join8(publishedDir, itemId),
+          itemId,
+          videoSlug,
+          runId,
+          { status: "published" }
+        );
+        uploaded++;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        errors.push(`published/${itemId}: ${msg}`);
+      }
+    }
+  } catch {
+    logger_default.info("No published directory found for migration");
+  }
+  logger_default.info(`Migration complete: ${uploaded} items uploaded, ${errors.length} errors`);
+  return { uploaded, errors };
+}
+async function getContentItems(filters) {
+  const parts = [];
+  if (filters?.videoSlug) {
+    parts.push(`PartitionKey eq '${filters.videoSlug}'`);
+  }
+  if (filters?.status) {
+    parts.push(`status eq '${filters.status}'`);
+  }
+  const filter = parts.length > 0 ? parts.join(" and ") : "";
+  const entities = await queryEntities(
+    CONTENT_TABLE,
+    filter
+  );
+  return entities;
+}
+async function getContentItem(videoSlug, itemId) {
+  const entity = await getEntity(
+    CONTENT_TABLE,
+    videoSlug,
+    itemId
+  );
+  return entity;
+}
+async function findContentItemByRowKey(itemId) {
+  const results = await queryEntities(
+    CONTENT_TABLE,
+    `RowKey eq '${itemId}'`
+  );
+  return results[0] ?? null;
+}
+async function updateContentStatus(videoSlug, itemId, status, extraFields) {
+  await updateEntity(CONTENT_TABLE, videoSlug, itemId, {
+    status,
+    ...extraFields
+  });
+  logger_default.info(`Updated content status: ${itemId} \u2192 ${status}`);
+}
+async function getVideoRecord(runId) {
+  return getEntity(
+    VIDEOS_TABLE,
+    "video",
+    runId
+  );
+}
+async function listVideos(status) {
+  const filter = status ? `PartitionKey eq 'video' and status eq '${status}'` : "PartitionKey eq 'video'";
+  return queryEntities(
+    VIDEOS_TABLE,
+    filter
+  );
+}
+async function downloadContentMedia(blobPath) {
+  return downloadStream(blobPath);
+}
+function getContentType(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "mp4":
+      return "video/mp4";
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "json":
+      return "application/json";
+    case "md":
+      return "text/markdown";
+    case "srt":
+    case "vtt":
+    case "ass":
+      return "text/plain";
+    default:
+      return "application/octet-stream";
+  }
+}
+function extractVideoSlug(itemId) {
+  const platforms = ["youtube-shorts", "instagram-reels", "instagram-feed", "twitter", "youtube", "tiktok", "instagram", "linkedin", "x"];
+  for (const platform of platforms) {
+    if (itemId.endsWith(`-${platform}`)) {
+      return itemId.slice(0, -(platform.length + 1));
+    }
+  }
+  return itemId;
+}
+var VIDEOS_TABLE, CONTENT_TABLE;
+var init_azureStorageService = __esm({
+  "src/L3-services/azureStorage/azureStorageService.ts"() {
+    "use strict";
+    init_configLogger();
+    init_blobClient();
+    init_tableClient();
+    VIDEOS_TABLE = "Videos";
+    CONTENT_TABLE = "Content";
+  }
+});
+
+// src/L3-services/azureStorage/azureConfigService.ts
+var azureConfigService_exports = {};
+__export(azureConfigService_exports, {
+  listConfigFiles: () => listConfigFiles,
+  pullConfig: () => pullConfig,
+  pushConfig: () => pushConfig
+});
+import { readdir as readdir2, stat as stat2, mkdir } from "fs/promises";
+import { join as join9 } from "path";
+async function pushConfig(vidpipeDir) {
+  let uploaded = 0;
+  for (const file of CONFIG_FILES) {
+    const fullPath = join9(vidpipeDir, file);
+    try {
+      await stat2(fullPath);
+      const blobPath = `${CONFIG_PREFIX}${file}`;
+      logger_default.info(`Uploading ${file}...`);
+      await uploadFile(blobPath, fullPath);
+      uploaded++;
+      logger_default.info(`  \u2705 ${blobPath}`);
+    } catch {
+      logger_default.debug(`Config file not found, skipping: ${file}`);
+    }
+  }
+  for (const dir of CONFIG_DIRS) {
+    const fullPath = join9(vidpipeDir, dir);
+    try {
+      await stat2(fullPath);
+      logger_default.info(`Uploading ${dir}/...`);
+      const count = await uploadDirectory(fullPath, `${CONFIG_PREFIX}${dir}`);
+      uploaded += count;
+      logger_default.info(`  \u2705 ${dir}/ (${count} files)`);
+    } catch {
+      logger_default.debug(`Config directory not found, skipping: ${dir}/`);
+    }
+  }
+  logger_default.info(`Pushed ${uploaded} config files to Azure`);
+  return { uploaded };
+}
+async function uploadDirectory(localDir, blobPrefix) {
+  let count = 0;
+  const entries = await readdir2(localDir);
+  for (const entry of entries) {
+    const fullPath = join9(localDir, entry);
+    const entryStat = await stat2(fullPath);
+    if (entryStat.isDirectory()) {
+      count += await uploadDirectory(fullPath, `${blobPrefix}/${entry}`);
+    } else if (entryStat.isFile()) {
+      const blobPath = `${blobPrefix}/${entry}`;
+      await uploadFile(blobPath, fullPath);
+      count++;
+    }
+  }
+  return count;
+}
+async function pullConfig(targetDir) {
+  let downloaded = 0;
+  const blobs = await listBlobs(CONFIG_PREFIX);
+  for (const blobPath of blobs) {
+    const relativePath = blobPath.slice(CONFIG_PREFIX.length);
+    const localPath = join9(targetDir, relativePath);
+    const parentDir = join9(localPath, "..");
+    await mkdir(parentDir, { recursive: true });
+    await downloadToFile(blobPath, localPath);
+    downloaded++;
+    logger_default.debug(`Downloaded config: ${blobPath} \u2192 ${localPath}`);
+  }
+  logger_default.info(`Pulled ${downloaded} config files from Azure`);
+  return { downloaded };
+}
+async function listConfigFiles() {
+  const blobs = await listBlobs(CONFIG_PREFIX);
+  return blobs.map((b) => b.slice(CONFIG_PREFIX.length));
+}
+var CONFIG_PREFIX, CONFIG_FILES, CONFIG_DIRS;
+var init_azureConfigService = __esm({
+  "src/L3-services/azureStorage/azureConfigService.ts"() {
+    "use strict";
+    init_configLogger();
+    init_blobClient();
+    CONFIG_PREFIX = "config/";
+    CONFIG_FILES = ["schedule.json", "brand.json"];
+    CONFIG_DIRS = ["assets"];
+  }
+});
+
+// src/L4-agents/cloudStorage/cloudStorageOperations.ts
+var cloudStorageOperations_exports = {};
+__export(cloudStorageOperations_exports, {
+  isCloudEnabled: () => isCloudEnabled,
+  migrateLocalContent: () => migrateLocalContent2,
+  pullConfig: () => pullConfig2,
+  pushConfig: () => pushConfig2,
+  uploadPipelineResults: () => uploadPipelineResults
+});
+function isCloudEnabled() {
+  return isAzureConfigured2();
+}
+async function uploadPipelineResults(inputVideoPath, publishQueueDir, videoSlug, metadata) {
+  const runId = getRunId();
+  logger_default.info(`Cloud upload starting (runId: ${runId})`);
+  let videoUploaded = false;
+  try {
+    await uploadRawVideo(inputVideoPath, runId, {
+      ...metadata,
+      slug: videoSlug
+    });
+    videoUploaded = true;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    logger_default.error(`Failed to upload raw video: ${msg}`);
+  }
+  const result = await uploadPublishQueue(publishQueueDir, videoSlug, runId);
+  logger_default.info(`Cloud upload complete: video=${videoUploaded}, content=${result.uploaded}, errors=${result.errors.length}`);
+  return {
+    runId,
+    videoUploaded,
+    contentUploaded: result.uploaded,
+    errors: result.errors
+  };
+}
+async function pullConfig2(targetDir) {
+  return pullConfig(targetDir);
+}
+async function pushConfig2(sourceDir) {
+  return pushConfig(sourceDir);
+}
+async function migrateLocalContent2(outputDir) {
+  return migrateLocalContent(outputDir);
+}
+var init_cloudStorageOperations = __esm({
+  "src/L4-agents/cloudStorage/cloudStorageOperations.ts"() {
+    "use strict";
+    init_configLogger();
+    init_azureStorageService();
+    init_azureConfigService();
   }
 });
 
@@ -10280,324 +11368,19 @@ async function loadAndValidateIdea(issueNumber) {
   return idea;
 }
 
-// src/L2-clients/late/lateApi.ts
-init_environment();
-init_configLogger();
-init_fileSystem();
-
-// src/L1-infra/http/network.ts
-import { Readable } from "stream";
-
-// src/L2-clients/late/lateApi.ts
-init_paths();
-init_httpClient();
-var LateApiClient = class {
-  baseUrl = "https://getlate.dev/api/v1";
-  apiKey;
-  constructor(apiKey) {
-    this.apiKey = apiKey ?? getConfig().LATE_API_KEY;
-    if (!this.apiKey) {
-      throw new Error("LATE_API_KEY is required \u2014 set it in environment or pass to constructor");
-    }
-  }
-  // ── Private request helper ───────────────────────────────────────────
-  async request(endpoint, options = {}, retries = 3) {
-    const url = `${this.baseUrl}${endpoint}`;
-    const headers = {
-      Authorization: `Bearer ${this.apiKey}`,
-      ...options.headers
-    };
-    if (!(options.body instanceof FormData)) {
-      headers["Content-Type"] = "application/json";
-    }
-    logger_default.debug(`Late API ${options.method ?? "GET"} ${endpoint}`);
-    for (let attempt = 1; attempt <= retries; attempt++) {
-      const response = await fetchRaw(url, { ...options, headers });
-      if (response.ok) {
-        if (response.status === 204) return void 0;
-        return await response.json();
-      }
-      if (response.status === 429 && attempt < retries) {
-        const retryAfter = Number(response.headers.get("Retry-After")) || 2;
-        logger_default.warn(`Late API rate limited, retrying in ${retryAfter}s (attempt ${attempt}/${retries})`);
-        await new Promise((r) => setTimeout(r, retryAfter * 1e3));
-        continue;
-      }
-      if (response.status === 401) {
-        throw new Error(
-          "Late API authentication failed (401). Check that LATE_API_KEY is valid."
-        );
-      }
-      const body = await response.text().catch(() => "<no body>");
-      throw new Error(
-        `Late API error ${response.status} ${options.method ?? "GET"} ${endpoint}: ${body}`
-      );
-    }
-    throw new Error(`Late API request failed after ${retries} retries`);
-  }
-  // ── Core methods ─────────────────────────────────────────────────────
-  async listProfiles() {
-    const data = await this.request("/profiles");
-    return data.profiles ?? [];
-  }
-  async listAccounts() {
-    const data = await this.request("/accounts");
-    return data.accounts ?? [];
-  }
-  async getScheduledPosts(platform) {
-    return this.listPosts({ status: "scheduled", platform });
-  }
-  async getDraftPosts(platform) {
-    return this.listPosts({ status: "draft", platform });
-  }
-  async createPost(params) {
-    const data = await this.request("/posts", {
-      method: "POST",
-      body: JSON.stringify(params)
-    });
-    return data.post;
-  }
-  async deletePost(postId) {
-    await this.request(`/posts/${encodeURIComponent(postId)}`, {
-      method: "DELETE"
-    });
-  }
-  async updatePost(postId, updates) {
-    const data = await this.request(`/posts/${encodeURIComponent(postId)}`, {
-      method: "PUT",
-      body: JSON.stringify(updates)
-    });
-    return data.post;
-  }
-  /** Reschedule a post and ensure it transitions out of draft status. */
-  async schedulePost(postId, scheduledFor) {
-    return this.updatePost(postId, { scheduledFor, isDraft: false });
-  }
-  async uploadMedia(filePath) {
-    const fileStats = await getFileStats(filePath);
-    const fileName = basename(filePath);
-    const ext = extname(fileName).toLowerCase();
-    const contentType = ext === ".mp4" ? "video/mp4" : ext === ".webm" ? "video/webm" : ext === ".mov" ? "video/quicktime" : "video/mp4";
-    logger_default.info(`Late API uploading ${String(fileName).replace(/[\r\n]/g, "")} (${(fileStats.size / 1024 / 1024).toFixed(1)} MB)`);
-    const presign = await this.request("/media/presign", {
-      method: "POST",
-      body: JSON.stringify({ filename: fileName, contentType })
-    });
-    logger_default.debug(`Late API presigned URL obtained for ${String(fileName).replace(/[\r\n]/g, "")} (expires in ${presign.expiresIn}s)`);
-    const nodeStream = openReadStream(filePath);
-    try {
-      const webStream = Readable.toWeb(nodeStream);
-      const uploadResp = await fetchRaw(presign.uploadUrl, {
-        method: "PUT",
-        headers: {
-          "Content-Type": contentType,
-          "Content-Length": String(fileStats.size)
-        },
-        body: webStream,
-        // Node.js-specific property for streaming request bodies (not in standard RequestInit type)
-        duplex: "half"
-      });
-      if (!uploadResp.ok) {
-        throw new Error(`Late media upload failed: ${uploadResp.status} ${uploadResp.statusText}`);
-      }
-    } finally {
-      nodeStream.destroy();
-    }
-    logger_default.debug(`Late API media uploaded \u2192 ${presign.publicUrl}`);
-    const type = contentType.startsWith("image/") ? "image" : "video";
-    return { url: presign.publicUrl, type };
-  }
-  /**
-   * Fetch posts with pagination, iterating pages until all results are collected.
-   * Supports filtering by status and platform.
-   */
-  async listPosts(options = {}) {
-    const limit = options.limit ?? 100;
-    const allPosts = [];
-    let page = 1;
-    while (true) {
-      const params = new URLSearchParams();
-      if (options.status) params.set("status", options.status);
-      if (options.platform) params.set("platform", options.platform);
-      params.set("limit", String(limit));
-      params.set("page", String(page));
-      const data = await this.request(
-        `/posts?${params}`
-      );
-      const posts = data.posts ?? data.data ?? [];
-      allPosts.push(...posts);
-      if (posts.length < limit) break;
-      page++;
-    }
-    return allPosts;
-  }
-  // ── Queue management ─────────────────────────────────────────────────
-  async listQueues(profileId, all = false) {
-    const params = new URLSearchParams({ profileId });
-    if (all) params.set("all", "true");
-    return this.request(`/queue/slots?${params}`);
-  }
-  async createQueue(params) {
-    return this.request("/queue/slots", { method: "POST", body: JSON.stringify(params) });
-  }
-  async updateQueue(params) {
-    return this.request("/queue/slots", { method: "PUT", body: JSON.stringify(params) });
-  }
-  async deleteQueue(profileId, queueId) {
-    return this.request(`/queue/slots?profileId=${profileId}&queueId=${queueId}`, { method: "DELETE" });
-  }
-  async previewQueue(profileId, queueId, count = 20) {
-    const params = new URLSearchParams({ profileId, count: String(count) });
-    if (queueId) params.set("queueId", queueId);
-    return this.request(`/queue/preview?${params}`);
-  }
-  async getNextQueueSlot(profileId, queueId) {
-    const params = new URLSearchParams({ profileId });
-    if (queueId) params.set("queueId", queueId);
-    return this.request(`/queue/next-slot?${params}`);
-  }
-  // ── Helper ───────────────────────────────────────────────────────────
-  async validateConnection() {
-    try {
-      const profiles = await this.listProfiles();
-      const name = profiles[0]?.name;
-      logger_default.info(`Late API connection valid \u2014 profile: ${name ?? "unknown"}`);
-      return { valid: true, profileName: name };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      logger_default.error(`Late API connection failed: ${message}`);
-      return { valid: false, error: message };
-    }
-  }
-};
-
 // src/L3-services/lateApi/lateApiService.ts
+init_lateApi();
+init_configLogger();
+init_queueMapping();
 function createLateApiClient(...args) {
   return new LateApiClient(...args);
 }
 
-// src/L3-services/queueMapping/queueMapping.ts
-init_configLogger();
-init_fileSystem();
-init_paths();
-var CACHE_FILE = ".vidpipe-queue-cache.json";
-var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-var memoryCache = null;
-function cachePath() {
-  return join(process.cwd(), CACHE_FILE);
-}
-function isCacheValid(cache) {
-  const fetchedAtTime = new Date(cache.fetchedAt).getTime();
-  if (Number.isNaN(fetchedAtTime)) {
-    logger_default.warn("Invalid fetchedAt in queue cache; treating as stale", {
-      fetchedAt: cache.fetchedAt
-    });
-    return false;
-  }
-  const age = Date.now() - fetchedAtTime;
-  return age < CACHE_TTL_MS;
-}
-async function readFileCache() {
-  try {
-    const raw = await readTextFile(cachePath());
-    const cache = JSON.parse(raw);
-    if (cache.mappings && cache.profileId && cache.fetchedAt && isCacheValid(cache)) {
-      return cache;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function writeFileCache(cache) {
-  try {
-    if (!cache || typeof cache !== "object" || !cache.mappings || !cache.profileId || !cache.fetchedAt) {
-      logger_default.warn("Invalid queue cache structure, skipping write");
-      return;
-    }
-    const sanitized = {
-      mappings: typeof cache.mappings === "object" ? { ...cache.mappings } : {},
-      profileId: String(cache.profileId),
-      fetchedAt: String(cache.fetchedAt)
-    };
-    for (const [name, id] of Object.entries(sanitized.mappings)) {
-      if (typeof name !== "string" || typeof id !== "string" || /[\x00-\x1f]/.test(name) || /[\x00-\x1f]/.test(id)) {
-        logger_default.warn("Invalid queue mapping data from API, skipping cache write");
-        return;
-      }
-    }
-    const resolvedCachePath = resolve(cachePath());
-    if (!resolvedCachePath.startsWith(resolve(process.cwd()) + sep)) {
-      throw new Error("Cache path outside working directory");
-    }
-    await writeTextFile(resolvedCachePath, JSON.stringify(sanitized, null, 2));
-  } catch (err) {
-    logger_default.warn("Failed to write queue cache file", { error: err });
-  }
-}
-async function fetchAndCache() {
-  const client = new LateApiClient();
-  const profiles = await client.listProfiles();
-  if (profiles.length === 0) {
-    logger_default.warn("No Late API profiles found \u2014 queue mappings will be empty");
-    const emptyCache = {
-      mappings: {},
-      profileId: "",
-      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    memoryCache = emptyCache;
-    return emptyCache;
-  }
-  const profileId = profiles[0]._id;
-  const { queues } = await client.listQueues(profileId, true);
-  if (queues.length === 0) {
-    logger_default.warn(
-      "No queues found in Late API \u2014 run `vidpipe sync-queues` to create platform queues"
-    );
-  }
-  const mappings = {};
-  for (const queue of queues) {
-    mappings[queue.name] = queue._id;
-  }
-  const cache = {
-    mappings,
-    profileId,
-    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  memoryCache = cache;
-  await writeFileCache(cache);
-  logger_default.info("Refreshed Late queue mappings", {
-    queueCount: queues.length,
-    queues: Object.keys(mappings)
-  });
-  return cache;
-}
-async function ensureMappings() {
-  if (memoryCache && isCacheValid(memoryCache)) {
-    return memoryCache;
-  }
-  const fileCache = await readFileCache();
-  if (fileCache) {
-    memoryCache = fileCache;
-    return fileCache;
-  }
-  try {
-    return await fetchAndCache();
-  } catch (err) {
-    logger_default.error("Failed to fetch Late queue mappings", { error: err });
-    return { mappings: {}, profileId: "", fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  }
-}
-async function getQueueId(platform, clipType) {
-  const cache = await ensureMappings();
-  const normalizedPlatform = platform === "twitter" ? "x" : platform;
-  const queueName = `${normalizedPlatform}-${clipType}`;
-  return cache.mappings[queueName] ?? null;
-}
-async function getProfileId() {
-  const cache = await ensureMappings();
-  return cache.profileId;
-}
+// src/L7-app/sdk/VidPipeSDK.ts
+init_queueMapping();
+
+// src/L3-services/scheduler/realign.ts
+init_lateApi();
 
 // src/L2-clients/scheduleStore/scheduleStore.ts
 init_fileSystem();
@@ -11053,6 +11836,7 @@ async function itemExists(id) {
 init_configLogger();
 
 // src/L3-services/scheduler/scheduler.ts
+init_lateApi();
 init_configLogger();
 var MAX_LOOKAHEAD_DAYS = 730;
 var DAY_MS = 24 * 60 * 60 * 1e3;
@@ -12023,6 +12807,7 @@ function buildPublishQueue2(...args) {
 
 // src/L4-agents/ScheduleAgent.ts
 init_BaseAgent();
+init_queueMapping();
 init_configLogger();
 
 // src/L4-agents/IdeationAgent.ts
@@ -14311,6 +15096,21 @@ Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour,
 Style: Default,Montserrat,120,&H00FFFFFF,&H0000FFFF,&H00000000,&H80000000,1,0,0,0,100,100,0,0,1,3,1,2,30,30,770,1
 Style: Hook,Montserrat,56,&H00333333,&H00333333,&H60D0D0D0,&H60E0E0E0,1,0,0,0,100,100,2,0,3,18,2,8,80,80,250,1
 
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+`;
+var ASS_HEADER_PORTRAIT_LOWER = `[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,120,&H00FFFFFF,&H0000FFFF,&H00000000,&H80000000,1,0,0,0,100,100,0,0,1,3,1,2,30,30,280,1
+Style: Hook,Montserrat,56,&H00333333,&H00333333,&H60D0D0D0,&H60E0E0E0,1,0,0,0,100,100,2,0,3,18,2,8,80,80,250,1
+
 [Events]
 Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
 `;
@@ -14387,14 +15187,26 @@ function buildPremiumDialogueLines(words, style = "shorts") {
   }
   return dialogues;
 }
+function getASSHeader(style) {
+  switch (style) {
+    case "portrait":
+      return ASS_HEADER_PORTRAIT;
+    case "portrait-lower":
+      return ASS_HEADER_PORTRAIT_LOWER;
+    case "medium":
+      return ASS_HEADER_MEDIUM;
+    default:
+      return ASS_HEADER;
+  }
+}
 function generateStyledASS(transcript, style = "shorts") {
-  const header = style === "portrait" ? ASS_HEADER_PORTRAIT : style === "medium" ? ASS_HEADER_MEDIUM : ASS_HEADER;
+  const header = getASSHeader(style);
   const allWords = transcript.words;
   if (allWords.length === 0) return header;
   return header + buildPremiumDialogueLines(allWords, style).join("\n") + "\n";
 }
 function generateStyledASSForSegment(transcript, startTime, endTime, buffer = 1, style = "shorts") {
-  const header = style === "portrait" ? ASS_HEADER_PORTRAIT : style === "medium" ? ASS_HEADER_MEDIUM : ASS_HEADER;
+  const header = getASSHeader(style);
   const bufferedStart = Math.max(0, startTime - buffer);
   const bufferedEnd = endTime + buffer;
   const words = transcript.words.filter(
@@ -14409,7 +15221,7 @@ function generateStyledASSForSegment(transcript, startTime, endTime, buffer = 1,
   return header + buildPremiumDialogueLines(adjusted, style).join("\n") + "\n";
 }
 function generateStyledASSForComposite(transcript, segments, buffer = 1, style = "shorts") {
-  const header = style === "portrait" ? ASS_HEADER_PORTRAIT : style === "medium" ? ASS_HEADER_MEDIUM : ASS_HEADER;
+  const header = getASSHeader(style);
   const allAdjusted = [];
   let runningOffset = 0;
   for (const seg of segments) {
@@ -14436,14 +15248,16 @@ function generateHookOverlay(hookText, displayDuration = 4, _style = "portrait")
   const text = hookText.length > HOOK_TEXT_MAX_LENGTH ? hookText.slice(0, HOOK_TEXT_MAX_LENGTH - 3) + "..." : hookText;
   return `Dialogue: 1,${toASS(0)},${toASS(displayDuration)},Hook,,0,0,0,,{\\fad(300,500)}${text}`;
 }
-function generatePortraitASSWithHook(transcript, hookText, startTime, endTime, buffer) {
-  const baseASS = generateStyledASSForSegment(transcript, startTime, endTime, buffer, "portrait");
-  const hookLine = generateHookOverlay(hookText, 4, "portrait");
+function generatePortraitASSWithHook(transcript, hookText, startTime, endTime, buffer, isSplitScreen = true) {
+  const style = isSplitScreen ? "portrait" : "portrait-lower";
+  const baseASS = generateStyledASSForSegment(transcript, startTime, endTime, buffer, style);
+  const hookLine = generateHookOverlay(hookText, 4, style);
   return baseASS + hookLine + "\n";
 }
-function generatePortraitASSWithHookComposite(transcript, segments, hookText, buffer) {
-  const baseASS = generateStyledASSForComposite(transcript, segments, buffer, "portrait");
-  const hookLine = generateHookOverlay(hookText, 4, "portrait");
+function generatePortraitASSWithHookComposite(transcript, segments, hookText, buffer, isSplitScreen = true) {
+  const style = isSplitScreen ? "portrait" : "portrait-lower";
+  const baseASS = generateStyledASSForComposite(transcript, segments, buffer, style);
+  const hookLine = generateHookOverlay(hookText, 4, style);
   return baseASS + hookLine + "\n";
 }
 
@@ -14736,7 +15550,7 @@ init_configLogger();
 init_brand();
 var MAX_FILE_SIZE_MB = 25;
 var WARN_FILE_SIZE_MB = 20;
-var MAX_RETRIES = 3;
+var MAX_RETRIES2 = 3;
 var RETRY_DELAY_MS = 5e3;
 async function transcribeAudio(audioPath) {
   logger_default.info(`Starting Whisper transcription: ${audioPath}`);
@@ -14758,7 +15572,7 @@ async function transcribeAudio(audioPath) {
   try {
     const prompt = getWhisperPrompt();
     let response;
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    for (let attempt = 1; attempt <= MAX_RETRIES2; attempt++) {
       try {
         response = await openai.audio.transcriptions.create({
           model: "whisper-1",
@@ -14771,9 +15585,9 @@ async function transcribeAudio(audioPath) {
       } catch (retryError) {
         const status = typeof retryError === "object" && retryError !== null && "status" in retryError ? retryError.status : void 0;
         if (status === 401 || status === 400 || status === 429) throw retryError;
-        if (attempt === MAX_RETRIES) throw retryError;
+        if (attempt === MAX_RETRIES2) throw retryError;
         const msg = retryError instanceof Error ? retryError.message : String(retryError);
-        logger_default.warn(`Whisper attempt ${attempt}/${MAX_RETRIES} failed: ${msg} \u2014 retrying in ${RETRY_DELAY_MS / 1e3}s`);
+        logger_default.warn(`Whisper attempt ${attempt}/${MAX_RETRIES2} failed: ${msg} \u2014 retrying in ${RETRY_DELAY_MS / 1e3}s`);
         await new Promise((resolve3) => setTimeout(resolve3, RETRY_DELAY_MS));
       }
     }
@@ -16018,6 +16832,19 @@ init_videoOperations();
 init_fileSystem();
 init_paths();
 init_configLogger();
+function mapVariantResults(results) {
+  return results.map((v) => ({
+    path: v.path,
+    aspectRatio: v.aspectRatio,
+    platform: v.platform,
+    width: v.width,
+    height: v.height,
+    isSplitScreen: v.isSplitScreen
+  }));
+}
+function buildPortraitCaptionASS(transcript, segments, hookText, isSplitScreen) {
+  return segments.length === 1 ? generatePortraitASSWithHook(transcript, hookText, segments[0].start, segments[0].end, void 0, isSplitScreen) : generatePortraitASSWithHookComposite(transcript, segments, hookText, void 0, isSplitScreen);
+}
 function buildShortsSystemPrompt(clipConfig) {
   const minDuration = clipConfig?.duration?.min ?? 15;
   const maxDuration = clipConfig?.duration?.max ?? 60;
@@ -16415,13 +17242,7 @@ Words: ${words}`;
           const defaultPlatforms = ["tiktok", "youtube-shorts", "instagram-reels", "instagram-feed", "linkedin"];
           const results = await generatePlatformVariants2(outputPath, shortsDir, shortSlug, defaultPlatforms, { webcamOverride });
           if (results.length > 0) {
-            clipVariants = results.map((v) => ({
-              path: v.path,
-              aspectRatio: v.aspectRatio,
-              platform: v.platform,
-              width: v.width,
-              height: v.height
-            }));
+            clipVariants = mapVariantResults(results);
             logger_default.info(`[ShortsAgent] Generated ${clipVariants.length} platform variants for: ${plan.title}`);
           }
         } catch (err) {
@@ -16449,7 +17270,8 @@ Words: ${words}`;
         if (portraitVariants.length > 0) {
           try {
             const hookText = plan.hook ?? plan.title;
-            const portraitAssContent = segments.length === 1 ? generatePortraitASSWithHook(transcript, hookText, segments[0].start, segments[0].end) : generatePortraitASSWithHookComposite(transcript, segments, hookText);
+            const isSplitScreen = portraitVariants[0].isSplitScreen ?? false;
+            const portraitAssContent = buildPortraitCaptionASS(transcript, segments, hookText, isSplitScreen);
             const portraitAssPath = join(shortsDir, `${shortSlug}-portrait.ass`);
             await writeTextFile(portraitAssPath, portraitAssContent);
             const portraitCaptionedPath = portraitVariants[0].path.replace(".mp4", "-captioned.mp4");
@@ -19455,6 +20277,16 @@ var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
   }
 };
 
+// src/L5-assets/bridges/cloudStorageBridge.ts
+async function uploadToCloud(inputVideoPath, publishQueueDir, videoSlug, metadata) {
+  const { uploadPipelineResults: uploadPipelineResults2 } = await Promise.resolve().then(() => (init_cloudStorageOperations(), cloudStorageOperations_exports));
+  return uploadPipelineResults2(inputVideoPath, publishQueueDir, videoSlug, metadata);
+}
+async function isCloudEnabled2() {
+  const { isCloudEnabled: check } = await Promise.resolve().then(() => (init_cloudStorageOperations(), cloudStorageOperations_exports));
+  return check();
+}
+
 // src/L6-pipeline/pipeline.ts
 init_types2();
 async function runStage(stageName, fn, stageResults) {
@@ -19735,6 +20567,23 @@ async function processVideo(videoPath, ideas, publishBy, spec) {
       skipStage("queue-build" /* QueueBuild */, "NO_SOCIAL_POSTS");
     }
     const blogPost = await trackStage("blog" /* Blog */, () => asset.getBlog());
+    await trackStage("cloud-upload" /* CloudUpload */, async () => {
+      const cloudEnabled = await isCloudEnabled2();
+      if (!cloudEnabled) {
+        logger_default.info("Cloud upload skipped \u2014 Azure storage not configured");
+        return;
+      }
+      const publishQueueDir = join(cfg.OUTPUT_DIR, "publish-queue");
+      const result = await uploadToCloud(videoPath, publishQueueDir, video.slug, {
+        originalFilename: video.filename,
+        duration: video.duration,
+        size: video.size
+      });
+      logger_default.info(`Cloud upload complete \u2014 runId: ${result.runId}, items uploaded: ${result.contentUploaded}, video: ${result.videoUploaded}`);
+      if (result.errors.length > 0) {
+        logger_default.warn(`Cloud upload had ${result.errors.length} error(s): ${result.errors.join("; ")}`);
+      }
+    });
     const totalDuration = Date.now() - pipelineStart;
     const report = costTracker3.getReport();
     if (report.records.length > 0) {
@@ -19848,7 +20697,9 @@ var credentialKeys = [
   "perplexityApiKey",
   "lateApiKey",
   "githubToken",
-  "geminiApiKey"
+  "geminiApiKey",
+  "azureStorageAccountName",
+  "azureStorageAccountKey"
 ];
 var defaultKeys = [
   "llmProvider",
@@ -20179,8 +21030,8 @@ function mapVariantPlatforms(platforms) {
   });
 }
 function getVariantSlug(videoPath) {
-  const basename2 = videoPath.split(/[\\/]/).pop() ?? videoPath;
-  return basename2.replace(/\.[^.]+$/, "");
+  const basename3 = videoPath.split(/[\\/]/).pop() ?? videoPath;
+  return basename3.replace(/\.[^.]+$/, "");
 }
 function buildDiagnosticStatus(required, passed) {
   if (passed) {
@@ -20548,6 +21399,88 @@ function createVidPipe(sdkConfig) {
       path() {
         return getConfigPath();
       }
+    },
+    cloud: {
+      async process(videoPath, options) {
+        const { uploadVideoFile: uploadVideoFile2, isAzureConfigured: isAzureConfigured3, getRunId: getRunId2 } = await Promise.resolve().then(() => (init_azureStorageService(), azureStorageService_exports));
+        if (!isAzureConfigured3()) {
+          throw new Error("Azure Storage not configured");
+        }
+        const { basename: getBasename } = await import("path");
+        const { stat: getFileStat } = await import("fs/promises");
+        const filename = getBasename(videoPath);
+        const runId = getRunId2();
+        const blobPath = `raw/${runId}-${filename}`;
+        await getFileStat(videoPath);
+        await uploadVideoFile2(videoPath, blobPath);
+        let workflowTriggered = false;
+        try {
+          const repo = options?.repo || "htekdev/vidpipe";
+          const args = ["workflow", "run", "process-video.yml", "--repo", repo, "-f", `video_url=blob://${blobPath}`];
+          if (options?.spec) args.push("-f", `spec=${options.spec}`);
+          if (options?.ideas) args.push("-f", `ideas=${options.ideas}`);
+          if (options?.publishBy) args.push("-f", `publish_by=${options.publishBy}`);
+          const triggerResult = await spawnCommand("gh", args);
+          if (triggerResult.error || triggerResult.status !== 0) {
+            throw triggerResult.error ?? new Error(`gh workflow run failed with status ${String(triggerResult.status)}`);
+          }
+          workflowTriggered = true;
+        } catch {
+        }
+        return { runId, blobPath, workflowTriggered };
+      },
+      async pushConfig() {
+        const { dirname: getDirname } = await import("path");
+        const config2 = getConfig();
+        const vidpipeDir = getDirname(config2.OUTPUT_DIR);
+        const { pushConfig: push } = await Promise.resolve().then(() => (init_azureConfigService(), azureConfigService_exports));
+        return push(vidpipeDir);
+      },
+      async pullConfig() {
+        const { dirname: getDirname } = await import("path");
+        const config2 = getConfig();
+        const vidpipeDir = getDirname(config2.OUTPUT_DIR);
+        const { pullConfig: pull } = await Promise.resolve().then(() => (init_azureConfigService(), azureConfigService_exports));
+        return pull(vidpipeDir);
+      },
+      async migrate() {
+        const config2 = getConfig();
+        const { migrateLocalContent: migrateLocalContent3 } = await Promise.resolve().then(() => (init_azureStorageService(), azureStorageService_exports));
+        return migrateLocalContent3(config2.OUTPUT_DIR);
+      },
+      async download(videoUrl, outputPath) {
+        if (videoUrl.startsWith("blob://")) {
+          const blobPath = videoUrl.slice("blob://".length);
+          const { downloadBlobToFile: downloadBlobToFile2 } = await Promise.resolve().then(() => (init_azureStorageService(), azureStorageService_exports));
+          await downloadBlobToFile2(blobPath, outputPath);
+        } else {
+          const result = await spawnCommand("curl", ["-L", "--fail", "-o", outputPath, videoUrl]);
+          if (result.status !== 0) {
+            const stderr = typeof result.stderr === "string" ? result.stderr.trim() : "";
+            throw new Error(
+              stderr.length > 0 ? `curl download failed with exit code ${result.status}: ${stderr}` : `curl download failed with exit code ${result.status}`
+            );
+          }
+        }
+      },
+      async status() {
+        const { isAzureConfigured: isAzureConfigured3, getContentItems: getContentItems2, listVideos: listVideos2 } = await Promise.resolve().then(() => (init_azureStorageService(), azureStorageService_exports));
+        const { listConfigFiles: listConfigFiles2 } = await Promise.resolve().then(() => (init_azureConfigService(), azureConfigService_exports));
+        const configured = isAzureConfigured3();
+        if (!configured) {
+          return { configured, configFiles: 0, contentItems: 0, videos: 0 };
+        }
+        const [configFiles, contentItems, videos] = await Promise.all([
+          listConfigFiles2(),
+          getContentItems2(),
+          listVideos2()
+        ]);
+        return { configured, configFiles: configFiles.length, contentItems: contentItems.length, videos: videos.length };
+      },
+      isConfigured() {
+        const config2 = getConfig();
+        return Boolean(config2.AZURE_STORAGE_ACCOUNT_NAME && config2.AZURE_STORAGE_ACCOUNT_KEY);
+      }
     }
   };
 }