vidpipe 1.3.18 → 1.3.20

package/dist/cli.js

@@ -698,6 +698,387 @@ var init_configLogger = __esm({
   }
 });
 
+// src/L0-pure/pipelineSpec/types.ts
+function isPresetName(value) {
+  return value === "full" || value === "clean" || value === "minimal";
+}
+var init_types = __esm({
+  "src/L0-pure/pipelineSpec/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/L0-pure/pipelineSpec/presets.ts
+function getPreset(name) {
+  return PRESETS[name];
+}
+var PRESET_FULL, PRESET_CLEAN, PRESET_MINIMAL, PRESETS;
+var init_presets = __esm({
+  "src/L0-pure/pipelineSpec/presets.ts"() {
+    "use strict";
+    PRESET_FULL = {
+      name: "full",
+      description: "Full pipeline with hook-first shorts, per-platform optimization",
+      processing: {
+        silenceRemoval: true,
+        visualEnhancement: true,
+        captions: true,
+        introOutro: true
+      },
+      clips: {
+        shorts: {
+          enabled: true,
+          strategy: "hook-first",
+          duration: { min: 15, max: 60 },
+          minViralScore: 8,
+          maxClips: 5
+        },
+        medium: {
+          enabled: true,
+          strategy: "chronological",
+          duration: { min: 60, max: 180 },
+          minViralScore: 10,
+          maxClips: 5
+        }
+      },
+      content: {
+        chapters: true,
+        summary: true,
+        blog: true
+      },
+      distribution: {
+        enabled: true,
+        publish: true,
+        platforms: {
+          targets: ["youtube", "linkedin", "instagram", "x", "tiktok"],
+          toneStrategy: "per-platform",
+          variants: true
+        }
+      }
+    };
+    PRESET_CLEAN = {
+      name: "clean",
+      description: "Simple cleanup with longer clips and unified platform handling",
+      processing: {
+        silenceRemoval: true,
+        visualEnhancement: false,
+        captions: true,
+        introOutro: true
+      },
+      clips: {
+        shorts: {
+          enabled: false
+        },
+        medium: {
+          enabled: true,
+          strategy: "chronological",
+          duration: { min: 60, max: 600 },
+          minViralScore: 6,
+          maxClips: 5
+        }
+      },
+      content: {
+        chapters: true,
+        summary: true,
+        blog: true
+      },
+      distribution: {
+        enabled: true,
+        publish: true,
+        platforms: {
+          targets: ["youtube", "linkedin", "instagram", "x", "tiktok"],
+          toneStrategy: "unified",
+          variants: false
+        }
+      }
+    };
+    PRESET_MINIMAL = {
+      name: "minimal",
+      description: "Cleanup only \u2014 no clips, no social, no blog",
+      processing: {
+        silenceRemoval: true,
+        visualEnhancement: false,
+        captions: true,
+        introOutro: false
+      },
+      clips: {
+        shorts: {
+          enabled: false
+        },
+        medium: {
+          enabled: false
+        }
+      },
+      content: {
+        chapters: true,
+        summary: true,
+        blog: false
+      },
+      distribution: {
+        enabled: false,
+        publish: false,
+        platforms: {
+          targets: [],
+          toneStrategy: "unified",
+          variants: false
+        }
+      }
+    };
+    PRESETS = {
+      full: PRESET_FULL,
+      clean: PRESET_CLEAN,
+      minimal: PRESET_MINIMAL
+    };
+  }
+});
+
+// src/L0-pure/pipelineSpec/validation.ts
+function isObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function validateClipConfig(clip, path, errors) {
+  if (!isObject(clip)) return;
+  if ("enabled" in clip && typeof clip.enabled !== "boolean") {
+    errors.push({ path: `${path}.enabled`, message: "must be a boolean" });
+  }
+  if ("strategy" in clip && clip.strategy !== void 0) {
+    if (!VALID_STRATEGIES.includes(clip.strategy)) {
+      errors.push({ path: `${path}.strategy`, message: `must be one of: ${VALID_STRATEGIES.join(", ")}` });
+    }
+  }
+  if ("duration" in clip && clip.duration !== void 0) {
+    const dur = clip.duration;
+    if (!isObject(dur)) {
+      errors.push({ path: `${path}.duration`, message: "must be an object with min and max" });
+    } else {
+      if ("min" in dur && (typeof dur.min !== "number" || dur.min < 0)) {
+        errors.push({ path: `${path}.duration.min`, message: "must be a non-negative number" });
+      }
+      if ("max" in dur && (typeof dur.max !== "number" || dur.max < 0)) {
+        errors.push({ path: `${path}.duration.max`, message: "must be a non-negative number" });
+      }
+      if (typeof dur.min === "number" && typeof dur.max === "number" && dur.min > dur.max) {
+        errors.push({ path: `${path}.duration`, message: "min must be less than or equal to max" });
+      }
+    }
+  }
+  if ("minViralScore" in clip && clip.minViralScore !== void 0) {
+    const score = clip.minViralScore;
+    if (typeof score !== "number" || score < 1 || score > 20) {
+      errors.push({ path: `${path}.minViralScore`, message: "must be a number between 1 and 20" });
+    }
+  }
+  if ("maxClips" in clip && clip.maxClips !== void 0) {
+    const max = clip.maxClips;
+    if (typeof max !== "number" || max < 1 || !Number.isInteger(max)) {
+      errors.push({ path: `${path}.maxClips`, message: "must be a positive integer" });
+    }
+  }
+}
+function validateProcessing(proc, errors) {
+  if (!isObject(proc)) return;
+  const boolFields = ["silenceRemoval", "visualEnhancement", "captions", "introOutro"];
+  for (const field of boolFields) {
+    if (field in proc && typeof proc[field] !== "boolean") {
+      errors.push({ path: `processing.${field}`, message: "must be a boolean" });
+    }
+  }
+}
+function validateContent(content, errors) {
+  if (!isObject(content)) return;
+  const boolFields = ["chapters", "summary", "blog"];
+  for (const field of boolFields) {
+    if (field in content && typeof content[field] !== "boolean") {
+      errors.push({ path: `content.${field}`, message: "must be a boolean" });
+    }
+  }
+}
+function validateDistribution(dist, errors) {
+  if (!isObject(dist)) return;
+  if ("enabled" in dist && typeof dist.enabled !== "boolean") {
+    errors.push({ path: "distribution.enabled", message: "must be a boolean" });
+  }
+  if ("publish" in dist && typeof dist.publish !== "boolean") {
+    errors.push({ path: "distribution.publish", message: "must be a boolean" });
+  }
+  if ("platforms" in dist && dist.platforms !== void 0) {
+    const plat = dist.platforms;
+    if (!isObject(plat)) {
+      errors.push({ path: "distribution.platforms", message: "must be an object" });
+      return;
+    }
+    if ("targets" in plat) {
+      if (!Array.isArray(plat.targets)) {
+        errors.push({ path: "distribution.platforms.targets", message: "must be an array" });
+      } else {
+        for (const target of plat.targets) {
+          if (!VALID_PLATFORMS.includes(target)) {
+            errors.push({
+              path: "distribution.platforms.targets",
+              message: `unknown platform '${String(target)}' \u2014 valid: ${VALID_PLATFORMS.join(", ")}`
+            });
+          }
+        }
+      }
+    }
+    if ("toneStrategy" in plat && plat.toneStrategy !== void 0) {
+      if (!VALID_TONE_STRATEGIES.includes(plat.toneStrategy)) {
+        errors.push({
+          path: "distribution.platforms.toneStrategy",
+          message: `must be one of: ${VALID_TONE_STRATEGIES.join(", ")}`
+        });
+      }
+    }
+    if ("variants" in plat && typeof plat.variants !== "boolean") {
+      errors.push({ path: "distribution.platforms.variants", message: "must be a boolean" });
+    }
+  }
+}
+function validateSpec(raw) {
+  const errors = [];
+  if (!isObject(raw)) {
+    errors.push({ path: "", message: "spec must be an object" });
+    return errors;
+  }
+  const spec = raw;
+  if ("name" in spec && spec.name !== void 0 && typeof spec.name !== "string") {
+    errors.push({ path: "name", message: "must be a string" });
+  }
+  if ("description" in spec && spec.description !== void 0 && typeof spec.description !== "string") {
+    errors.push({ path: "description", message: "must be a string" });
+  }
+  if ("processing" in spec) validateProcessing(spec.processing, errors);
+  if ("clips" in spec && spec.clips !== void 0) {
+    if (!isObject(spec.clips)) {
+      errors.push({ path: "clips", message: "must be an object" });
+    } else {
+      if ("shorts" in spec.clips) validateClipConfig(spec.clips.shorts, "clips.shorts", errors);
+      if ("medium" in spec.clips) validateClipConfig(spec.clips.medium, "clips.medium", errors);
+    }
+  }
+  if ("content" in spec) validateContent(spec.content, errors);
+  if ("distribution" in spec) validateDistribution(spec.distribution, errors);
+  return errors;
+}
+var VALID_STRATEGIES, VALID_TONE_STRATEGIES, VALID_PLATFORMS;
+var init_validation = __esm({
+  "src/L0-pure/pipelineSpec/validation.ts"() {
+    "use strict";
+    VALID_STRATEGIES = ["hook-first", "chronological"];
+    VALID_TONE_STRATEGIES = ["unified", "per-platform"];
+    VALID_PLATFORMS = ["youtube", "linkedin", "instagram", "x", "tiktok"];
+  }
+});
+
+// src/L0-pure/pipelineSpec/merger.ts
+function mergeDuration(base, override) {
+  if (!override) return base;
+  if (!base) return override;
+  return {
+    min: override.min ?? base.min,
+    max: override.max ?? base.max
+  };
+}
+function mergeClipConfig(base, override) {
+  if (!override) return base;
+  return {
+    enabled: override.enabled ?? base.enabled,
+    strategy: override.strategy ?? base.strategy,
+    duration: mergeDuration(base.duration, override.duration),
+    minViralScore: override.minViralScore ?? base.minViralScore,
+    maxClips: override.maxClips ?? base.maxClips
+  };
+}
+function mergeWithDefaults(partial, base = PRESET_FULL) {
+  return {
+    name: partial.name ?? base.name,
+    description: partial.description ?? base.description,
+    processing: {
+      silenceRemoval: partial.processing?.silenceRemoval ?? base.processing.silenceRemoval,
+      visualEnhancement: partial.processing?.visualEnhancement ?? base.processing.visualEnhancement,
+      captions: partial.processing?.captions ?? base.processing.captions,
+      introOutro: partial.processing?.introOutro ?? base.processing.introOutro
+    },
+    clips: {
+      shorts: mergeClipConfig(base.clips.shorts, partial.clips?.shorts),
+      medium: mergeClipConfig(base.clips.medium, partial.clips?.medium)
+    },
+    content: {
+      chapters: partial.content?.chapters ?? base.content.chapters,
+      summary: partial.content?.summary ?? base.content.summary,
+      blog: partial.content?.blog ?? base.content.blog
+    },
+    distribution: {
+      enabled: partial.distribution?.enabled ?? base.distribution.enabled,
+      publish: partial.distribution?.publish ?? base.distribution.publish,
+      platforms: {
+        targets: partial.distribution?.platforms?.targets ?? base.distribution.platforms.targets,
+        toneStrategy: partial.distribution?.platforms?.toneStrategy ?? base.distribution.platforms.toneStrategy,
+        variants: partial.distribution?.platforms?.variants ?? base.distribution.platforms.variants
+      }
+    }
+  };
+}
+function applySkipFlags(spec, flags) {
+  return {
+    ...spec,
+    processing: {
+      silenceRemoval: spec.processing.silenceRemoval && !flags.SKIP_SILENCE_REMOVAL,
+      visualEnhancement: spec.processing.visualEnhancement && !flags.SKIP_VISUAL_ENHANCEMENT,
+      captions: spec.processing.captions && !flags.SKIP_CAPTIONS,
+      introOutro: spec.processing.introOutro && !flags.SKIP_INTRO_OUTRO
+    },
+    clips: {
+      shorts: {
+        ...spec.clips.shorts,
+        enabled: spec.clips.shorts.enabled && !flags.SKIP_SHORTS
+      },
+      medium: {
+        ...spec.clips.medium,
+        enabled: spec.clips.medium.enabled && !flags.SKIP_MEDIUM_CLIPS
+      }
+    },
+    distribution: {
+      ...spec.distribution,
+      enabled: spec.distribution.enabled && !flags.SKIP_SOCIAL,
+      publish: spec.distribution.publish && !flags.SKIP_SOCIAL_PUBLISH
+    }
+  };
+}
+function resolveFromFlags(flags) {
+  return applySkipFlags(PRESET_FULL, flags);
+}
+var init_merger = __esm({
+  "src/L0-pure/pipelineSpec/merger.ts"() {
+    "use strict";
+    init_presets();
+  }
+});
+
+// src/L0-pure/pipelineSpec/index.ts
+var pipelineSpec_exports = {};
+__export(pipelineSpec_exports, {
+  PRESETS: () => PRESETS,
+  PRESET_CLEAN: () => PRESET_CLEAN,
+  PRESET_FULL: () => PRESET_FULL,
+  PRESET_MINIMAL: () => PRESET_MINIMAL,
+  applySkipFlags: () => applySkipFlags,
+  getPreset: () => getPreset,
+  isPresetName: () => isPresetName,
+  mergeWithDefaults: () => mergeWithDefaults,
+  resolveFromFlags: () => resolveFromFlags,
+  validateSpec: () => validateSpec
+});
+var init_pipelineSpec = __esm({
+  "src/L0-pure/pipelineSpec/index.ts"() {
+    "use strict";
+    init_types();
+    init_presets();
+    init_validation();
+    init_merger();
+  }
+});
+
 // src/L0-pure/types/index.ts
 function getStageInfo(stage) {
   const info = PIPELINE_STAGES.find((s) => s.stage === stage);
@@ -729,9 +1110,10 @@ function isSupportedVideoExtension(ext) {
   return SUPPORTED_VIDEO_EXTENSIONS.includes(ext.toLowerCase());
 }
 var Platform, PIPELINE_STAGES, TOTAL_STAGES, PLATFORM_CHAR_LIMITS, SUPPORTED_VIDEO_EXTENSIONS;
-var init_types = __esm({
+var init_types2 = __esm({
   "src/L0-pure/types/index.ts"() {
     "use strict";
+    init_pipelineSpec();
     Platform = /* @__PURE__ */ ((Platform2) => {
       Platform2["TikTok"] = "tiktok";
       Platform2["YouTube"] = "youtube";
@@ -5837,23 +6219,63 @@ function createSessionRpc(connection, sessionId) {
       readFile: async (params) => connection.sendRequest("session.workspace.readFile", { sessionId, ...params }),
       createFile: async (params) => connection.sendRequest("session.workspace.createFile", { sessionId, ...params })
     },
+    /** @experimental */
     fleet: {
       start: async (params) => connection.sendRequest("session.fleet.start", { sessionId, ...params })
     },
+    /** @experimental */
     agent: {
       list: async () => connection.sendRequest("session.agent.list", { sessionId }),
       getCurrent: async () => connection.sendRequest("session.agent.getCurrent", { sessionId }),
       select: async (params) => connection.sendRequest("session.agent.select", { sessionId, ...params }),
-      deselect: async () => connection.sendRequest("session.agent.deselect", { sessionId })
+      deselect: async () => connection.sendRequest("session.agent.deselect", { sessionId }),
+      reload: async () => connection.sendRequest("session.agent.reload", { sessionId })
+    },
+    /** @experimental */
+    skills: {
+      list: async () => connection.sendRequest("session.skills.list", { sessionId }),
+      enable: async (params) => connection.sendRequest("session.skills.enable", { sessionId, ...params }),
+      disable: async (params) => connection.sendRequest("session.skills.disable", { sessionId, ...params }),
+      reload: async () => connection.sendRequest("session.skills.reload", { sessionId })
+    },
+    /** @experimental */
+    mcp: {
+      list: async () => connection.sendRequest("session.mcp.list", { sessionId }),
+      enable: async (params) => connection.sendRequest("session.mcp.enable", { sessionId, ...params }),
+      disable: async (params) => connection.sendRequest("session.mcp.disable", { sessionId, ...params }),
+      reload: async () => connection.sendRequest("session.mcp.reload", { sessionId })
+    },
+    /** @experimental */
+    plugins: {
+      list: async () => connection.sendRequest("session.plugins.list", { sessionId })
     },
+    /** @experimental */
+    extensions: {
+      list: async () => connection.sendRequest("session.extensions.list", { sessionId }),
+      enable: async (params) => connection.sendRequest("session.extensions.enable", { sessionId, ...params }),
+      disable: async (params) => connection.sendRequest("session.extensions.disable", { sessionId, ...params }),
+      reload: async () => connection.sendRequest("session.extensions.reload", { sessionId })
+    },
+    /** @experimental */
     compaction: {
       compact: async () => connection.sendRequest("session.compaction.compact", { sessionId })
     },
     tools: {
       handlePendingToolCall: async (params) => connection.sendRequest("session.tools.handlePendingToolCall", { sessionId, ...params })
     },
+    commands: {
+      handlePendingCommand: async (params) => connection.sendRequest("session.commands.handlePendingCommand", { sessionId, ...params })
+    },
+    ui: {
+      elicitation: async (params) => connection.sendRequest("session.ui.elicitation", { sessionId, ...params })
+    },
     permissions: {
       handlePendingPermissionRequest: async (params) => connection.sendRequest("session.permissions.handlePendingPermissionRequest", { sessionId, ...params })
+    },
+    log: async (params) => connection.sendRequest("session.log", { sessionId, ...params }),
+    shell: {
+      exec: async (params) => connection.sendRequest("session.shell.exec", { sessionId, ...params }),
+      kill: async (params) => connection.sendRequest("session.shell.kill", { sessionId, ...params })
     }
   };
 }
@@ -5875,13 +6297,30 @@ var init_sdkProtocolVersion = __esm({
   }
 });
 
+// node_modules/@github/copilot-sdk/dist/telemetry.js
+async function getTraceContext(provider) {
+  if (!provider) return {};
+  try {
+    return await provider() ?? {};
+  } catch {
+    return {};
+  }
+}
+var init_telemetry = __esm({
+  "node_modules/@github/copilot-sdk/dist/telemetry.js"() {
+    "use strict";
+  }
+});
+
 // node_modules/@github/copilot-sdk/dist/session.js
-var import_node, CopilotSession;
+var import_node, NO_RESULT_PERMISSION_V2_ERROR, CopilotSession;
 var init_session = __esm({
   "node_modules/@github/copilot-sdk/dist/session.js"() {
     "use strict";
     import_node = __toESM(require_node(), 1);
     init_rpc();
+    init_telemetry();
+    NO_RESULT_PERMISSION_V2_ERROR = "Permission handlers cannot return 'no-result' when connected to a protocol v2 server.";
     CopilotSession = class {
       /**
        * Creates a new CopilotSession instance.
@@ -5889,12 +6328,14 @@ var init_session = __esm({
        * @param sessionId - The unique identifier for this session
        * @param connection - The JSON-RPC message connection to the Copilot CLI
        * @param workspacePath - Path to the session workspace directory (when infinite sessions enabled)
+       * @param traceContextProvider - Optional callback to get W3C Trace Context for outbound RPCs
        * @internal This constructor is internal. Use {@link CopilotClient.createSession} to create sessions.
        */
-      constructor(sessionId, connection, _workspacePath) {
+      constructor(sessionId, connection, _workspacePath, traceContextProvider) {
         this.sessionId = sessionId;
         this.connection = connection;
         this._workspacePath = _workspacePath;
+        this.traceContextProvider = traceContextProvider;
       }
       eventHandlers = /* @__PURE__ */ new Set();
       typedEventHandlers = /* @__PURE__ */ new Map();
@@ -5902,7 +6343,9 @@ var init_session = __esm({
       permissionHandler;
       userInputHandler;
       hooks;
+      transformCallbacks;
       _rpc = null;
+      traceContextProvider;
       /**
        * Typed session-scoped RPC methods.
        */
@@ -5940,6 +6383,7 @@ var init_session = __esm({
        */
       async send(options) {
         const response = await this.connection.sendRequest("session.send", {
+          ...await getTraceContext(this.traceContextProvider),
           sessionId: this.sessionId,
           prompt: options.prompt,
           attachments: options.attachments,
@@ -6069,9 +6513,19 @@ var init_session = __esm({
           const { requestId, toolName } = event.data;
           const args = event.data.arguments;
           const toolCallId = event.data.toolCallId;
+          const traceparent = event.data.traceparent;
+          const tracestate = event.data.tracestate;
           const handler = this.toolHandlers.get(toolName);
           if (handler) {
-            void this._executeToolAndRespond(requestId, toolName, toolCallId, args, handler);
+            void this._executeToolAndRespond(
+              requestId,
+              toolName,
+              toolCallId,
+              args,
+              handler,
+              traceparent,
+              tracestate
+            );
           }
         } else if (event.type === "permission.requested") {
           const { requestId, permissionRequest } = event.data;
@@ -6084,13 +6538,15 @@ var init_session = __esm({
        * Executes a tool handler and sends the result back via RPC.
        * @internal
        */
-      async _executeToolAndRespond(requestId, toolName, toolCallId, args, handler) {
+      async _executeToolAndRespond(requestId, toolName, toolCallId, args, handler, traceparent, tracestate) {
         try {
           const rawResult = await handler(args, {
             sessionId: this.sessionId,
             toolCallId,
             toolName,
-            arguments: args
+            arguments: args,
+            traceparent,
+            tracestate
           });
           let result;
           if (rawResult == null) {
@@ -6121,6 +6577,9 @@ var init_session = __esm({
           const result = await this.permissionHandler(permissionRequest, {
             sessionId: this.sessionId
           });
+          if (result.kind === "no-result") {
+            return;
+          }
           await this.rpc.permissions.handlePendingPermissionRequest({ requestId, result });
         } catch (_error) {
           try {
@@ -6201,6 +6660,40 @@ var init_session = __esm({
       registerHooks(hooks) {
         this.hooks = hooks;
       }
+      /**
+       * Registers transform callbacks for system message sections.
+       *
+       * @param callbacks - Map of section ID to transform callback, or undefined to clear
+       * @internal This method is typically called internally when creating a session.
+       */
+      registerTransformCallbacks(callbacks) {
+        this.transformCallbacks = callbacks;
+      }
+      /**
+       * Handles a systemMessage.transform request from the runtime.
+       * Dispatches each section to its registered transform callback.
+       *
+       * @param sections - Map of section IDs to their current rendered content
+       * @returns A promise that resolves with the transformed sections
+       * @internal This method is for internal use by the SDK.
+       */
+      async _handleSystemMessageTransform(sections) {
+        const result = {};
+        for (const [sectionId, { content }] of Object.entries(sections)) {
+          const callback = this.transformCallbacks?.get(sectionId);
+          if (callback) {
+            try {
+              const transformed = await callback(content);
+              result[sectionId] = { content: transformed };
+            } catch (_error) {
+              result[sectionId] = { content };
+            }
+          } else {
+            result[sectionId] = { content };
+          }
+        }
+        return { sections: result };
+      }
       /**
        * Handles a permission request in the v2 protocol format (synchronous RPC).
        * Used as a back-compat adapter when connected to a v2 server.
@@ -6217,8 +6710,14 @@ var init_session = __esm({
           const result = await this.permissionHandler(request, {
             sessionId: this.sessionId
           });
+          if (result.kind === "no-result") {
+            throw new Error(NO_RESULT_PERMISSION_V2_ERROR);
+          }
           return result;
-        } catch (_error) {
+        } catch (error) {
+          if (error instanceof Error && error.message === NO_RESULT_PERMISSION_V2_ERROR) {
+            throw error;
+          }
           return { kind: "denied-no-approval-rule-and-could-not-request-from-user" };
         }
       }
@@ -6374,14 +6873,35 @@ var init_session = __esm({
        * The new model takes effect for the next message. Conversation history is preserved.
        *
        * @param model - Model ID to switch to
+       * @param options - Optional settings for the new model
        *
        * @example
        * ```typescript
        * await session.setModel("gpt-4.1");
+       * await session.setModel("claude-sonnet-4.6", { reasoningEffort: "high" });
+       * ```
+       */
+      async setModel(model, options) {
+        await this.rpc.model.switchTo({ modelId: model, ...options });
+      }
+      /**
+       * Log a message to the session timeline.
+       * The message appears in the session event stream and is visible to SDK consumers
+       * and (for non-ephemeral messages) persisted to the session event log on disk.
+       *
+       * @param message - Human-readable message text
+       * @param options - Optional log level and ephemeral flag
+       *
+       * @example
+       * ```typescript
+       * await session.log("Processing started");
+       * await session.log("Disk usage high", { level: "warning" });
+       * await session.log("Connection failed", { level: "error" });
+       * await session.log("Debug info", { ephemeral: true });
        * ```
        */
-      async setModel(model) {
-        await this.rpc.model.switchTo({ modelId: model });
+      async log(message, options) {
+        await this.rpc.log({ message, ...options });
       }
     };
   }
@@ -6389,7 +6909,9 @@ var init_session = __esm({
 
 // node_modules/@github/copilot-sdk/dist/client.js
 import { spawn } from "child_process";
+import { randomUUID } from "crypto";
 import { existsSync as existsSync4 } from "fs";
+import { createRequire as createRequire2 } from "module";
 import { Socket } from "net";
 import { dirname as dirname3, join as join6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -6403,6 +6925,30 @@ function toJsonSchema(parameters) {
   }
   return parameters;
 }
+function extractTransformCallbacks(systemMessage) {
+  if (!systemMessage || systemMessage.mode !== "customize" || !systemMessage.sections) {
+    return { wirePayload: systemMessage, transformCallbacks: void 0 };
+  }
+  const transformCallbacks = /* @__PURE__ */ new Map();
+  const wireSections = {};
+  for (const [sectionId, override] of Object.entries(systemMessage.sections)) {
+    if (!override) continue;
+    if (typeof override.action === "function") {
+      transformCallbacks.set(sectionId, override.action);
+      wireSections[sectionId] = { action: "transform" };
+    } else {
+      wireSections[sectionId] = { action: override.action, content: override.content };
+    }
+  }
+  if (transformCallbacks.size === 0) {
+    return { wirePayload: systemMessage, transformCallbacks: void 0 };
+  }
+  const wirePayload = {
+    ...systemMessage,
+    sections: wireSections
+  };
+  return { wirePayload, transformCallbacks };
+}
 function getNodeExecPath() {
   if (process.versions.bun) {
     return "node";
@@ -6410,9 +6956,22 @@ function getNodeExecPath() {
   return process.execPath;
 }
 function getBundledCliPath() {
-  const sdkUrl = import.meta.resolve("@github/copilot/sdk");
-  const sdkPath = fileURLToPath3(sdkUrl);
-  return join6(dirname3(dirname3(sdkPath)), "index.js");
+  if (typeof import.meta.resolve === "function") {
+    const sdkUrl = import.meta.resolve("@github/copilot/sdk");
+    const sdkPath = fileURLToPath3(sdkUrl);
+    return join6(dirname3(dirname3(sdkPath)), "index.js");
+  }
+  const req = createRequire2(__filename);
+  const searchPaths = req.resolve.paths("@github/copilot") ?? [];
+  for (const base of searchPaths) {
+    const candidate = join6(base, "@github", "copilot", "index.js");
+    if (existsSync4(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Could not find @github/copilot package. Searched ${searchPaths.length} paths. Ensure it is installed, or pass cliPath/cliUrl to CopilotClient.`
+  );
 }
 var import_node2, MIN_PROTOCOL_VERSION, CopilotClient;
 var init_client = __esm({
@@ -6422,6 +6981,7 @@ var init_client = __esm({
     init_rpc();
     init_sdkProtocolVersion();
     init_session();
+    init_telemetry();
     MIN_PROTOCOL_VERSION = 2;
     CopilotClient = class {
       cliProcess = null;
@@ -6436,6 +6996,8 @@ var init_client = __esm({
       options;
       isExternalServer = false;
       forceStopping = false;
+      onListModels;
+      onGetTraceContext;
       modelsCache = null;
       modelsCacheLock = Promise.resolve();
       sessionLifecycleHandlers = /* @__PURE__ */ new Set();
@@ -6501,8 +7063,10 @@ var init_client = __esm({
         if (options.isChildProcess) {
           this.isExternalServer = true;
         }
+        this.onListModels = options.onListModels;
+        this.onGetTraceContext = options.onGetTraceContext;
         this.options = {
-          cliPath: options.cliPath || getBundledCliPath(),
+          cliPath: options.cliUrl ? void 0 : options.cliPath || getBundledCliPath(),
           cliArgs: options.cliArgs ?? [],
           cwd: options.cwd ?? process.cwd(),
           port: options.port || 0,
@@ -6512,11 +7076,12 @@ var init_client = __esm({
           cliUrl: options.cliUrl,
           logLevel: options.logLevel || "debug",
           autoStart: options.autoStart ?? true,
-          autoRestart: options.autoRestart ?? true,
+          autoRestart: false,
           env: options.env ?? process.env,
           githubToken: options.githubToken,
           // Default useLoggedInUser to false when githubToken is provided, otherwise true
-          useLoggedInUser: options.useLoggedInUser ?? (options.githubToken ? false : true)
+          useLoggedInUser: options.useLoggedInUser ?? (options.githubToken ? false : true),
+          telemetry: options.telemetry
         };
       }
       /**
@@ -6612,8 +7177,8 @@ var init_client = __esm({
             } catch (error) {
               lastError = error instanceof Error ? error : new Error(String(error));
               if (attempt < 3) {
-                const delay = 100 * Math.pow(2, attempt - 1);
-                await new Promise((resolve4) => setTimeout(resolve4, delay));
+                const delay2 = 100 * Math.pow(2, attempt - 1);
+                await new Promise((resolve4) => setTimeout(resolve4, delay2));
               }
             }
           }
@@ -6768,36 +7333,13 @@ var init_client = __esm({
             throw new Error("Client not connected. Call start() first.");
           }
         }
-        const response = await this.connection.sendRequest("session.create", {
-          model: config2.model,
-          sessionId: config2.sessionId,
-          clientName: config2.clientName,
-          reasoningEffort: config2.reasoningEffort,
-          tools: config2.tools?.map((tool) => ({
-            name: tool.name,
-            description: tool.description,
-            parameters: toJsonSchema(tool.parameters),
-            overridesBuiltInTool: tool.overridesBuiltInTool
-          })),
-          systemMessage: config2.systemMessage,
-          availableTools: config2.availableTools,
-          excludedTools: config2.excludedTools,
-          provider: config2.provider,
-          requestPermission: true,
-          requestUserInput: !!config2.onUserInputRequest,
-          hooks: !!(config2.hooks && Object.values(config2.hooks).some(Boolean)),
-          workingDirectory: config2.workingDirectory,
-          streaming: config2.streaming,
-          mcpServers: config2.mcpServers,
-          envValueMode: "direct",
-          customAgents: config2.customAgents,
-          configDir: config2.configDir,
-          skillDirectories: config2.skillDirectories,
-          disabledSkills: config2.disabledSkills,
-          infiniteSessions: config2.infiniteSessions
-        });
-        const { sessionId, workspacePath } = response;
-        const session = new CopilotSession(sessionId, this.connection, workspacePath);
+        const sessionId = config2.sessionId ?? randomUUID();
+        const session = new CopilotSession(
+          sessionId,
+          this.connection,
+          void 0,
+          this.onGetTraceContext
+        );
         session.registerTools(config2.tools);
         session.registerPermissionHandler(config2.onPermissionRequest);
         if (config2.onUserInputRequest) {
@@ -6806,7 +7348,54 @@ var init_client = __esm({
         if (config2.hooks) {
           session.registerHooks(config2.hooks);
         }
+        const { wirePayload: wireSystemMessage, transformCallbacks } = extractTransformCallbacks(
+          config2.systemMessage
+        );
+        if (transformCallbacks) {
+          session.registerTransformCallbacks(transformCallbacks);
+        }
+        if (config2.onEvent) {
+          session.on(config2.onEvent);
+        }
         this.sessions.set(sessionId, session);
+        try {
+          const response = await this.connection.sendRequest("session.create", {
+            ...await getTraceContext(this.onGetTraceContext),
+            model: config2.model,
+            sessionId,
+            clientName: config2.clientName,
+            reasoningEffort: config2.reasoningEffort,
+            tools: config2.tools?.map((tool) => ({
+              name: tool.name,
+              description: tool.description,
+              parameters: toJsonSchema(tool.parameters),
+              overridesBuiltInTool: tool.overridesBuiltInTool,
+              skipPermission: tool.skipPermission
+            })),
+            systemMessage: wireSystemMessage,
+            availableTools: config2.availableTools,
+            excludedTools: config2.excludedTools,
+            provider: config2.provider,
+            requestPermission: true,
+            requestUserInput: !!config2.onUserInputRequest,
+            hooks: !!(config2.hooks && Object.values(config2.hooks).some(Boolean)),
+            workingDirectory: config2.workingDirectory,
+            streaming: config2.streaming,
+            mcpServers: config2.mcpServers,
+            envValueMode: "direct",
+            customAgents: config2.customAgents,
+            agent: config2.agent,
+            configDir: config2.configDir,
+            skillDirectories: config2.skillDirectories,
+            disabledSkills: config2.disabledSkills,
+            infiniteSessions: config2.infiniteSessions
+          });
+          const { workspacePath } = response;
+          session["_workspacePath"] = workspacePath;
+        } catch (e) {
+          this.sessions.delete(sessionId);
+          throw e;
+        }
         return session;
       }
       /**
@@ -6846,37 +7435,12 @@ var init_client = __esm({
             throw new Error("Client not connected. Call start() first.");
           }
         }
-        const response = await this.connection.sendRequest("session.resume", {
+        const session = new CopilotSession(
           sessionId,
-          clientName: config2.clientName,
-          model: config2.model,
-          reasoningEffort: config2.reasoningEffort,
-          systemMessage: config2.systemMessage,
-          availableTools: config2.availableTools,
-          excludedTools: config2.excludedTools,
-          tools: config2.tools?.map((tool) => ({
-            name: tool.name,
-            description: tool.description,
-            parameters: toJsonSchema(tool.parameters),
-            overridesBuiltInTool: tool.overridesBuiltInTool
-          })),
-          provider: config2.provider,
-          requestPermission: true,
-          requestUserInput: !!config2.onUserInputRequest,
-          hooks: !!(config2.hooks && Object.values(config2.hooks).some(Boolean)),
-          workingDirectory: config2.workingDirectory,
-          configDir: config2.configDir,
-          streaming: config2.streaming,
-          mcpServers: config2.mcpServers,
-          envValueMode: "direct",
-          customAgents: config2.customAgents,
-          skillDirectories: config2.skillDirectories,
-          disabledSkills: config2.disabledSkills,
-          infiniteSessions: config2.infiniteSessions,
-          disableResume: config2.disableResume
-        });
-        const { sessionId: resumedSessionId, workspacePath } = response;
-        const session = new CopilotSession(resumedSessionId, this.connection, workspacePath);
+          this.connection,
+          void 0,
+          this.onGetTraceContext
+        );
         session.registerTools(config2.tools);
         session.registerPermissionHandler(config2.onPermissionRequest);
         if (config2.onUserInputRequest) {
@@ -6885,7 +7449,55 @@ var init_client = __esm({
         if (config2.hooks) {
           session.registerHooks(config2.hooks);
         }
-        this.sessions.set(resumedSessionId, session);
+        const { wirePayload: wireSystemMessage, transformCallbacks } = extractTransformCallbacks(
+          config2.systemMessage
+        );
+        if (transformCallbacks) {
+          session.registerTransformCallbacks(transformCallbacks);
+        }
+        if (config2.onEvent) {
+          session.on(config2.onEvent);
+        }
+        this.sessions.set(sessionId, session);
+        try {
+          const response = await this.connection.sendRequest("session.resume", {
+            ...await getTraceContext(this.onGetTraceContext),
+            sessionId,
+            clientName: config2.clientName,
+            model: config2.model,
+            reasoningEffort: config2.reasoningEffort,
+            systemMessage: wireSystemMessage,
+            availableTools: config2.availableTools,
+            excludedTools: config2.excludedTools,
+            tools: config2.tools?.map((tool) => ({
+              name: tool.name,
+              description: tool.description,
+              parameters: toJsonSchema(tool.parameters),
+              overridesBuiltInTool: tool.overridesBuiltInTool,
+              skipPermission: tool.skipPermission
+            })),
+            provider: config2.provider,
+            requestPermission: true,
+            requestUserInput: !!config2.onUserInputRequest,
+            hooks: !!(config2.hooks && Object.values(config2.hooks).some(Boolean)),
+            workingDirectory: config2.workingDirectory,
+            configDir: config2.configDir,
+            streaming: config2.streaming,
+            mcpServers: config2.mcpServers,
+            envValueMode: "direct",
+            customAgents: config2.customAgents,
+            agent: config2.agent,
+            skillDirectories: config2.skillDirectories,
+            disabledSkills: config2.disabledSkills,
+            infiniteSessions: config2.infiniteSessions,
+            disableResume: config2.disableResume
+          });
+          const { workspacePath } = response;
+          session["_workspacePath"] = workspacePath;
+        } catch (e) {
+          this.sessions.delete(sessionId);
+          throw e;
+        }
         return session;
       }
       /**
@@ -6946,15 +7558,15 @@ var init_client = __esm({
       /**
        * List available models with their metadata.
        *
+       * If an `onListModels` handler was provided in the client options,
+       * it is called instead of querying the CLI server.
+       *
        * Results are cached after the first successful call to avoid rate limiting.
        * The cache is cleared when the client disconnects.
        *
-       * @throws Error if not authenticated
+       * @throws Error if not connected (when no custom handler is set)
        */
       async listModels() {
-        if (!this.connection) {
-          throw new Error("Client not connected");
-        }
         await this.modelsCacheLock;
         let resolveLock;
         this.modelsCacheLock = new Promise((resolve4) => {
@@ -6964,10 +7576,18 @@ var init_client = __esm({
           if (this.modelsCache !== null) {
             return [...this.modelsCache];
           }
-          const result = await this.connection.sendRequest("models.list", {});
-          const response = result;
-          const models = response.models;
-          this.modelsCache = models;
+          let models;
+          if (this.onListModels) {
+            models = await this.onListModels();
+          } else {
+            if (!this.connection) {
+              throw new Error("Client not connected");
+            }
+            const result = await this.connection.sendRequest("models.list", {});
+            const response = result;
+            models = response.models;
+          }
+          this.modelsCache = [...models];
           return [...models];
         } finally {
           resolveLock();
@@ -7180,6 +7800,27 @@ var init_client = __esm({
           if (this.options.githubToken) {
             envWithoutNodeDebug.COPILOT_SDK_AUTH_TOKEN = this.options.githubToken;
           }
+          if (!this.options.cliPath) {
+            throw new Error(
+              "Path to Copilot CLI is required. Please provide it via the cliPath option, or use cliUrl to rely on a remote CLI."
+            );
+          }
+          if (this.options.telemetry) {
+            const t = this.options.telemetry;
+            envWithoutNodeDebug.COPILOT_OTEL_ENABLED = "true";
+            if (t.otlpEndpoint !== void 0)
+              envWithoutNodeDebug.OTEL_EXPORTER_OTLP_ENDPOINT = t.otlpEndpoint;
+            if (t.filePath !== void 0)
+              envWithoutNodeDebug.COPILOT_OTEL_FILE_EXPORTER_PATH = t.filePath;
+            if (t.exporterType !== void 0)
+              envWithoutNodeDebug.COPILOT_OTEL_EXPORTER_TYPE = t.exporterType;
+            if (t.sourceName !== void 0)
+              envWithoutNodeDebug.COPILOT_OTEL_SOURCE_NAME = t.sourceName;
+            if (t.captureContent !== void 0)
+              envWithoutNodeDebug.OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = String(
+                t.captureContent
+              );
+          }
           if (!existsSync4(this.options.cliPath)) {
             throw new Error(
               `Copilot CLI not found at ${this.options.cliPath}. Ensure @github/copilot is installed.`
@@ -7279,8 +7920,6 @@ stderr: ${stderrOutput}`
               } else {
                 reject(new Error(`CLI server exited with code ${code}`));
               }
-            } else if (this.options.autoRestart && this.state === "connected") {
-              void this.reconnect();
             }
           });
           setTimeout(() => {
@@ -7385,12 +8024,15 @@ stderr: ${stderrOutput}`
           "hooks.invoke",
           async (params) => await this.handleHooksInvoke(params)
         );
+        this.connection.onRequest(
+          "systemMessage.transform",
+          async (params) => await this.handleSystemMessageTransform(params)
+        );
         this.connection.onClose(() => {
-          if (this.state === "connected" && this.options.autoRestart) {
-            void this.reconnect();
-          }
+          this.state = "disconnected";
         });
         this.connection.onError((_error) => {
+          this.state = "disconnected";
         });
       }
       handleSessionEventNotification(notification) {
@@ -7449,6 +8091,16 @@ stderr: ${stderrOutput}`
         const output = await session._handleHooksInvoke(params.hookType, params.input);
         return { output };
       }
+      async handleSystemMessageTransform(params) {
+        if (!params || typeof params.sessionId !== "string" || !params.sections || typeof params.sections !== "object") {
+          throw new Error("Invalid systemMessage.transform payload");
+        }
+        const session = this.sessions.get(params.sessionId);
+        if (!session) {
+          throw new Error(`Session not found: ${params.sessionId}`);
+        }
+        return await session._handleSystemMessageTransform(params.sections);
+      }
       // ========================================================================
       // Protocol v2 backward-compatibility adapters
       // ========================================================================
@@ -7477,11 +8129,15 @@ stderr: ${stderrOutput}`
           };
         }
         try {
+          const traceparent = params.traceparent;
+          const tracestate = params.tracestate;
           const invocation = {
             sessionId: params.sessionId,
             toolCallId: params.toolCallId,
             toolName: params.toolName,
-            arguments: params.arguments
+            arguments: params.arguments,
+            traceparent,
+            tracestate
           };
           const result = await handler(params.arguments, invocation);
           return { result: this.normalizeToolResultV2(result) };
@@ -7511,7 +8167,10 @@ stderr: ${stderrOutput}`
         try {
           const result = await session._handlePermissionRequestV2(params.permissionRequest);
           return { result };
-        } catch (_error) {
+        } catch (error) {
+          if (error instanceof Error && error.message === NO_RESULT_PERMISSION_V2_ERROR) {
+            throw error;
+          }
           return {
             result: {
               kind: "denied-no-approval-rule-and-could-not-request-from-user"
@@ -7541,24 +8200,13 @@ stderr: ${stderrOutput}`
       isToolResultObject(value) {
         return typeof value === "object" && value !== null && "textResultForLlm" in value && typeof value.textResultForLlm === "string" && "resultType" in value;
       }
-      /**
-       * Attempt to reconnect to the server
-       */
-      async reconnect() {
-        this.state = "disconnected";
-        try {
-          await this.stop();
-          await this.start();
-        } catch (_error) {
-        }
-      }
     };
   }
 });
 
 // node_modules/@github/copilot-sdk/dist/types.js
 var approveAll;
-var init_types2 = __esm({
+var init_types3 = __esm({
   "node_modules/@github/copilot-sdk/dist/types.js"() {
     "use strict";
     approveAll = () => ({ kind: "approved" });
@@ -7571,21 +8219,21 @@ var init_dist = __esm({
     "use strict";
     init_client();
     init_session();
-    init_types2();
+    init_types3();
   }
 });
 
 // src/L1-infra/ai/copilot.ts
 import { existsSync as existsSync5 } from "fs";
 import { join as join7, dirname as dirname4 } from "path";
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 function resolveCopilotCliPath() {
   const platform = process.platform;
   const arch = process.arch;
   const binaryName = platform === "win32" ? "copilot.exe" : "copilot";
   const platformPkg = `@github/copilot-${platform}-${arch}`;
   try {
-    const require_ = createRequire2(import.meta.url);
+    const require_ = createRequire3(import.meta.url);
     const searchPaths = require_.resolve.paths(platformPkg) ?? [];
     for (const base of searchPaths) {
       const candidate = join7(base, platformPkg, binaryName);
@@ -9804,7 +10452,7 @@ var STATUS_LABEL_PREFIX, PLATFORM_LABEL_PREFIX, PRIORITY_LABEL_PREFIX, COMMENT_M
 var init_ideaService = __esm({
   "src/L3-services/ideaService/ideaService.ts"() {
     "use strict";
-    init_types();
+    init_types2();
     init_githubClient();
     init_environment();
     init_configLogger();
@@ -10229,7 +10877,7 @@ async function itemExists(id) {
 var init_postStore = __esm({
   "src/L3-services/postStore/postStore.ts"() {
     "use strict";
-    init_types();
+    init_types2();
     init_environment();
     init_configLogger();
     init_fileSystem();
@@ -10396,6 +11044,31 @@ var init_lateApi = __esm({
         }
         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 {
@@ -11254,81 +11927,396 @@ async function rescheduleAllPosts(options) {
       }
       if (!dryRun) {
         try {
-          await lateClient.schedulePost(latePostId, newSlotDatetime);
-        } catch (scheduleErr) {
-          const errMsg = scheduleErr instanceof Error ? scheduleErr.message : String(scheduleErr);
-          if (errMsg.includes("Published posts can only have their recycling config updated")) {
-            logger_default.info(`Skipping ${label}: post already published on platform`);
-            result.details.push({ itemId: item.id, platform: itemPlatform, latePostId, oldSlot, newSlot: null, error: "Already published \u2014 skipped" });
-            result.unchanged++;
-            continue;
-          }
-          throw scheduleErr;
+          await lateClient.schedulePost(latePostId, newSlotDatetime);
+        } catch (scheduleErr) {
+          const errMsg = scheduleErr instanceof Error ? scheduleErr.message : String(scheduleErr);
+          if (errMsg.includes("Published posts can only have their recycling config updated")) {
+            logger_default.info(`Skipping ${label}: post already published on platform`);
+            result.details.push({ itemId: item.id, platform: itemPlatform, latePostId, oldSlot, newSlot: null, error: "Already published \u2014 skipped" });
+            result.unchanged++;
+            continue;
+          }
+          throw scheduleErr;
+        }
+        await updatePublishedItemSchedule(item.id, newSlotDatetime);
+      }
+      if (oldSlot) {
+        const oldMs = normalizeDateTime(oldSlot);
+        const oldBooked = bookedMap.get(oldMs);
+        if (oldBooked?.postId === latePostId) {
+          bookedMap.delete(oldMs);
+        }
+      }
+      bookedMap.set(newSlotMs, {
+        scheduledFor: newSlotDatetime,
+        source: "late",
+        postId: latePostId,
+        platform: itemPlatform,
+        ideaLinked: isIdea,
+        ideaIds: item.metadata.ideaIds
+      });
+      logger_default.info(`Rescheduled ${label}: ${oldSlot ?? "unscheduled"} \u2192 ${newSlotDatetime}`);
+      result.details.push({ itemId: item.id, platform: itemPlatform, latePostId, oldSlot, newSlot: newSlotDatetime });
+      result.rescheduled++;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger_default.error(`Failed to reschedule ${label}: ${msg}`);
+      result.details.push({ itemId: item.id, platform: itemPlatform, latePostId, oldSlot, newSlot: null, error: msg });
+      result.failed++;
+    }
+  }
+  logger_default.info(`Reschedule complete: ${result.rescheduled} moved, ${result.unchanged} unchanged, ${result.failed} failed`);
+  return result;
+}
+async function rescheduleIdeaPosts(options) {
+  return rescheduleAllPosts(options);
+}
+async function getScheduleCalendar(startDate, endDate) {
+  const bookedMap = await buildBookedMap();
+  let filtered = [...bookedMap.values()].filter((slot) => slot.source === "local" || slot.status === "scheduled").map((slot) => ({
+    platform: slot.platform,
+    scheduledFor: slot.scheduledFor,
+    source: slot.source,
+    postId: slot.postId,
+    itemId: slot.itemId
+  }));
+  if (startDate) {
+    const startMs = startDate.getTime();
+    filtered = filtered.filter((slot) => normalizeDateTime(slot.scheduledFor) >= startMs);
+  }
+  if (endDate) {
+    const endMs = endDate.getTime();
+    filtered = filtered.filter((slot) => normalizeDateTime(slot.scheduledFor) <= endMs);
+  }
+  filtered.sort((left, right) => normalizeDateTime(left.scheduledFor) - normalizeDateTime(right.scheduledFor));
+  return filtered;
+}
+var MAX_LOOKAHEAD_DAYS, DAY_MS, HOUR_MS;
+var init_scheduler = __esm({
+  "src/L3-services/scheduler/scheduler.ts"() {
+    "use strict";
+    init_lateApi();
+    init_configLogger();
+    init_postStore();
+    init_scheduleConfig();
+    MAX_LOOKAHEAD_DAYS = 730;
+    DAY_MS = 24 * 60 * 60 * 1e3;
+    HOUR_MS = 60 * 60 * 1e3;
+  }
+});
+
+// src/L3-services/queueMapping/queueMapping.ts
+function cachePath() {
+  return join(process.cwd(), CACHE_FILE);
+}
+function isCacheValid(cache2) {
+  const fetchedAtTime = new Date(cache2.fetchedAt).getTime();
+  if (Number.isNaN(fetchedAtTime)) {
+    logger_default.warn("Invalid fetchedAt in queue cache; treating as stale", {
+      fetchedAt: cache2.fetchedAt
+    });
+    return false;
+  }
+  const age = Date.now() - fetchedAtTime;
+  return age < CACHE_TTL_MS;
+}
+async function readFileCache() {
+  try {
+    const raw = await readTextFile(cachePath());
+    const cache2 = JSON.parse(raw);
+    if (cache2.mappings && cache2.profileId && cache2.fetchedAt && isCacheValid(cache2)) {
+      return cache2;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function writeFileCache(cache2) {
+  try {
+    if (!cache2 || typeof cache2 !== "object" || !cache2.mappings || !cache2.profileId || !cache2.fetchedAt) {
+      logger_default.warn("Invalid queue cache structure, skipping write");
+      return;
+    }
+    const sanitized = {
+      mappings: typeof cache2.mappings === "object" ? { ...cache2.mappings } : {},
+      profileId: String(cache2.profileId),
+      fetchedAt: String(cache2.fetchedAt)
+    };
+    for (const [name, id] of Object.entries(sanitized.mappings)) {
+      if (typeof name !== "string" || typeof id !== "string" || /[\x00-\x1f]/.test(name) || /[\x00-\x1f]/.test(id)) {
+        logger_default.warn("Invalid queue mapping data from API, skipping cache write");
+        return;
+      }
+    }
+    const resolvedCachePath = resolve(cachePath());
+    if (!resolvedCachePath.startsWith(resolve(process.cwd()) + sep)) {
+      throw new Error("Cache path outside working directory");
+    }
+    await writeTextFile(resolvedCachePath, JSON.stringify(sanitized, null, 2));
+  } catch (err) {
+    logger_default.warn("Failed to write queue cache file", { error: err });
+  }
+}
+async function fetchAndCache() {
+  const client = new LateApiClient();
+  const profiles = await client.listProfiles();
+  if (profiles.length === 0) {
+    logger_default.warn("No Late API profiles found \u2014 queue mappings will be empty");
+    const emptyCache = {
+      mappings: {},
+      profileId: "",
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    memoryCache = emptyCache;
+    return emptyCache;
+  }
+  const profileId = profiles[0]._id;
+  const { queues } = await client.listQueues(profileId, true);
+  if (queues.length === 0) {
+    logger_default.warn(
+      "No queues found in Late API \u2014 run `vidpipe sync-queues` to create platform queues"
+    );
+  }
+  const mappings = {};
+  for (const queue2 of queues) {
+    mappings[queue2.name] = queue2._id;
+  }
+  const cache2 = {
+    mappings,
+    profileId,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  memoryCache = cache2;
+  await writeFileCache(cache2);
+  logger_default.info("Refreshed Late queue mappings", {
+    queueCount: queues.length,
+    queues: Object.keys(mappings)
+  });
+  return cache2;
+}
+async function ensureMappings() {
+  if (memoryCache && isCacheValid(memoryCache)) {
+    return memoryCache;
+  }
+  const fileCache = await readFileCache();
+  if (fileCache) {
+    memoryCache = fileCache;
+    return fileCache;
+  }
+  try {
+    return await fetchAndCache();
+  } catch (err) {
+    logger_default.error("Failed to fetch Late queue mappings", { error: err });
+    return { mappings: {}, profileId: "", fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function getQueueId(platform, clipType) {
+  const cache2 = await ensureMappings();
+  const normalizedPlatform = platform === "twitter" ? "x" : platform;
+  const queueName = `${normalizedPlatform}-${clipType}`;
+  return cache2.mappings[queueName] ?? null;
+}
+async function getProfileId() {
+  const cache2 = await ensureMappings();
+  return cache2.profileId;
+}
+async function refreshQueueMappings() {
+  memoryCache = null;
+  const cache2 = await fetchAndCache();
+  return { ...cache2.mappings };
+}
+var CACHE_FILE, CACHE_TTL_MS, 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_MS = 24 * 60 * 60 * 1e3;
+    memoryCache = null;
+  }
+});
+
+// src/L3-services/queueSync/queueSync.ts
+var queueSync_exports = {};
+__export(queueSync_exports, {
+  syncQueuesToLate: () => syncQueuesToLate
+});
+function normalizePlatformName(platform) {
+  return PLATFORM_NAME_MAP[platform] ?? platform;
+}
+function slotsToSortedKey(slots) {
+  const sorted = [...slots].sort(
+    (a, b) => a.dayOfWeek !== b.dayOfWeek ? a.dayOfWeek - b.dayOfWeek : a.time.localeCompare(b.time)
+  );
+  return JSON.stringify(sorted);
+}
+function delay(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+function buildDesiredQueues(config2) {
+  const queues = [];
+  for (const [platformKey, platformSchedule] of Object.entries(config2.platforms)) {
+    const normalizedPlatform = normalizePlatformName(platformKey);
+    if (!platformSchedule.byClipType) continue;
+    for (const [clipType, clipTypeSchedule] of Object.entries(platformSchedule.byClipType)) {
+      const queueName = `${normalizedPlatform}-${clipType}`;
+      const slots = [];
+      for (const timeSlot of clipTypeSchedule.slots) {
+        for (const day of timeSlot.days) {
+          slots.push({ dayOfWeek: DAY_MAP[day], time: timeSlot.time });
+        }
+      }
+      if (slots.length > 0) {
+        queues.push({ name: queueName, slots });
+      }
+    }
+  }
+  return queues;
+}
+async function syncQueuesToLate(options) {
+  const reshuffle = options?.reshuffle ?? false;
+  const dryRun = options?.dryRun ?? false;
+  const deleteOrphans = options?.deleteOrphans ?? false;
+  const result = {
+    created: [],
+    updated: [],
+    deleted: [],
+    unchanged: [],
+    errors: []
+  };
+  const config2 = await loadScheduleConfig();
+  const timezone = config2.timezone;
+  const client = new LateApiClient();
+  const profiles = await client.listProfiles();
+  if (profiles.length === 0) {
+    throw new Error("No Late API profiles found \u2014 cannot sync queues");
+  }
+  const profileId = profiles[0]._id;
+  logger_default.info(`Using Late profile "${profiles[0].name}" (${profileId})`);
+  const desiredQueues = buildDesiredQueues(config2);
+  logger_default.info(`Built ${desiredQueues.length} queue definitions from schedule.json`);
+  const existingData = await client.listQueues(profileId, true);
+  const existingQueues = existingData.queues.map((q) => ({
+    _id: q._id,
+    name: q.name,
+    slots: q.slots,
+    active: q.active
+  }));
+  logger_default.info(`Found ${existingQueues.length} existing queues in Late`);
+  const existingByName = /* @__PURE__ */ new Map();
+  for (const eq of existingQueues) {
+    existingByName.set(eq.name, eq);
+  }
+  const desiredNames = /* @__PURE__ */ new Set();
+  for (const desired of desiredQueues) {
+    desiredNames.add(desired.name);
+    const existing = existingByName.get(desired.name);
+    if (existing) {
+      const existingKey = slotsToSortedKey(existing.slots);
+      const desiredKey = slotsToSortedKey(desired.slots);
+      if (existingKey === desiredKey) {
+        logger_default.debug(`Queue "${desired.name}" unchanged`);
+        result.unchanged.push(desired.name);
+      } else {
+        logger_default.info(`Queue "${desired.name}" slots differ \u2014 updating`);
+        if (!dryRun) {
+          try {
+            await client.updateQueue({
+              profileId,
+              queueId: existing._id,
+              name: desired.name,
+              timezone,
+              slots: desired.slots,
+              reshuffleExisting: reshuffle
+            });
+            result.updated.push(desired.name);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger_default.error(`Failed to update queue "${desired.name}": ${message}`);
+            result.errors.push({ queueName: desired.name, error: message });
+          }
+        } else {
+          logger_default.info(`[DRY RUN] Would update queue "${desired.name}"`);
+          result.updated.push(desired.name);
+        }
+        await delay(RATE_LIMIT_DELAY_MS);
+      }
+    } else {
+      logger_default.info(`Queue "${desired.name}" does not exist \u2014 creating`);
+      if (!dryRun) {
+        try {
+          await client.createQueue({
+            profileId,
+            name: desired.name,
+            timezone,
+            slots: desired.slots,
+            active: true
+          });
+          result.created.push(desired.name);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          logger_default.error(`Failed to create queue "${desired.name}": ${message}`);
+          result.errors.push({ queueName: desired.name, error: message });
         }
-        await updatePublishedItemSchedule(item.id, newSlotDatetime);
+      } else {
+        logger_default.info(`[DRY RUN] Would create queue "${desired.name}"`);
+        result.created.push(desired.name);
       }
-      if (oldSlot) {
-        const oldMs = normalizeDateTime(oldSlot);
-        const oldBooked = bookedMap.get(oldMs);
-        if (oldBooked?.postId === latePostId) {
-          bookedMap.delete(oldMs);
+      await delay(RATE_LIMIT_DELAY_MS);
+    }
+  }
+  if (deleteOrphans) {
+    for (const existing of existingQueues) {
+      if (!desiredNames.has(existing.name)) {
+        logger_default.info(`Orphan queue "${existing.name}" \u2014 deleting`);
+        if (!dryRun) {
+          try {
+            await client.deleteQueue(profileId, existing._id);
+            result.deleted.push(existing.name);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger_default.error(`Failed to delete orphan queue "${existing.name}": ${message}`);
+            result.errors.push({ queueName: existing.name, error: message });
+          }
+        } else {
+          logger_default.info(`[DRY RUN] Would delete orphan queue "${existing.name}"`);
+          result.deleted.push(existing.name);
         }
+        await delay(RATE_LIMIT_DELAY_MS);
       }
-      bookedMap.set(newSlotMs, {
-        scheduledFor: newSlotDatetime,
-        source: "late",
-        postId: latePostId,
-        platform: itemPlatform,
-        ideaLinked: isIdea,
-        ideaIds: item.metadata.ideaIds
-      });
-      logger_default.info(`Rescheduled ${label}: ${oldSlot ?? "unscheduled"} \u2192 ${newSlotDatetime}`);
-      result.details.push({ itemId: item.id, platform: itemPlatform, latePostId, oldSlot, newSlot: newSlotDatetime });
-      result.rescheduled++;
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      logger_default.error(`Failed to reschedule ${label}: ${msg}`);
-      result.details.push({ itemId: item.id, platform: itemPlatform, latePostId, oldSlot, newSlot: null, error: msg });
-      result.failed++;
     }
   }
-  logger_default.info(`Reschedule complete: ${result.rescheduled} moved, ${result.unchanged} unchanged, ${result.failed} failed`);
-  return result;
-}
-async function rescheduleIdeaPosts(options) {
-  return rescheduleAllPosts(options);
-}
-async function getScheduleCalendar(startDate, endDate) {
-  const bookedMap = await buildBookedMap();
-  let filtered = [...bookedMap.values()].filter((slot) => slot.source === "local" || slot.status === "scheduled").map((slot) => ({
-    platform: slot.platform,
-    scheduledFor: slot.scheduledFor,
-    source: slot.source,
-    postId: slot.postId,
-    itemId: slot.itemId
-  }));
-  if (startDate) {
-    const startMs = startDate.getTime();
-    filtered = filtered.filter((slot) => normalizeDateTime(slot.scheduledFor) >= startMs);
-  }
-  if (endDate) {
-    const endMs = endDate.getTime();
-    filtered = filtered.filter((slot) => normalizeDateTime(slot.scheduledFor) <= endMs);
+  if (!dryRun) {
+    await refreshQueueMappings();
   }
-  filtered.sort((left, right) => normalizeDateTime(left.scheduledFor) - normalizeDateTime(right.scheduledFor));
-  return filtered;
+  logger_default.info(
+    `Queue sync complete: ${result.created.length} created, ${result.updated.length} updated, ${result.deleted.length} deleted, ${result.unchanged.length} unchanged, ${result.errors.length} errors`
+  );
+  return result;
 }
-var MAX_LOOKAHEAD_DAYS, DAY_MS, HOUR_MS;
-var init_scheduler = __esm({
-  "src/L3-services/scheduler/scheduler.ts"() {
+var DAY_MAP, PLATFORM_NAME_MAP, RATE_LIMIT_DELAY_MS;
+var init_queueSync = __esm({
+  "src/L3-services/queueSync/queueSync.ts"() {
     "use strict";
     init_lateApi();
-    init_configLogger();
-    init_postStore();
     init_scheduleConfig();
-    MAX_LOOKAHEAD_DAYS = 730;
-    DAY_MS = 24 * 60 * 60 * 1e3;
-    HOUR_MS = 60 * 60 * 1e3;
+    init_queueMapping();
+    init_configLogger();
+    DAY_MAP = {
+      sun: 0,
+      mon: 1,
+      tue: 2,
+      wed: 3,
+      thu: 4,
+      fri: 5,
+      sat: 6
+    };
+    PLATFORM_NAME_MAP = { twitter: "x" };
+    RATE_LIMIT_DELAY_MS = 200;
   }
 });
 
@@ -11502,6 +12490,13 @@ function formatDate2(iso, timezone) {
 }
 async function runReschedule(options = {}) {
   initConfig();
+  if (options.queue) {
+    const { syncQueuesToLate: syncQueuesToLate2 } = await Promise.resolve().then(() => (init_queueSync(), queueSync_exports));
+    logger_default.info("Using Late API queue reshuffle for rescheduling...");
+    const result2 = await syncQueuesToLate2({ reshuffle: true, dryRun: options.dryRun });
+    logger_default.info(`Queue reshuffle complete: ${result2.updated.length} queues reshuffled`);
+    return;
+  }
   const scheduleConfig = await loadScheduleConfig();
   const { timezone } = scheduleConfig;
   if (options.dryRun) {
@@ -11543,6 +12538,7 @@ var init_reschedule = __esm({
     init_environment();
     init_scheduler();
     init_scheduleConfig();
+    init_configLogger();
     PLATFORM_ICON2 = {
       tiktok: "\u{1F3B5}",
       youtube: "\u25B6\uFE0F",
@@ -11554,6 +12550,132 @@ var init_reschedule = __esm({
   }
 });
 
+// src/L7-app/commands/syncQueues.ts
+var syncQueues_exports = {};
+__export(syncQueues_exports, {
+  runSyncQueues: () => runSyncQueues
+});
+async function runSyncQueues(options = {}) {
+  initConfig();
+  logger_default.info("Syncing schedule.json to Late API queues...");
+  if (options.dryRun) logger_default.info("[DRY RUN] No changes will be made");
+  const result = await syncQueuesToLate({
+    reshuffle: options.reshuffle,
+    dryRun: options.dryRun,
+    deleteOrphans: options.deleteOrphans
+  });
+  if (result.created.length > 0) {
+    logger_default.info(`Created ${result.created.length} queues: ${result.created.join(", ")}`);
+  }
+  if (result.updated.length > 0) {
+    logger_default.info(`Updated ${result.updated.length} queues: ${result.updated.join(", ")}`);
+  }
+  if (result.deleted.length > 0) {
+    logger_default.info(`Deleted ${result.deleted.length} queues: ${result.deleted.join(", ")}`);
+  }
+  if (result.unchanged.length > 0) {
+    logger_default.info(`Unchanged: ${result.unchanged.length} queues`);
+  }
+  if (result.errors.length > 0) {
+    for (const err of result.errors) {
+      logger_default.error(`Error syncing ${err.queueName}: ${err.error}`);
+    }
+  }
+  const total = result.created.length + result.updated.length + result.deleted.length + result.unchanged.length;
+  logger_default.info(`Sync complete: ${total} queues processed`);
+}
+var init_syncQueues = __esm({
+  "src/L7-app/commands/syncQueues.ts"() {
+    "use strict";
+    init_environment();
+    init_configLogger();
+    init_queueSync();
+  }
+});
+
+// src/L1-infra/spec/specLoader.ts
+var specLoader_exports = {};
+__export(specLoader_exports, {
+  loadSpec: () => loadSpec
+});
+import { readFile, readdir } from "fs/promises";
+import { join as join8, extname as extname2 } from "path";
+import { parse as parseYaml } from "yaml";
+function isFilePath(nameOrPath) {
+  return nameOrPath.includes("/") || nameOrPath.includes("\\") || nameOrPath.endsWith(".yaml") || nameOrPath.endsWith(".yml") || nameOrPath.endsWith(".json");
+}
+function parseFileContent(raw, filePath) {
+  const ext = extname2(filePath).toLowerCase();
+  if (ext === ".json") {
+    return JSON.parse(raw);
+  }
+  return parseYaml(raw);
+}
+async function fileExists4(filePath) {
+  try {
+    await readFile(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listSpecFiles(specsDir) {
+  try {
+    const entries = await readdir(specsDir);
+    return entries.filter((e) => e.endsWith(".yaml") || e.endsWith(".yml") || e.endsWith(".json"));
+  } catch {
+    return [];
+  }
+}
+function validateAndMerge(raw, source) {
+  const errors = validateSpec(raw);
+  if (errors.length > 0) {
+    const details = errors.map((e) => `  - ${e.path ? e.path + ": " : ""}${e.message}`).join("\n");
+    throw new Error(`Invalid pipeline spec from ${source}:
+${details}`);
+  }
+  return mergeWithDefaults(raw);
+}
+async function loadSpec(nameOrPath, repoRoot) {
+  if (isFilePath(nameOrPath)) {
+    let raw;
+    try {
+      raw = await readFile(nameOrPath, "utf-8");
+    } catch (err) {
+      throw new Error(`Failed to read spec file '${nameOrPath}': ${err.message}`);
+    }
+    const parsed = parseFileContent(raw, nameOrPath);
+    return validateAndMerge(parsed, nameOrPath);
+  }
+  if (isPresetName(nameOrPath)) {
+    return getPreset(nameOrPath);
+  }
+  const specsDir = join8(repoRoot, "pipeline-specs");
+  const conventionPath = join8(specsDir, `${nameOrPath}.yaml`);
+  if (await fileExists4(conventionPath)) {
+    const raw = await readFile(conventionPath, "utf-8");
+    const parsed = parseFileContent(raw, conventionPath);
+    return validateAndMerge(parsed, conventionPath);
+  }
+  const availableFiles = await listSpecFiles(specsDir);
+  const presetList = ["full", "clean", "minimal"];
+  const parts = [`Unknown spec '${nameOrPath}'.`];
+  parts.push(`  Built-in presets: ${presetList.join(", ")}`);
+  if (availableFiles.length > 0) {
+    const names = availableFiles.map((f) => f.replace(/\.(yaml|yml|json)$/, ""));
+    parts.push(`  Custom specs in pipeline-specs/: ${names.join(", ")}`);
+  } else {
+    parts.push(`  No custom specs found in pipeline-specs/`);
+  }
+  throw new Error(parts.join("\n"));
+}
+var init_specLoader = __esm({
+  "src/L1-infra/spec/specLoader.ts"() {
+    "use strict";
+    init_pipelineSpec();
+  }
+});
+
 // src/L1-infra/cli/cli.ts
 import { Command } from "commander";
 import readline from "readline";
@@ -11577,7 +12699,7 @@ init_environment();
 init_paths();
 init_fileSystem();
 init_configLogger();
-init_types();
+init_types2();
 var FileWatcher = class _FileWatcher extends EventEmitter {
   watchFolder;
   watcher = null;
@@ -13260,7 +14382,7 @@ var SocialPostAsset = class extends TextAsset {
 // src/L5-assets/ShortVideoAsset.ts
 init_paths();
 init_fileSystem();
-init_types();
+init_types2();
 
 // src/L5-assets/thumbnailGeneration.ts
 init_paths();
@@ -13520,7 +14642,7 @@ var ShortVideoAsset = class extends VideoAsset {
 // src/L5-assets/MediumClipAsset.ts
 init_paths();
 init_fileSystem();
-init_types();
+init_types2();
 var MediumClipAsset = class extends VideoAsset {
   /** Parent video this clip was extracted from */
   parent;
@@ -13930,7 +15052,39 @@ init_videoOperations();
 init_fileSystem();
 init_paths();
 init_configLogger();
-var SYSTEM_PROMPT2 = `You are a viral short-form video strategist. Your job is to analyze a video transcript with word-level timestamps and extract the **most compelling, shareable moments** as shorts (15\u201360 seconds each).
+function buildShortsSystemPrompt(clipConfig) {
+  const minDuration = clipConfig?.duration?.min ?? 15;
+  const maxDuration = clipConfig?.duration?.max ?? 60;
+  const minViralScore = clipConfig?.minViralScore ?? 8;
+  const maxClips = clipConfig?.maxClips ?? 5;
+  const strategy = clipConfig?.strategy ?? "hook-first";
+  const isHookFirst = strategy === "hook-first";
+  const hookFirstSection = isHookFirst ? `
+### Hook-First Video Ordering
+
+If a short's natural content flows A\u2192B\u2192C\u2192D, the final short should play as D\u2192A\u2192B\u2192C \u2014 the **payoff moment (D) is moved to the front as the hook**, then the content plays from the beginning up to that point. The hook does NOT repeat.
+
+**How to implement:**
+1. Plan the content as normal (full story A\u2192D)
+2. Identify the single most arresting 2-5 second moment \u2014 usually the payoff, punchline, or emotional peak
+3. That moment becomes the FIRST segment in the segments array
+4. The remaining content plays chronologically from start to just before the hook
+5. Example: content [120s\u2013150s], best moment [145s\u2013150s] \u2192 segments: [{start: 145, end: 150}, {start: 120, end: 145}]
+
+**Hook quality rules (NEVER violate):**
+- The hook segment MUST start and end on a **complete sentence or clause boundary**
+- The hook MUST be a **self-contained, complete thought** \u2014 understandable without prior context
+- If no moment qualifies as a clean hook, **keep segments chronological** and use hook text only` : `
+### Chronological Video Ordering
+
+Segments MUST be ordered chronologically \u2014 preserve the original video timeline. Do NOT reorder segments for hook-first ordering. Instead, rely on a strong verbal hook (the \`hook\` text field) as a text overlay to capture attention in the first 3 seconds while the content plays in its natural order.
+
+**How to implement:**
+1. Plan the content as normal \u2014 segments play in order from the video
+2. Identify the most compelling hook text that teases the payoff
+3. All segments in the segments array must be in ascending time order
+4. The hook text overlay provides the attention-grab, not segment reordering`;
+  return `You are a viral short-form video strategist. Your job is to analyze a video transcript with word-level timestamps and extract the **most compelling, shareable moments** as shorts (${minDuration}\u2013${maxDuration} seconds each).
 
 ## Core Philosophy: Quality Over Quantity
 
@@ -13947,7 +15101,7 @@ Design every clip to maximize rewatches and shares, not passive likes.
 ## Your workflow
 1. Read the transcript and note the total duration.
 2. Work through the transcript **section by section**. For each chunk, identify moments with genuine viral potential.
-3. For each potential short, score it using the Viral Score Framework (see below). **Only extract clips scoring 8 or higher.**
+3. For each potential short, score it using the Viral Score Framework (see below). **Only extract clips scoring ${minViralScore} or higher.**
 4. Call **add_shorts** for each batch of qualifying shorts. You can call it as many times as needed.
 5. After your first pass, call **review_shorts** to see everything you've planned so far.
 6. Review critically: Would YOU share each of these? Could any be combined into stronger composites? Are there moments you underscored?
@@ -13962,7 +15116,7 @@ Viral Score = (Hook Strength \xD7 3) + (Emotional Intensity \xD7 2) +
               (Replay Potential \xD7 2)
 
 Maximum score: 60  \u2192  Normalized to 1-20 scale (divide by 3)
-Minimum to extract: 8/20
+Minimum to extract: ${minViralScore}/20
 \`\`\`
 
 | Factor | 1 (Weak) | 3 (Moderate) | 5 (Strong) |
@@ -13998,22 +15152,7 @@ Minimum to extract: 8/20
 | **result-first** | Show the outcome immediately, then explain how | Tutorials, before/after |
 | **bold-claim** | Make a specific, surprising statement of fact | Data-driven, authority content |
 | **question** | "Want to know why X?" \u2014 engage curiosity directly | Engagement-focused, relatable |
-
-### Hook-First Video Ordering
-
-If a short's natural content flows A\u2192B\u2192C\u2192D, the final short should play as D\u2192A\u2192B\u2192C \u2014 the **payoff moment (D) is moved to the front as the hook**, then the content plays from the beginning up to that point. The hook does NOT repeat.
-
-**How to implement:**
-1. Plan the content as normal (full story A\u2192D)
-2. Identify the single most arresting 2-5 second moment \u2014 usually the payoff, punchline, or emotional peak
-3. That moment becomes the FIRST segment in the segments array
-4. The remaining content plays chronologically from start to just before the hook
-5. Example: content [120s\u2013150s], best moment [145s\u2013150s] \u2192 segments: [{start: 145, end: 150}, {start: 120, end: 145}]
-
-**Hook quality rules (NEVER violate):**
-- The hook segment MUST start and end on a **complete sentence or clause boundary**
-- The hook MUST be a **self-contained, complete thought** \u2014 understandable without prior context
-- If no moment qualifies as a clean hook, **keep segments chronological** and use hook text only
+${hookFirstSection}
 
 ## Narrative structures (classify every short)
 
@@ -14064,14 +15203,14 @@ Composites (multi-segment shorts) often make the **best** shorts:
 
 ## Rules
 
-1. Each short must be 15-60 seconds total duration.
+1. Each short must be ${minDuration}-${maxDuration} seconds total duration.
 2. Timestamps must align to word boundaries from the transcript.
 3. Prefer natural sentence boundaries for clean cuts.
 4. Every short needs a catchy, descriptive title (5-10 words).
 5. Tags should be lowercase, no hashes, 3-6 per short.
 6. A 1-second buffer is automatically added around each segment boundary.
 7. Avoid significant timestamp overlap between shorts.
-8. **Minimum viral score of 8/20 to extract.** Be ruthless about quality.
+8. **Minimum viral score of ${minViralScore}/20 to extract.** Be ruthless about quality.
 9. Every short MUST have a hook, hookType, emotionalTrigger, viralScore, narrativeStructure, and shareReason.
 
 ## Using Clip Direction
@@ -14084,8 +15223,10 @@ You may receive AI-generated clip direction with suggested shorts. Use these as
 
 Before adding a short, ask yourself: **"Would I interrupt someone to show them this?"**
 - If YES \u2192 strong clip, add it
-- If "maybe, it's interesting" \u2192 score it honestly and only keep if \u22658
+- If "maybe, it's interesting" \u2192 score it honestly and only keep if \u2265${minViralScore}
 - If NO \u2192 drop it, no matter how "complete" the topic coverage feels`;
+}
+var SYSTEM_PROMPT2 = buildShortsSystemPrompt();
 var ADD_SHORTS_SCHEMA = {
   type: "object",
   properties: {
@@ -14235,20 +15376,22 @@ Review critically:
     return this.isFinalized;
   }
 };
-async function generateShorts(video, transcript, model, clipDirection, webcamOverride, ideas) {
-  const systemPrompt = SYSTEM_PROMPT2 + (ideas?.length ? buildIdeaContext(ideas) : "");
+async function generateShorts(video, transcript, model, clipDirection, webcamOverride, ideas, clipConfig, generateVariants) {
+  const basePrompt = clipConfig ? buildShortsSystemPrompt(clipConfig) : SYSTEM_PROMPT2;
+  const systemPrompt = basePrompt + (ideas?.length ? buildIdeaContext(ideas) : "");
   const agent = new ShortsAgent(systemPrompt, model);
   const transcriptLines = transcript.segments.map((seg) => {
     const words = seg.words.map((w) => `[${w.start.toFixed(2)}-${w.end.toFixed(2)}] ${w.word}`).join(" ");
     return `[${seg.start.toFixed(2)}s \u2013 ${seg.end.toFixed(2)}s] ${seg.text}
 Words: ${words}`;
   });
+  const minViralScore = clipConfig?.minViralScore ?? 8;
   const promptParts = [
     `Analyze the following transcript (${transcript.duration.toFixed(0)}s total) and find the most viral-worthy moments for shorts.
 `,
     `Video: ${video.filename}`,
     `Duration: ${transcript.duration.toFixed(1)}s`,
-    `Focus on quality over quantity \u2014 only extract clips scoring 8+ on the viral score framework. Every clip must have a hook, hookType, emotionalTrigger, viralScore, narrativeStructure, and shareReason.
+    `Focus on quality over quantity \u2014 only extract clips scoring ${minViralScore}+ on the viral score framework. Every clip must have a hook, hookType, emotionalTrigger, viralScore, narrativeStructure, and shareReason.
 `,
     "--- TRANSCRIPT ---\n",
     transcriptLines.join("\n\n"),
@@ -14300,23 +15443,27 @@ Words: ${words}`;
       } else {
         await extractCompositeClip2(video.repoPath, segments, outputPath);
       }
-      let variants;
-      try {
-        const defaultPlatforms = ["tiktok", "youtube-shorts", "instagram-reels", "instagram-feed", "linkedin"];
-        const results = await generatePlatformVariants2(outputPath, shortsDir, shortSlug, defaultPlatforms, { webcamOverride });
-        if (results.length > 0) {
-          variants = results.map((v) => ({
-            path: v.path,
-            aspectRatio: v.aspectRatio,
-            platform: v.platform,
-            width: v.width,
-            height: v.height
-          }));
-          logger_default.info(`[ShortsAgent] Generated ${variants.length} platform variants for: ${plan.title}`);
+      let clipVariants;
+      if (generateVariants !== false) {
+        try {
+          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
+            }));
+            logger_default.info(`[ShortsAgent] Generated ${clipVariants.length} platform variants for: ${plan.title}`);
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          logger_default.warn(`[ShortsAgent] Platform variant generation failed for ${plan.title}: ${message}`);
         }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logger_default.warn(`[ShortsAgent] Platform variant generation failed for ${plan.title}: ${message}`);
+      } else {
+        logger_default.info(`[ShortsAgent] Skipping variant generation for: ${plan.title} (disabled by spec)`);
       }
       let captionedPath;
       try {
@@ -14331,8 +15478,8 @@ Words: ${words}`;
         logger_default.warn(`[ShortsAgent] Caption burning failed for ${plan.title}: ${message}`);
         captionedPath = void 0;
       }
-      if (variants) {
-        const portraitVariants = variants.filter((v) => v.aspectRatio === "9:16");
+      if (clipVariants) {
+        const portraitVariants = clipVariants.filter((v) => v.aspectRatio === "9:16");
         if (portraitVariants.length > 0) {
           try {
             const hookText = plan.hook ?? plan.title;
@@ -14350,7 +15497,7 @@ Words: ${words}`;
             logger_default.warn(`[ShortsAgent] Portrait caption burning failed for ${plan.title}: ${message}`);
           }
         }
-        const nonPortraitVariants = variants.filter((v) => v.aspectRatio !== "9:16");
+        const nonPortraitVariants = clipVariants.filter((v) => v.aspectRatio !== "9:16");
         for (const variant of nonPortraitVariants) {
           try {
             const variantAssContent = segments.length === 1 ? generateStyledASSForSegment(transcript, segments[0].start, segments[0].end) : generateStyledASSForComposite(transcript, segments);
@@ -14401,7 +15548,7 @@ Words: ${words}`;
         description: plan.description,
         tags: plan.tags,
         hook: plan.hook,
-        variants,
+        variants: clipVariants,
         hookType: plan.hookType,
         emotionalTrigger: plan.emotionalTrigger,
         viralScore: plan.viralScore,
@@ -14424,7 +15571,15 @@ init_videoOperations();
 init_fileSystem();
 init_paths();
 init_configLogger();
-var SYSTEM_PROMPT3 = `You are a medium-form video content strategist. Your job is to analyze a video transcript with word-level timestamps and extract the **most valuable, engaging 1-3 minute segments** as standalone medium-form clips.
+function buildMediumSystemPrompt(clipConfig) {
+  const minDuration = clipConfig?.duration?.min ?? 60;
+  const maxDuration = clipConfig?.duration?.max ?? 180;
+  const minViralScore = clipConfig?.minViralScore ?? 10;
+  const maxClips = clipConfig?.maxClips ?? 5;
+  const minMinutes = Math.floor(minDuration / 60);
+  const maxMinutes = Math.ceil(maxDuration / 60);
+  const durationLabel = `${minMinutes}-${maxMinutes} minute`;
+  return `You are a medium-form video content strategist. Your job is to analyze a video transcript with word-level timestamps and extract the **most valuable, engaging ${minMinutes}-${maxMinutes} minute segments** as standalone medium-form clips.
 
 ## Core Philosophy: Value Density Over Coverage
 
@@ -14441,7 +15596,7 @@ Design every clip to maximize saves and shares.
 ## Your workflow
 1. Read the transcript and note the total duration.
 2. Work through the transcript **section by section** (roughly 5-8 minute chunks). For each chunk, identify segments with genuine standalone value.
-3. For each potential clip, score it using the Viral Score Framework (see below). **Only extract clips scoring 10 or higher.**
+3. For each potential clip, score it using the Viral Score Framework (see below). **Only extract clips scoring ${minViralScore} or higher.**
 4. Call **add_medium_clips** for each batch of clips you find. You can call it as many times as needed.
 5. After your first pass, call **review_medium_clips** to see everything you've planned so far.
 6. Review critically: Does each clip deliver clear, standalone value? Would someone save it? Could segments be combined into something stronger?
@@ -14456,7 +15611,7 @@ Viral Score = (Hook Strength \xD7 3) + (Emotional Intensity \xD7 2) +
               (Replay Potential \xD7 2)
 
 Maximum score: 60  \u2192  Normalized to 1-20 scale (divide by 3)
-Minimum to extract: 10/20 (higher bar than shorts \u2014 medium clips cost more to produce)
+Minimum to extract: ${minViralScore}/20 (higher bar than shorts \u2014 medium clips cost more to produce)
 \`\`\`
 
 | Factor | 1 (Weak) | 3 (Moderate) | 5 (Strong) |
@@ -14535,10 +15690,10 @@ Identify the PRIMARY emotion driving engagement:
 
 ## Duration optimization
 
-- **Sweet spot**: 60-120 seconds (1-2 minutes)
-- **Maximum**: 180 seconds \u2014 only if retention quality is exceptional
-- **Under 60 seconds**: Too short for medium format \u2014 should be a short instead
-- **Over 120 seconds**: Requires multiple micro-hooks and exceptional pacing
+- **Sweet spot**: ${minDuration}-${Math.min(maxDuration, 120)} seconds (${minMinutes}-${Math.min(maxMinutes, 2)} minutes)
+- **Maximum**: ${maxDuration} seconds \u2014 only if retention quality is exceptional
+- **Under ${minDuration} seconds**: Too short for medium format \u2014 should be a short instead
+- **Over ${Math.min(maxDuration, 120)} seconds**: Requires multiple micro-hooks and exceptional pacing
 
 ## Differences from shorts
 
@@ -14560,7 +15715,7 @@ For compilations, segments must be in chronological order.
 
 ## Rules
 
-1. Each clip must be 60-180 seconds total duration.
+1. Each clip must be ${minDuration}-${maxDuration} seconds total duration.
 2. Timestamps must align to word boundaries from the transcript.
 3. Prefer natural sentence and paragraph boundaries for clean entry/exit points.
 4. Each clip must be self-contained \u2014 a viewer with no other context should get value.
@@ -14568,7 +15723,7 @@ For compilations, segments must be in chronological order.
 6. For compilations, specify segments in **chronological order**.
 7. Tags should be lowercase, no hashes, 3-6 per clip.
 8. A 1-second buffer is automatically added around each segment boundary.
-9. **Minimum viral score of 10/20 to extract.** Medium clips cost more to produce \u2014 quality bar is higher.
+9. **Minimum viral score of ${minViralScore}/20 to extract.** Medium clips cost more to produce \u2014 quality bar is higher.
 10. Every clip MUST have hook, hookType, emotionalTrigger, viralScore, narrativeStructure, clipType, saveReason, and microHooks.
 11. Avoid significant overlap with content that would work better as a short.
 
@@ -14576,7 +15731,7 @@ For compilations, segments must be in chronological order.
 
 Before adding a clip, ask yourself: **"Would I bookmark this to come back to later?"**
 - If YES \u2192 strong clip, add it
-- If "it's informative but not reference-worthy" \u2192 score it honestly and only keep if \u226510
+- If "it's informative but not reference-worthy" \u2192 score it honestly and only keep if \u2265${minViralScore}
 - If NO \u2192 drop it or consider if it works better as a short
 
 ## Using Clip Direction
@@ -14585,6 +15740,8 @@ You may receive AI-generated clip direction with suggested medium clips. Use the
 - Feel free to adjust timestamps, combine suggestions, or ignore ones that don't work
 - You may also find good clips NOT in the suggestions \u2014 always analyze the full transcript
 - Pay special attention to suggested hooks and topic arcs \u2014 they come from multimodal analysis`;
+}
+var SYSTEM_PROMPT3 = buildMediumSystemPrompt();
 var ADD_MEDIUM_CLIPS_SCHEMA = {
   type: "object",
   properties: {
@@ -14742,20 +15899,26 @@ Review critically:
     return this.isFinalized;
   }
 };
-async function generateMediumClips(video, transcript, model, clipDirection, ideas) {
-  const systemPrompt = SYSTEM_PROMPT3 + (ideas?.length ? buildIdeaContext(ideas) : "");
+async function generateMediumClips(video, transcript, model, clipDirection, ideas, clipConfig) {
+  const basePrompt = clipConfig ? buildMediumSystemPrompt(clipConfig) : SYSTEM_PROMPT3;
+  const systemPrompt = basePrompt + (ideas?.length ? buildIdeaContext(ideas) : "");
   const agent = new MediumVideoAgent(systemPrompt, model);
   const transcriptLines = transcript.segments.map((seg) => {
     const words = seg.words.map((w) => `[${w.start.toFixed(2)}-${w.end.toFixed(2)}] ${w.word}`).join(" ");
     return `[${seg.start.toFixed(2)}s \u2013 ${seg.end.toFixed(2)}s] ${seg.text}
 Words: ${words}`;
   });
+  const minDuration = clipConfig?.duration?.min ?? 60;
+  const maxDuration = clipConfig?.duration?.max ?? 180;
+  const minViralScore = clipConfig?.minViralScore ?? 10;
+  const minMinutes = Math.floor(minDuration / 60);
+  const maxMinutes = Math.ceil(maxDuration / 60);
   const promptParts = [
-    `Analyze the following transcript (${transcript.duration.toFixed(0)}s total) and find the most valuable segments for medium-length clips (1-3 minutes each).
+    `Analyze the following transcript (${transcript.duration.toFixed(0)}s total) and find the most valuable segments for medium-length clips (${minMinutes}-${maxMinutes} minutes each).
 `,
     `Video: ${video.filename}`,
     `Duration: ${transcript.duration.toFixed(1)}s`,
-    `Focus on value density over coverage \u2014 only extract clips scoring 10+ on the viral score framework. Every clip must have hook, hookType, emotionalTrigger, viralScore, narrativeStructure, clipType, saveReason, and microHooks.
+    `Focus on value density over coverage \u2014 only extract clips scoring ${minViralScore}+ on the viral score framework. Every clip must have hook, hookType, emotionalTrigger, viralScore, narrativeStructure, clipType, saveReason, and microHooks.
 `,
     "--- TRANSCRIPT ---\n",
     transcriptLines.join("\n\n"),
@@ -15640,17 +16803,27 @@ init_paths();
 init_BaseAgent();
 init_configLogger();
 init_environment();
-init_types();
-var SYSTEM_PROMPT5 = `You are a viral social-media content strategist.
-Given a video transcript and summary you MUST generate one post for each of the 5 platforms listed below.
-Each post must match the platform's tone, format, and constraints exactly.
-
-Platform guidelines:
+init_types2();
+var PER_PLATFORM_GUIDELINES = `Platform guidelines:
 1. **TikTok** \u2013 Casual, hook-driven, trending hashtags, 150 chars max, emoji-heavy.
 2. **YouTube** \u2013 Descriptive, SEO-optimized title + description, relevant tags.
 3. **Instagram** \u2013 Visual storytelling, emoji-rich, 30 hashtags max, engaging caption.
 4. **LinkedIn** \u2013 Professional, thought-leadership, industry insights, 1-3 hashtags.
-5. **X (Twitter)** \u2013 Concise, punchy, 280 chars max, 2-5 hashtags, thread-ready.
+5. **X (Twitter)** \u2013 Concise, punchy, 280 chars max, 2-5 hashtags, thread-ready.`;
+var UNIFIED_TONE_GUIDELINES = `Platform guidelines:
+For all platforms, use the same professional but approachable tone. Keep posts concise, informative, and authentic. Use the same core message \u2014 adapt only for platform-specific formatting constraints (character limits, hashtag placement).
+1. **TikTok** \u2013 150 chars max, include relevant hashtags.
+2. **YouTube** \u2013 SEO-optimized title + description, relevant tags.
+3. **Instagram** \u2013 30 hashtags max, engaging caption.
+4. **LinkedIn** \u2013 1-3 hashtags, professional framing.
+5. **X (Twitter)** \u2013 280 chars max, 2-5 hashtags.`;
+function buildSocialMediaSystemPrompt(toneStrategy) {
+  const platformGuidelines = toneStrategy === "unified" ? UNIFIED_TONE_GUIDELINES : PER_PLATFORM_GUIDELINES;
+  return `You are a viral social-media content strategist.
+Given a video transcript and summary you MUST generate one post for each of the 5 platforms listed below.
+Each post must match the platform's format and constraints exactly.
+
+${platformGuidelines}
 
 IMPORTANT \u2013 Content format:
 The "content" field you provide must be the FINAL, ready-to-post text that can be directly copied and pasted onto the platform. Do NOT use markdown headers, bullet points, or any formatting inside the content. Include hashtags inline at the end of the post text where appropriate. The content is saved as-is for direct posting.
@@ -15662,6 +16835,8 @@ Workflow:
 
 Include relevant links in posts when search results provide them.
 Always call "create_posts" exactly once with all 5 platform posts.`;
+}
+var SYSTEM_PROMPT5 = buildSocialMediaSystemPrompt();
 var SocialMediaAgent = class extends BaseAgent {
   collectedPosts = [];
   constructor(systemPrompt = SYSTEM_PROMPT5, model) {
@@ -15842,8 +17017,9 @@ async function generateShortPosts(video, short, transcript, model, summary) {
     await agent.destroy();
   }
 }
-async function generateSocialPosts(video, transcript, summary, outputDir, model, ideas) {
-  const systemPrompt = SYSTEM_PROMPT5 + (ideas?.length ? buildIdeaContextForPosts(ideas) : "");
+async function generateSocialPosts(video, transcript, summary, outputDir, model, ideas, toneStrategy) {
+  const basePrompt = toneStrategy ? buildSocialMediaSystemPrompt(toneStrategy) : SYSTEM_PROMPT5;
+  const systemPrompt = basePrompt + (ideas?.length ? buildIdeaContextForPosts(ideas) : "");
   const agent = new SocialMediaAgent(systemPrompt, model);
   try {
     const userMessage = [
@@ -16131,11 +17307,11 @@ async function markFailed(slug, error) {
 init_fileSystem();
 init_paths();
 init_configLogger();
-init_types();
-init_types();
+init_types2();
+init_types2();
 
 // src/L3-services/socialPosting/platformContentStrategy.ts
-init_types();
+init_types2();
 var CONTENT_MATRIX = {
   ["youtube" /* YouTube */]: {
     video: { captions: true, variantKey: null },
@@ -16169,10 +17345,10 @@ function platformAcceptsMedia(platform, clipType) {
 
 // src/L3-services/queueBuilder/queueBuilder.ts
 init_postStore();
-function resolveShortMedia(clip, platform) {
+function resolveShortMedia(clip, platform, variantsEnabled) {
   const rule = getMediaRule(platform, "short");
   if (!rule) return null;
-  if (rule.variantKey && clip.variants?.length) {
+  if (variantsEnabled !== false && rule.variantKey && clip.variants?.length) {
     const match = clip.variants.find((v) => v.platform === rule.variantKey);
     if (match) return match.path;
     if (platform === "instagram" /* Instagram */) {
@@ -16219,7 +17395,7 @@ async function parsePostFrontmatter(postPath) {
 function stripFrontmatter(content) {
   return content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "").trim();
 }
-async function buildPublishQueue(video, shorts, mediumClips, socialPosts, captionedVideoPath, ideaIds) {
+async function buildPublishQueue(video, shorts, mediumClips, socialPosts, captionedVideoPath, ideaIds, variantsEnabled) {
   const result = { itemsCreated: 0, itemsSkipped: 0, errors: [] };
   for (const post of socialPosts) {
     try {
@@ -16238,7 +17414,7 @@ async function buildPublishQueue(video, shorts, mediumClips, socialPosts, captio
           clipSlug = short.slug;
           clipType = "short";
           sourceClip = dirname(short.outputPath);
-          mediaPath = resolveShortMedia(short, post.platform);
+          mediaPath = resolveShortMedia(short, post.platform, variantsEnabled);
           thumbnailPath = short.thumbnailPath ?? null;
           clipIdeaIssueNumber = short.ideaIssueNumber;
         } else if (medium) {
@@ -16991,7 +18167,7 @@ async function enhanceVideo(videoPath, transcript, video) {
 // src/L5-assets/MainVideoAsset.ts
 init_environment();
 init_configLogger();
-init_types();
+init_types2();
 var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
   sourcePath;
   videoDir;
@@ -17000,6 +18176,16 @@ var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
   _ideas = [];
   /** Per-clip idea assignments from idea discovery (clipId → ideaIssueNumber) */
   _clipIdeaMap = /* @__PURE__ */ new Map();
+  /** Pipeline spec controlling clip and platform configuration */
+  _spec;
+  /** Set the pipeline spec for configuring agent behavior */
+  setSpec(spec) {
+    this._spec = spec;
+  }
+  /** Get the pipeline spec */
+  get spec() {
+    return this._spec;
+  }
   /** Set ideas for editorial direction */
   setIdeas(ideas) {
     this._ideas = ideas;
@@ -17549,7 +18735,18 @@ var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
   async generateShortsInternal() {
     const transcript = await this.getTranscript();
     const videoFile = await this.toVideoFile();
-    const shorts = await generateShorts(videoFile, transcript);
+    const shortsConfig = this._spec?.clips.shorts;
+    const shouldGenerateVariants = this._spec?.distribution.platforms.variants;
+    const shorts = await generateShorts(
+      videoFile,
+      transcript,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      shortsConfig,
+      shouldGenerateVariants
+    );
     logger_default.info(`Generated ${shorts.length} short clips`);
     return shorts;
   }
@@ -17581,7 +18778,15 @@ var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
   async generateMediumClipsInternal() {
     const transcript = await this.getTranscript();
     const videoFile = await this.toVideoFile();
-    const clips = await generateMediumClips(videoFile, transcript);
+    const mediumConfig = this._spec?.clips.medium;
+    const clips = await generateMediumClips(
+      videoFile,
+      transcript,
+      void 0,
+      void 0,
+      void 0,
+      mediumConfig
+    );
     logger_default.info(`Generated ${clips.length} medium clips for ${this.slug}`);
     return clips;
   }
@@ -17604,7 +18809,16 @@ var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
     const summary = await this.getSummary();
     const video = await this.toVideoFile();
     await ensureDirectory(this.socialPostsDir);
-    const posts = await generateSocialPosts(video, transcript, summary, this.socialPostsDir);
+    const toneStrategy = this._spec?.distribution.platforms.toneStrategy;
+    const posts = await generateSocialPosts(
+      video,
+      transcript,
+      summary,
+      this.socialPostsDir,
+      void 0,
+      void 0,
+      toneStrategy
+    );
     await this.markSocialPostsComplete();
     return posts;
   }
@@ -17978,7 +19192,8 @@ var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
   async buildPublishQueueData(shorts, mediumClips, socialPosts, captionedVideoPath) {
     const video = await this.toVideoFile();
     const ideaIds = this._ideas.length > 0 ? this._ideas.map((idea) => String(idea.issueNumber)) : void 0;
-    return buildPublishQueue2(video, shorts, mediumClips, socialPosts, captionedVideoPath, ideaIds);
+    const variantsEnabled = this._spec?.distribution.platforms.variants;
+    return buildPublishQueue2(video, shorts, mediumClips, socialPosts, captionedVideoPath, ideaIds, variantsEnabled);
   }
   /**
    * Build the publish queue (simplified wrapper for pipeline).
@@ -18199,6 +19414,7 @@ async function executeRealignPlan(plan, onProgress) {
 }
 
 // src/L4-agents/ScheduleAgent.ts
+init_queueMapping();
 init_configLogger();
 var TOOL_LABELS = {
   list_posts: "\u{1F4CB} Listing posts",
@@ -18314,14 +19530,16 @@ var ScheduleAgent = class extends BaseAgent {
       },
       {
         name: "reschedule_post",
-        description: "Move a post to a new scheduled time.",
+        description: "Move a post to a new scheduled time, or re-queue it to get the next available queue slot. If scheduledFor is provided, the post is moved to that exact time. If omitted, the post is re-queued using the Late API queue for its platform/clipType.",
         parameters: {
           type: "object",
           properties: {
             postId: { type: "string", description: "The Late post ID" },
-            scheduledFor: { type: "string", description: "New scheduled datetime (ISO 8601)" }
+            scheduledFor: { type: "string", description: "New scheduled datetime (ISO 8601). Omit to re-queue using the platform queue." },
+            platform: { type: "string", description: "Platform for queue lookup when re-queuing without scheduledFor" },
+            clipType: { type: "string", description: "Clip type for queue lookup: short, medium-clip, video" }
           },
-          required: ["postId", "scheduledFor"]
+          required: ["postId"]
         },
         handler: async (args) => this.handleToolCall("reschedule_post", args)
       },
@@ -18511,9 +19729,23 @@ var ScheduleAgent = class extends BaseAgent {
     try {
       const postId = args.postId;
       const scheduledFor = args.scheduledFor;
+      const platform = args.platform;
+      const clipType = args.clipType;
       const client = createLateApiClient();
-      const updated = await client.schedulePost(postId, scheduledFor);
-      return { success: true, postId, scheduledFor: updated.scheduledFor };
+      if (scheduledFor) {
+        const updated = await client.schedulePost(postId, scheduledFor);
+        return { success: true, postId, scheduledFor: updated.scheduledFor, source: "manual" };
+      }
+      if (platform) {
+        const normalized = platform === "twitter" ? "x" : platform;
+        const queueId = await getQueueId(normalized, clipType ?? "short");
+        if (queueId) {
+          const profileId = await getProfileId();
+          const updated = await client.updatePost(postId, { queuedFromProfile: profileId, queueId });
+          return { success: true, postId, scheduledFor: updated.scheduledFor, source: "queue", queueId };
+        }
+      }
+      return { error: "Either scheduledFor or platform must be provided. Provide scheduledFor for a specific time, or platform to re-queue." };
     } catch (err) {
       logger_default.error("reschedule_post failed", { error: err });
       return { error: `Failed to reschedule post: ${err.message}` };
@@ -18535,9 +19767,22 @@ var ScheduleAgent = class extends BaseAgent {
       const platform = args.platform;
       const clipType = args.clipType;
       const normalized = platform === "twitter" ? "x" : platform;
+      const queueId = await getQueueId(normalized, clipType ?? "short");
+      if (queueId) {
+        try {
+          const profileId = await getProfileId();
+          const client = createLateApiClient();
+          const preview = await client.previewQueue(profileId, queueId, 1);
+          if (preview.slots?.length > 0) {
+            return { platform: normalized, clipType: clipType ?? "any", nextSlot: preview.slots[0], source: "queue", queueId };
+          }
+        } catch (err) {
+          logger_default.warn("Queue preview failed, falling back to local calculation", { queueId, error: err });
+        }
+      }
       const slot = await findNextSlot(normalized, clipType);
       if (!slot) return { error: `No available slot found for ${normalized}` };
-      return { platform: normalized, clipType: clipType ?? "any", nextSlot: slot };
+      return { platform: normalized, clipType: clipType ?? "any", nextSlot: slot, source: "local" };
     } catch (err) {
       logger_default.error("find_next_slot failed", { error: err });
       return { error: `Failed to find next slot: ${err.message}` };
@@ -18610,6 +19855,7 @@ var ScheduleAgent = class extends BaseAgent {
       skipped: plan.skipped,
       unmatched: plan.unmatched
     };
+    logger_default.info("Queue-based reshuffle is also available via `vidpipe sync-queues --reshuffle`");
     if (dryRun) {
       job.status = "completed";
       job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -18651,7 +19897,7 @@ init_modelConfig();
 init_configLogger();
 init_ideaService();
 init_providerFactory();
-init_types();
+init_types2();
 init_BaseAgent();
 var BASE_SYSTEM_PROMPT = `You are a content strategist for a tech content creator. Your role is to research trending topics, analyze what's working, and generate compelling video ideas grounded in real-world data.
 
@@ -20071,7 +21317,7 @@ function createIdeaDiscoveryAgent(...args) {
 }
 
 // src/L6-pipeline/pipeline.ts
-init_types();
+init_types2();
 async function runStage(stageName, fn, stageResults) {
   const start = Date.now();
   if (progressEmitter.isEnabled()) {
@@ -20125,11 +21371,22 @@ async function runStage(stageName, fn, stageResults) {
     return void 0;
   }
 }
-async function processVideo(videoPath, ideas, publishBy) {
+async function processVideo(videoPath, ideas, publishBy, spec) {
   const pipelineStart = Date.now();
   const stageResults = [];
   const cfg = getConfig();
   let stagesSkipped = 0;
+  const skipFlags = {
+    SKIP_SILENCE_REMOVAL: cfg.SKIP_SILENCE_REMOVAL,
+    SKIP_VISUAL_ENHANCEMENT: cfg.SKIP_VISUAL_ENHANCEMENT,
+    SKIP_CAPTIONS: cfg.SKIP_CAPTIONS,
+    SKIP_INTRO_OUTRO: cfg.SKIP_INTRO_OUTRO,
+    SKIP_SHORTS: cfg.SKIP_SHORTS,
+    SKIP_MEDIUM_CLIPS: cfg.SKIP_MEDIUM_CLIPS,
+    SKIP_SOCIAL: cfg.SKIP_SOCIAL,
+    SKIP_SOCIAL_PUBLISH: cfg.SKIP_SOCIAL_PUBLISH
+  };
+  const effectiveSpec = spec ? applySkipFlags(spec, skipFlags) : resolveFromFlags(skipFlags);
   costTracker3.reset();
   function trackStage(stage, fn) {
     costTracker3.setStage(stage);
@@ -20194,43 +21451,44 @@ async function processVideo(videoPath, ideas, publishBy) {
     asset.setIdeas(ideas);
     logger_default.info(`Pipeline using ${ideas.length} idea(s) for editorial direction`);
   }
+  asset.setSpec(effectiveSpec);
   try {
     const transcript = await trackStage("transcription" /* Transcription */, () => asset.getTranscript());
     let editedVideoPath;
-    if (!cfg.SKIP_SILENCE_REMOVAL) {
+    if (effectiveSpec.processing.silenceRemoval) {
       editedVideoPath = await trackStage("silence-removal" /* SilenceRemoval */, () => asset.getEditedVideo());
     } else {
-      skipStage("silence-removal" /* SilenceRemoval */, "SKIP_SILENCE_REMOVAL");
+      skipStage("silence-removal" /* SilenceRemoval */, "SPEC_DISABLED");
     }
     let enhancedVideoPath;
-    if (!cfg.SKIP_VISUAL_ENHANCEMENT) {
+    if (effectiveSpec.processing.visualEnhancement) {
       enhancedVideoPath = await trackStage("visual-enhancement" /* VisualEnhancement */, () => asset.getEnhancedVideo());
     } else {
-      skipStage("visual-enhancement" /* VisualEnhancement */, "SKIP_VISUAL_ENHANCEMENT");
+      skipStage("visual-enhancement" /* VisualEnhancement */, "SPEC_DISABLED");
     }
     let captions;
-    if (!cfg.SKIP_CAPTIONS) {
+    if (effectiveSpec.processing.captions) {
       captions = await trackStage("captions" /* Captions */, () => asset.getCaptions());
     } else {
-      skipStage("captions" /* Captions */, "SKIP_CAPTIONS");
+      skipStage("captions" /* Captions */, "SPEC_DISABLED");
     }
     let captionedVideoPath;
-    if (!cfg.SKIP_CAPTIONS) {
+    if (effectiveSpec.processing.captions) {
       captionedVideoPath = await trackStage("caption-burn" /* CaptionBurn */, () => asset.getCaptionedVideo());
     } else {
-      skipStage("caption-burn" /* CaptionBurn */, "SKIP_CAPTIONS");
+      skipStage("caption-burn" /* CaptionBurn */, "SPEC_DISABLED");
     }
     let introOutroVideoPath;
-    if (!cfg.SKIP_INTRO_OUTRO) {
+    if (effectiveSpec.processing.introOutro) {
       introOutroVideoPath = await trackStage("intro-outro" /* IntroOutro */, () => asset.getIntroOutroVideo());
     } else {
-      skipStage("intro-outro" /* IntroOutro */, "SKIP_INTRO_OUTRO");
+      skipStage("intro-outro" /* IntroOutro */, "SPEC_DISABLED");
     }
     let shorts = [];
-    if (!cfg.SKIP_SHORTS) {
+    if (effectiveSpec.clips.shorts.enabled) {
       const shortAssets = await trackStage("shorts" /* Shorts */, async () => {
         const assets = await asset.getShorts();
-        if (!cfg.SKIP_INTRO_OUTRO) {
+        if (effectiveSpec.processing.introOutro) {
           for (const shortAsset of assets) {
             const introOutroPath = await shortAsset.getIntroOutroVideo();
             if (introOutroPath !== shortAsset.clip.outputPath) {
@@ -20257,13 +21515,13 @@ async function processVideo(videoPath, ideas, publishBy) {
         }
       }
     } else {
-      skipStage("shorts" /* Shorts */, "SKIP_SHORTS");
+      skipStage("shorts" /* Shorts */, "SPEC_DISABLED");
     }
     let mediumClips = [];
-    if (!cfg.SKIP_MEDIUM_CLIPS) {
+    if (effectiveSpec.clips.medium.enabled) {
       const mediumAssets = await trackStage("medium-clips" /* MediumClips */, async () => {
         const assets = await asset.getMediumClips();
-        if (!cfg.SKIP_INTRO_OUTRO) {
+        if (effectiveSpec.processing.introOutro) {
           for (const clipAsset of assets) {
             const introOutroPath = await clipAsset.getIntroOutroVideo();
             if (introOutroPath !== clipAsset.clip.outputPath) {
@@ -20283,7 +21541,7 @@ async function processVideo(videoPath, ideas, publishBy) {
         }
       }
     } else {
-      skipStage("medium-clips" /* MediumClips */, "SKIP_MEDIUM_CLIPS");
+      skipStage("medium-clips" /* MediumClips */, "SPEC_DISABLED");
     }
     const chapters = await trackStage("chapters" /* Chapters */, () => asset.getChapters());
     const summary = await trackStage("summary" /* Summary */, () => asset.getSummary());
@@ -20302,7 +21560,7 @@ async function processVideo(videoPath, ideas, publishBy) {
       skipStage("idea-discovery" /* IdeaDiscovery */, "NO_CLIPS");
     }
     let socialPosts = [];
-    if (!cfg.SKIP_SOCIAL) {
+    if (effectiveSpec.distribution.enabled) {
       const mainPosts = await trackStage("social-media" /* SocialMedia */, () => asset.getSocialPosts()) ?? [];
       socialPosts.push(...mainPosts);
       if (shorts.length > 0) {
@@ -20326,14 +21584,14 @@ async function processVideo(videoPath, ideas, publishBy) {
         skipStage("medium-clip-posts" /* MediumClipPosts */, "NO_MEDIUM_CLIPS");
       }
     } else {
-      skipStage("social-media" /* SocialMedia */, "SKIP_SOCIAL");
-      skipStage("short-posts" /* ShortPosts */, "SKIP_SOCIAL");
-      skipStage("medium-clip-posts" /* MediumClipPosts */, "SKIP_SOCIAL");
+      skipStage("social-media" /* SocialMedia */, "SPEC_DISABLED");
+      skipStage("short-posts" /* ShortPosts */, "SPEC_DISABLED");
+      skipStage("medium-clip-posts" /* MediumClipPosts */, "SPEC_DISABLED");
     }
-    if (!cfg.SKIP_SOCIAL_PUBLISH && socialPosts.length > 0) {
+    if (effectiveSpec.distribution.publish && socialPosts.length > 0) {
       await trackStage("queue-build" /* QueueBuild */, () => asset.buildQueue(shorts, mediumClips, socialPosts, introOutroVideoPath ?? captionedVideoPath));
-    } else if (cfg.SKIP_SOCIAL_PUBLISH) {
-      skipStage("queue-build" /* QueueBuild */, "SKIP_SOCIAL_PUBLISH");
+    } else if (!effectiveSpec.distribution.publish) {
+      skipStage("queue-build" /* QueueBuild */, "SPEC_DISABLED");
     } else {
       skipStage("queue-build" /* QueueBuild */, "NO_SOCIAL_POSTS");
     }
@@ -20425,13 +21683,13 @@ function generateCostMarkdown(report) {
   }
   return md;
 }
-async function processVideoSafe(videoPath, ideas, publishBy) {
+async function processVideoSafe(videoPath, ideas, publishBy, spec) {
   const filename = basename(videoPath);
   const slug = filename.replace(/\.(mp4|mov|webm|avi|mkv)$/i, "");
   await markPending3(slug, videoPath);
   await markProcessing3(slug);
   try {
-    const result = await processVideo(videoPath, ideas, publishBy);
+    const result = await processVideo(videoPath, ideas, publishBy, spec);
     await markCompleted3(slug);
     return result;
   } catch (err) {
@@ -20909,6 +22167,7 @@ function getPlatformIcon(platform) {
 
 // src/L7-app/commands/realign.ts
 init_environment();
+init_configLogger();
 function formatDate(iso) {
   const d = new Date(iso);
   return d.toLocaleDateString("en-US", {
@@ -20938,6 +22197,23 @@ var PLATFORM_ICON = {
 async function runRealign(options = {}) {
   initConfig();
   console.log("\n\u{1F504} Realign Late Posts\n");
+  if (options.queue) {
+    console.log("  Using Late API queue reshuffle mode");
+    if (options.dryRun) {
+      console.log("  Mode: DRY RUN (no changes will be made)\n");
+    }
+    const { syncQueuesToLate: syncQueuesToLate2 } = await Promise.resolve().then(() => (init_queueSync(), queueSync_exports));
+    const result2 = await syncQueuesToLate2({ reshuffle: true, dryRun: options.dryRun });
+    logger_default.info(`Queue reshuffle complete: ${result2.updated.length} queues reshuffled`);
+    console.log(`  \u2705 Queue reshuffle complete: ${result2.updated.length} queues reshuffled`);
+    if (result2.errors.length > 0) {
+      for (const err of result2.errors) {
+        console.log(`  \u274C ${err.queueName}: ${err.error}`);
+      }
+    }
+    console.log();
+    return;
+  }
   if (options.platform) {
     console.log(`  Platform filter: ${options.platform}`);
   }
@@ -21356,8 +22632,8 @@ async function discoverIdeas(input) {
 }
 
 // src/L7-app/commands/ideate.ts
-init_types();
-var VALID_PLATFORMS = new Set(Object.values(Platform));
+init_types2();
+var VALID_PLATFORMS2 = new Set(Object.values(Platform));
 async function runIdeate(options = {}) {
   initConfig();
   if (options.add) {
@@ -21466,8 +22742,8 @@ function parsePlatforms(value) {
   const platforms = [];
   for (const name of names) {
     const lower = name.toLowerCase();
-    if (!VALID_PLATFORMS.has(lower)) {
-      throw new Error(`Invalid platform "${name}". Valid platforms: ${[...VALID_PLATFORMS].join(", ")}`);
+    if (!VALID_PLATFORMS2.has(lower)) {
+      throw new Error(`Invalid platform "${name}". Valid platforms: ${[...VALID_PLATFORMS2].join(", ")}`);
     }
     platforms.push(lower);
   }
@@ -21760,7 +23036,7 @@ init_postStore();
 init_fileSystem();
 init_brand();
 init_paths();
-init_types();
+init_types2();
 init_configLogger();
 async function runDiscoverIdeas(options) {
   const pendingItems = await getPendingItems();
@@ -22702,8 +23978,8 @@ function buildPromptFromContext(ctx, contentType) {
 // src/L7-app/commands/ideaUpdate.ts
 init_environment();
 init_ideaService();
-init_types();
-var VALID_PLATFORMS2 = new Set(Object.values(Platform));
+init_types2();
+var VALID_PLATFORMS3 = new Set(Object.values(Platform));
 var VALID_STATUSES = /* @__PURE__ */ new Set(["draft", "ready", "recorded", "published"]);
 var VALID_URGENCIES = /* @__PURE__ */ new Map([
   ["hot", 3],
@@ -22717,7 +23993,7 @@ var VALID_URGENCIES = /* @__PURE__ */ new Map([
 ]);
 function parsePlatforms2(raw) {
   if (!raw) return void 0;
-  return raw.split(",").map((p) => p.trim().toLowerCase()).filter((p) => VALID_PLATFORMS2.has(p));
+  return raw.split(",").map((p) => p.trim().toLowerCase()).filter((p) => VALID_PLATFORMS3.has(p));
 }
 function parseCommaSeparated2(raw) {
   if (!raw) return void 0;
@@ -22887,8 +24163,9 @@ init_paths();
 init_postStore();
 init_ideaService2();
 init_scheduler();
-init_types();
+init_types2();
 init_configLogger();
+init_queueMapping();
 
 // src/L7-app/review/approvalQueue.ts
 init_fileSystem();
@@ -22898,21 +24175,21 @@ init_scheduler();
 init_scheduleConfig();
 
 // src/L3-services/socialPosting/accountMapping.ts
-init_types();
+init_types2();
 init_lateApi();
 init_configLogger();
 init_fileSystem();
 init_paths();
-var CACHE_FILE = ".vidpipe-cache.json";
-var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-var memoryCache = null;
+var CACHE_FILE2 = ".vidpipe-cache.json";
+var CACHE_TTL_MS2 = 24 * 60 * 60 * 1e3;
+var memoryCache2 = null;
 function toLatePlatform2(platform) {
   return platform === "x" /* X */ ? "twitter" : platform;
 }
-function cachePath() {
-  return join(process.cwd(), CACHE_FILE);
+function cachePath2() {
+  return join(process.cwd(), CACHE_FILE2);
 }
-function isCacheValid(cache2) {
+function isCacheValid2(cache2) {
   const fetchedAtTime = new Date(cache2.fetchedAt).getTime();
   if (Number.isNaN(fetchedAtTime)) {
     logger_default.warn("Invalid fetchedAt in account cache; treating as stale", {
@@ -22921,13 +24198,13 @@ function isCacheValid(cache2) {
     return false;
   }
   const age = Date.now() - fetchedAtTime;
-  return age < CACHE_TTL_MS;
+  return age < CACHE_TTL_MS2;
 }
-async function readFileCache() {
+async function readFileCache2() {
   try {
-    const raw = await readTextFile(cachePath());
+    const raw = await readTextFile(cachePath2());
     const cache2 = JSON.parse(raw);
-    if (cache2.accounts && cache2.fetchedAt && isCacheValid(cache2)) {
+    if (cache2.accounts && cache2.fetchedAt && isCacheValid2(cache2)) {
       return cache2;
     }
     return null;
@@ -22935,7 +24212,7 @@ async function readFileCache() {
     return null;
   }
 }
-async function writeFileCache(cache2) {
+async function writeFileCache2(cache2) {
   try {
     if (!cache2 || typeof cache2 !== "object" || !cache2.accounts || !cache2.fetchedAt) {
       logger_default.warn("Invalid cache structure, skipping write");
@@ -22951,7 +24228,7 @@ async function writeFileCache(cache2) {
         return;
       }
     }
-    const resolvedCachePath = resolve(cachePath());
+    const resolvedCachePath = resolve(cachePath2());
     if (!resolvedCachePath.startsWith(resolve(process.cwd()) + sep)) {
       throw new Error("Cache path outside working directory");
     }
@@ -22960,7 +24237,7 @@ async function writeFileCache(cache2) {
     logger_default.warn("Failed to write account cache file", { error: err });
   }
 }
-async function fetchAndCache() {
+async function fetchAndCache2() {
   const client = new LateApiClient();
   const accounts = await client.listAccounts();
   const mapping = {};
@@ -22973,37 +24250,38 @@ async function fetchAndCache() {
     accounts: mapping,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  memoryCache = cache2;
-  await writeFileCache(cache2);
+  memoryCache2 = cache2;
+  await writeFileCache2(cache2);
   logger_default.info("Refreshed Late account mappings", {
     platforms: Object.keys(mapping)
   });
   return mapping;
 }
-async function ensureMappings() {
-  if (memoryCache && isCacheValid(memoryCache)) {
-    return memoryCache.accounts;
+async function ensureMappings2() {
+  if (memoryCache2 && isCacheValid2(memoryCache2)) {
+    return memoryCache2.accounts;
   }
-  const fileCache = await readFileCache();
+  const fileCache = await readFileCache2();
   if (fileCache) {
-    memoryCache = fileCache;
+    memoryCache2 = fileCache;
     return fileCache.accounts;
   }
   try {
-    return await fetchAndCache();
+    return await fetchAndCache2();
   } catch (err) {
     logger_default.error("Failed to fetch Late account mappings", { error: err });
     return {};
   }
 }
 async function getAccountId(platform) {
-  const mappings = await ensureMappings();
+  const mappings = await ensureMappings2();
   const latePlatform = toLatePlatform2(platform);
   return mappings[latePlatform] ?? null;
 }
 
 // src/L7-app/review/approvalQueue.ts
-init_types();
+init_queueMapping();
+init_types2();
 init_configLogger();
 var queue = [];
 var processing = false;
@@ -23103,10 +24381,21 @@ async function processApprovalBatch(itemIds) {
       }
       const ideaIds = item.metadata.ideaIds;
       const publishBy = publishByMap.get(itemId);
-      const slot = ideaIds?.length ? await findNextSlot(latePlatform, item.metadata.clipType, { ideaIds, publishBy }) : await findNextSlot(latePlatform, item.metadata.clipType);
-      if (!slot) {
-        results.push({ itemId, success: false, error: `No available slot for ${latePlatform}` });
-        continue;
+      const clipType = item.metadata.clipType || "short";
+      const queueId = await getQueueId(latePlatform, clipType);
+      let slot;
+      let useQueue = false;
+      if (queueId) {
+        useQueue = true;
+        logger_default.debug(`Using Late queue ${queueId} for ${latePlatform}/${clipType} (idea priority via batch order)`);
+      } else {
+        logger_default.debug(`No queue for ${latePlatform}/${clipType}, using local slot calculation`);
+        const foundSlot = ideaIds?.length ? await findNextSlot(latePlatform, clipType, { ideaIds, publishBy }) : await findNextSlot(latePlatform, clipType);
+        slot = foundSlot ?? void 0;
+        if (!slot) {
+          results.push({ itemId, success: false, error: `No available slot for ${latePlatform}` });
+          continue;
+        }
       }
       const platform = fromLatePlatform(latePlatform);
       const accountId = item.metadata.accountId || await getAccountId(platform);
@@ -23151,23 +24440,30 @@ async function processApprovalBatch(itemIds) {
         content_preview_confirmed: true,
         express_consent_given: true
       } : void 0;
-      const latePost = await client.createPost({
+      const profileId = useQueue ? await getProfileId() : void 0;
+      const createParams = {
         content: item.postContent,
         platforms: [{ platform: latePlatform, accountId }],
-        scheduledFor: slot,
         timezone: schedConfig.timezone,
         isDraft: false,
         mediaItems,
         platformSpecificData,
         tiktokSettings
-      });
+      };
+      if (useQueue) {
+        createParams.queuedFromProfile = profileId;
+        createParams.queueId = queueId ?? void 0;
+      } else {
+        createParams.scheduledFor = slot;
+      }
+      const latePost = await client.createPost(createParams);
       publishDataMap.set(itemId, {
         latePostId: latePost._id,
-        scheduledFor: slot,
+        scheduledFor: latePost.scheduledFor ?? slot ?? "",
         publishedUrl: void 0,
         accountId
       });
-      results.push({ itemId, success: true, scheduledFor: slot, latePostId: latePost._id });
+      results.push({ itemId, success: true, scheduledFor: latePost.scheduledFor ?? slot, latePostId: latePost._id });
     } catch (itemErr) {
       const itemMsg = itemErr instanceof Error ? itemErr.message : String(itemErr);
       if (itemMsg.includes("429") || itemMsg.includes("Daily post limit")) {
@@ -23197,7 +24493,7 @@ async function processApprovalBatch(itemIds) {
 }
 
 // src/L7-app/review/routes.ts
-var CACHE_TTL_MS2 = 5 * 60 * 1e3;
+var CACHE_TTL_MS3 = 5 * 60 * 1e3;
 var cache = /* @__PURE__ */ new Map();
 function getCached(key) {
   const entry = cache.get(key);
@@ -23205,7 +24501,7 @@ function getCached(key) {
   cache.delete(key);
   return void 0;
 }
-function setCache(key, data, ttl = CACHE_TTL_MS2) {
+function setCache(key, data, ttl = CACHE_TTL_MS3) {
   cache.set(key, { data, expiry: Date.now() + ttl });
 }
 async function getEarliestPublishBy(ideaIds) {
@@ -23374,6 +24670,18 @@ function createRouter() {
     try {
       const normalized = normalizePlatformString(req.params.platform);
       const clipType = typeof req.query.clipType === "string" ? req.query.clipType : void 0;
+      const queueId = await getQueueId(normalized, clipType ?? "short");
+      if (queueId) {
+        try {
+          const profileId = await getProfileId();
+          const client = createLateApiClient();
+          const preview = await client.previewQueue(profileId, queueId, 1);
+          if (preview.slots?.length > 0) {
+            return res.json({ platform: normalized, nextSlot: preview.slots[0], source: "queue" });
+          }
+        } catch {
+        }
+      }
       const slot = await findNextSlot(normalized, clipType);
       res.json({ platform: normalized, nextSlot: slot });
     } catch (err) {
@@ -23545,13 +24853,22 @@ program.command("schedule").description("View the current posting schedule acros
   await runSchedule({ platform: opts.platform });
   process.exit(0);
 });
-program.command("realign").description("Realign all Late scheduled, cancelled, and failed posts to match schedule.json slots").option("--platform <name>", "Filter by platform (tiktok, youtube, instagram, linkedin, twitter)").option("--dry-run", "Preview changes without updating posts").action(async (opts) => {
-  await runRealign({ platform: opts.platform, dryRun: opts.dryRun });
+program.command("realign").description("Realign all Late scheduled, cancelled, and failed posts to match schedule.json slots").option("--platform <name>", "Filter by platform (tiktok, youtube, instagram, linkedin, twitter)").option("--dry-run", "Preview changes without updating posts").option("--queue", "Use Late API queue reshuffle instead of per-post reschedule").action(async (opts) => {
+  await runRealign({ platform: opts.platform, dryRun: opts.dryRun, queue: opts.queue });
   process.exit(0);
 });
-program.command("reschedule").description("Reschedule idea-linked posts for optimal slot placement, displacing non-idea content").option("--dry-run", "Preview changes without updating posts").action(async (opts) => {
+program.command("reschedule").description("Reschedule idea-linked posts for optimal slot placement, displacing non-idea content").option("--dry-run", "Preview changes without updating posts").option("--queue", "Use Late API queue reshuffle instead of per-post reschedule").action(async (opts) => {
   const { runReschedule: runReschedule2 } = await Promise.resolve().then(() => (init_reschedule(), reschedule_exports));
-  await runReschedule2({ dryRun: opts.dryRun });
+  await runReschedule2({ dryRun: opts.dryRun, queue: opts.queue });
+  process.exit(0);
+});
+program.command("sync-queues").description("Sync schedule.json queue definitions to Late API queues").option("--reshuffle", "Reschedule existing queued posts to match new slot times").option("--dry-run", "Preview changes without making API calls").option("--delete-orphans", "Delete Late queues not in schedule.json").action(async (opts) => {
+  const { runSyncQueues: runSyncQueues2 } = await Promise.resolve().then(() => (init_syncQueues(), syncQueues_exports));
+  await runSyncQueues2({
+    reshuffle: opts.reshuffle,
+    dryRun: opts.dryRun,
+    deleteOrphans: opts.deleteOrphans
+  });
   process.exit(0);
 });
 program.command("chat").description("Interactive chat session with the schedule management agent").action(async () => {
@@ -23627,7 +24944,29 @@ program.command("thumbnail").description("Generate a thumbnail for a recording f
   });
   process.exit(0);
 });
-var defaultCmd = program.command("process", { isDefault: true }).argument("[video-path]", "Path to a video file to process (implies --once)").option("--watch-dir <path>", "Folder to watch for new recordings (default: env WATCH_FOLDER)").option("--output-dir <path>", "Output directory for processed videos (default: ./recordings)").option("--openai-key <key>", "OpenAI API key (default: env OPENAI_API_KEY)").option("--exa-key <key>", "Exa AI API key for web search (default: env EXA_API_KEY)").option("--youtube-key <key>", "YouTube API key (default: env YOUTUBE_API_KEY)").option("--perplexity-key <key>", "Perplexity API key (default: env PERPLEXITY_API_KEY)").option("--once", "Process a single video and exit (no watching)").option("--brand <path>", "Path to brand.json config (default: ./brand.json)").option("--no-silence-removal", "Skip silence removal stage").option("--no-shorts", "Skip shorts generation").option("--no-medium-clips", "Skip medium clip generation").option("--no-social", "Skip social media post generation").option("--no-captions", "Skip caption generation/burning").option("--no-visual-enhancement", "Skip visual enhancement (AI image overlays)").option("--no-intro-outro", "Skip intro/outro concatenation").option("--no-social-publish", "Skip social media publishing/queue-build stage").option("--late-api-key <key>", "Late API key (default: env LATE_API_KEY)").option("--late-profile-id <id>", "Late profile ID (default: env LATE_PROFILE_ID)").option("--ideas <ids>", "Comma-separated idea IDs to link to this video").option("--publish-by <date>", "Publish-by deadline for auto-created ideas (ISO date or +Nd for relative, default: +7d)").option("-v, --verbose", "Verbose logging").option("--progress", "Emit structured JSON progress events to stderr").option("--doctor", "Check all prerequisites and exit").action(async (videoPath) => {
+program.command("specs").description("List available pipeline spec presets and custom specs").action(async () => {
+  const { PRESETS: PRESETS2 } = await Promise.resolve().then(() => (init_pipelineSpec(), pipelineSpec_exports));
+  console.log("\nBuilt-in presets:\n");
+  for (const [name, preset] of Object.entries(PRESETS2)) {
+    console.log(`  ${name.padEnd(12)} ${preset.description}`);
+  }
+  try {
+    const specsDir = join(projectRoot(), "pipeline-specs");
+    const files = listDirectorySync(specsDir);
+    const specFiles = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml") || f.endsWith(".json"));
+    if (specFiles.length > 0) {
+      console.log("\nCustom specs (pipeline-specs/):\n");
+      for (const file of specFiles) {
+        const name = file.replace(/\.(yaml|yml|json)$/, "");
+        console.log(`  ${name}`);
+      }
+    }
+  } catch {
+  }
+  console.log("\nUsage: vidpipe process --spec <name-or-path> video.mp4\n");
+  process.exit(0);
+});
+var defaultCmd = program.command("process", { isDefault: true }).argument("[video-path]", "Path to a video file to process (implies --once)").option("--watch-dir <path>", "Folder to watch for new recordings (default: env WATCH_FOLDER)").option("--output-dir <path>", "Output directory for processed videos (default: ./recordings)").option("--openai-key <key>", "OpenAI API key (default: env OPENAI_API_KEY)").option("--exa-key <key>", "Exa AI API key for web search (default: env EXA_API_KEY)").option("--youtube-key <key>", "YouTube API key (default: env YOUTUBE_API_KEY)").option("--perplexity-key <key>", "Perplexity API key (default: env PERPLEXITY_API_KEY)").option("--once", "Process a single video and exit (no watching)").option("--brand <path>", "Path to brand.json config (default: ./brand.json)").option("--no-silence-removal", "Skip silence removal stage").option("--no-shorts", "Skip shorts generation").option("--no-medium-clips", "Skip medium clip generation").option("--no-social", "Skip social media post generation").option("--no-captions", "Skip caption generation/burning").option("--no-visual-enhancement", "Skip visual enhancement (AI image overlays)").option("--no-intro-outro", "Skip intro/outro concatenation").option("--no-social-publish", "Skip social media publishing/queue-build stage").option("--spec <nameOrPath>", "Pipeline spec preset name or YAML file path").option("--late-api-key <key>", "Late API key (default: env LATE_API_KEY)").option("--late-profile-id <id>", "Late profile ID (default: env LATE_PROFILE_ID)").option("--ideas <ids>", "Comma-separated idea IDs to link to this video").option("--publish-by <date>", "Publish-by deadline for auto-created ideas (ISO date or +Nd for relative, default: +7d)").option("-v, --verbose", "Verbose logging").option("--progress", "Emit structured JSON progress events to stderr").option("--doctor", "Check all prerequisites and exit").action(async (videoPath) => {
   const opts = defaultCmd.opts();
   if (opts.doctor) {
     await runDoctor();
@@ -23662,6 +25001,18 @@ var defaultCmd = program.command("process", { isDefault: true }).argument("[vide
   const config2 = getConfig();
   logger_default.info(`Watch folder: ${config2.WATCH_FOLDER}`);
   logger_default.info(`Output dir:   ${config2.OUTPUT_DIR}`);
+  let pipelineSpec;
+  if (opts.spec) {
+    try {
+      const { loadSpec: loadSpec2 } = await Promise.resolve().then(() => (init_specLoader(), specLoader_exports));
+      pipelineSpec = await loadSpec2(opts.spec, config2.REPO_ROOT);
+      logger_default.info(`Using pipeline spec: ${pipelineSpec.name}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger_default.error(`Failed to load pipeline spec: ${msg}`);
+      process.exit(1);
+    }
+  }
   let ideas;
   if (opts.ideas) {
     const { getIdeasByIds: getIdeasByIds2 } = await Promise.resolve().then(() => (init_ideaService2(), ideaService_exports2));
@@ -23692,7 +25043,7 @@ var defaultCmd = program.command("process", { isDefault: true }).argument("[vide
         process.exit(1);
       }
     }
-    await processVideoSafe(resolvedPath, ideas, publishBy);
+    await processVideoSafe(resolvedPath, ideas, publishBy, pipelineSpec);
     if (ideas && ideas.length > 0) {
       try {
         const { markRecorded: markRecorded3 } = await Promise.resolve().then(() => (init_ideaService(), ideaService_exports));
@@ -23720,7 +25071,7 @@ var defaultCmd = program.command("process", { isDefault: true }).argument("[vide
       while (queue2.length > 0) {
         const vp = queue2.shift();
         logger_default.info(`Processing video: ${vp}`);
-        await processVideoSafe(vp, ideas);
+        await processVideoSafe(vp, ideas, void 0, pipelineSpec);
         if (onceMode) {
           logger_default.info("--once flag set, exiting after first video.");
           await shutdown();