vidpipe 1.3.18 → 1.3.20

package/dist/index.js

@@ -38,6 +38,116 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/L0-pure/pipelineSpec/types.ts
+var init_types = __esm({
+  "src/L0-pure/pipelineSpec/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/L0-pure/pipelineSpec/presets.ts
+var PRESET_FULL;
+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
+        }
+      }
+    };
+  }
+});
+
+// src/L0-pure/pipelineSpec/validation.ts
+var init_validation = __esm({
+  "src/L0-pure/pipelineSpec/validation.ts"() {
+    "use strict";
+  }
+});
+
+// src/L0-pure/pipelineSpec/merger.ts
+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 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);
@@ -66,9 +176,10 @@ function normalizePlatformString(raw) {
   return lower;
 }
 var Platform, PipelineStage, 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";
@@ -1632,7 +1743,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();
@@ -4987,23 +5098,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 })
     }
   };
 }
@@ -5025,13 +5176,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.
@@ -5039,12 +5207,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();
@@ -5052,7 +5222,9 @@ var init_session = __esm({
       permissionHandler;
       userInputHandler;
       hooks;
+      transformCallbacks;
       _rpc = null;
+      traceContextProvider;
       /**
        * Typed session-scoped RPC methods.
        */
@@ -5090,6 +5262,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,
@@ -5219,9 +5392,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;
@@ -5234,13 +5417,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) {
@@ -5271,6 +5456,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 {
@@ -5351,6 +5539,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.
@@ -5367,8 +5589,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" };
         }
       }
@@ -5524,14 +5752,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 });
       }
     };
   }
@@ -5539,7 +5788,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 join5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -5553,6 +5804,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";
@@ -5560,9 +5835,22 @@ function getNodeExecPath() {
   return process.execPath;
 }
 function getBundledCliPath() {
-  const sdkUrl = import.meta.resolve("@github/copilot/sdk");
-  const sdkPath = fileURLToPath3(sdkUrl);
-  return join5(dirname3(dirname3(sdkPath)), "index.js");
+  if (typeof import.meta.resolve === "function") {
+    const sdkUrl = import.meta.resolve("@github/copilot/sdk");
+    const sdkPath = fileURLToPath3(sdkUrl);
+    return join5(dirname3(dirname3(sdkPath)), "index.js");
+  }
+  const req = createRequire2(__filename);
+  const searchPaths = req.resolve.paths("@github/copilot") ?? [];
+  for (const base of searchPaths) {
+    const candidate = join5(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({
@@ -5572,6 +5860,7 @@ var init_client = __esm({
     init_rpc();
     init_sdkProtocolVersion();
     init_session();
+    init_telemetry();
     MIN_PROTOCOL_VERSION = 2;
     CopilotClient = class {
       cliProcess = null;
@@ -5586,6 +5875,8 @@ var init_client = __esm({
       options;
       isExternalServer = false;
       forceStopping = false;
+      onListModels;
+      onGetTraceContext;
       modelsCache = null;
       modelsCacheLock = Promise.resolve();
       sessionLifecycleHandlers = /* @__PURE__ */ new Set();
@@ -5651,8 +5942,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,
@@ -5662,11 +5955,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
         };
       }
       /**
@@ -5918,36 +6212,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) {
@@ -5956,7 +6227,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;
       }
       /**
@@ -5996,37 +6314,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) {
@@ -6035,7 +6328,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;
       }
       /**
@@ -6096,15 +6437,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((resolve3) => {
@@ -6114,10 +6455,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();
@@ -6330,6 +6679,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.`
@@ -6429,8 +6799,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(() => {
@@ -6535,12 +6903,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) {
@@ -6599,6 +6970,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
       // ========================================================================
@@ -6627,11 +7008,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) };
@@ -6661,7 +7046,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"
@@ -6691,24 +7079,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" });
@@ -6721,21 +7098,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 join6, 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 = join6(base, platformPkg, binaryName);
@@ -9795,7 +10172,7 @@ Call the generate_thumbnail tool with a detailed, vivid prompt that will create
 });
 
 // src/L7-app/sdk/VidPipeSDK.ts
-init_types();
+init_types2();
 init_environment();
 init_globalConfig();
 init_fileSystem();
@@ -10054,6 +10431,31 @@ var LateApiClient = class {
     }
     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 {
@@ -10074,6 +10476,129 @@ function createLateApiClient(...args) {
   return new LateApiClient(...args);
 }
 
+// src/L3-services/queueMapping/queueMapping.ts
+init_configLogger();
+init_fileSystem();
+init_paths();
+var CACHE_FILE = ".vidpipe-queue-cache.json";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var memoryCache = null;
+function cachePath() {
+  return join(process.cwd(), CACHE_FILE);
+}
+function isCacheValid(cache) {
+  const fetchedAtTime = new Date(cache.fetchedAt).getTime();
+  if (Number.isNaN(fetchedAtTime)) {
+    logger_default.warn("Invalid fetchedAt in queue cache; treating as stale", {
+      fetchedAt: cache.fetchedAt
+    });
+    return false;
+  }
+  const age = Date.now() - fetchedAtTime;
+  return age < CACHE_TTL_MS;
+}
+async function readFileCache() {
+  try {
+    const raw = await readTextFile(cachePath());
+    const cache = JSON.parse(raw);
+    if (cache.mappings && cache.profileId && cache.fetchedAt && isCacheValid(cache)) {
+      return cache;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function writeFileCache(cache) {
+  try {
+    if (!cache || typeof cache !== "object" || !cache.mappings || !cache.profileId || !cache.fetchedAt) {
+      logger_default.warn("Invalid queue cache structure, skipping write");
+      return;
+    }
+    const sanitized = {
+      mappings: typeof cache.mappings === "object" ? { ...cache.mappings } : {},
+      profileId: String(cache.profileId),
+      fetchedAt: String(cache.fetchedAt)
+    };
+    for (const [name, id] of Object.entries(sanitized.mappings)) {
+      if (typeof name !== "string" || typeof id !== "string" || /[\x00-\x1f]/.test(name) || /[\x00-\x1f]/.test(id)) {
+        logger_default.warn("Invalid queue mapping data from API, skipping cache write");
+        return;
+      }
+    }
+    const resolvedCachePath = resolve(cachePath());
+    if (!resolvedCachePath.startsWith(resolve(process.cwd()) + sep)) {
+      throw new Error("Cache path outside working directory");
+    }
+    await writeTextFile(resolvedCachePath, JSON.stringify(sanitized, null, 2));
+  } catch (err) {
+    logger_default.warn("Failed to write queue cache file", { error: err });
+  }
+}
+async function fetchAndCache() {
+  const client = new LateApiClient();
+  const profiles = await client.listProfiles();
+  if (profiles.length === 0) {
+    logger_default.warn("No Late API profiles found \u2014 queue mappings will be empty");
+    const emptyCache = {
+      mappings: {},
+      profileId: "",
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    memoryCache = emptyCache;
+    return emptyCache;
+  }
+  const profileId = profiles[0]._id;
+  const { queues } = await client.listQueues(profileId, true);
+  if (queues.length === 0) {
+    logger_default.warn(
+      "No queues found in Late API \u2014 run `vidpipe sync-queues` to create platform queues"
+    );
+  }
+  const mappings = {};
+  for (const queue of queues) {
+    mappings[queue.name] = queue._id;
+  }
+  const cache = {
+    mappings,
+    profileId,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  memoryCache = cache;
+  await writeFileCache(cache);
+  logger_default.info("Refreshed Late queue mappings", {
+    queueCount: queues.length,
+    queues: Object.keys(mappings)
+  });
+  return cache;
+}
+async function ensureMappings() {
+  if (memoryCache && isCacheValid(memoryCache)) {
+    return memoryCache;
+  }
+  const fileCache = await readFileCache();
+  if (fileCache) {
+    memoryCache = fileCache;
+    return fileCache;
+  }
+  try {
+    return await fetchAndCache();
+  } catch (err) {
+    logger_default.error("Failed to fetch Late queue mappings", { error: err });
+    return { mappings: {}, profileId: "", fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function getQueueId(platform, clipType) {
+  const cache = await ensureMappings();
+  const normalizedPlatform = platform === "twitter" ? "x" : platform;
+  const queueName = `${normalizedPlatform}-${clipType}`;
+  return cache.mappings[queueName] ?? null;
+}
+async function getProfileId() {
+  const cache = await ensureMappings();
+  return cache.profileId;
+}
+
 // src/L2-clients/scheduleStore/scheduleStore.ts
 init_fileSystem();
 init_paths();
@@ -10376,7 +10901,7 @@ function getIdeaSpacingConfig() {
 }
 
 // src/L3-services/postStore/postStore.ts
-init_types();
+init_types2();
 init_environment();
 init_configLogger();
 init_fileSystem();
@@ -11249,11 +11774,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 },
@@ -11301,10 +11826,10 @@ async function generateImage2(prompt, outputPath, options) {
 }
 
 // src/L3-services/queueBuilder/queueBuilder.ts
-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 */) {
@@ -11351,7 +11876,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 {
@@ -11370,7 +11895,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) {
@@ -11508,7 +12033,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.
 
@@ -14823,7 +15348,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();
@@ -15083,7 +15608,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;
@@ -15493,7 +16018,39 @@ init_videoOperations();
 init_fileSystem();
 init_paths();
 init_configLogger();
-var SYSTEM_PROMPT5 = `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
 
@@ -15510,7 +16067,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?
@@ -15525,7 +16082,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) |
@@ -15561,22 +16118,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)
 
@@ -15627,14 +16169,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
@@ -15647,8 +16189,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_PROMPT5 = buildShortsSystemPrompt();
 var ADD_SHORTS_SCHEMA = {
   type: "object",
   properties: {
@@ -15798,20 +16342,22 @@ Review critically:
     return this.isFinalized;
   }
 };
-async function generateShorts(video, transcript, model, clipDirection, webcamOverride, ideas) {
-  const systemPrompt = SYSTEM_PROMPT5 + (ideas?.length ? buildIdeaContext(ideas) : "");
+async function generateShorts(video, transcript, model, clipDirection, webcamOverride, ideas, clipConfig, generateVariants) {
+  const basePrompt = clipConfig ? buildShortsSystemPrompt(clipConfig) : SYSTEM_PROMPT5;
+  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"),
@@ -15863,23 +16409,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 {
@@ -15894,8 +16444,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;
@@ -15913,7 +16463,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);
@@ -15964,7 +16514,7 @@ Words: ${words}`;
         description: plan.description,
         tags: plan.tags,
         hook: plan.hook,
-        variants,
+        variants: clipVariants,
         hookType: plan.hookType,
         emotionalTrigger: plan.emotionalTrigger,
         viralScore: plan.viralScore,
@@ -15987,7 +16537,15 @@ init_videoOperations();
 init_fileSystem();
 init_paths();
 init_configLogger();
-var SYSTEM_PROMPT6 = `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
 
@@ -16004,7 +16562,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?
@@ -16019,7 +16577,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) |
@@ -16098,10 +16656,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
 
@@ -16123,7 +16681,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.
@@ -16131,7 +16689,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.
 
@@ -16139,7 +16697,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
@@ -16148,6 +16706,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_PROMPT6 = buildMediumSystemPrompt();
 var ADD_MEDIUM_CLIPS_SCHEMA = {
   type: "object",
   properties: {
@@ -16305,20 +16865,26 @@ Review critically:
     return this.isFinalized;
   }
 };
-async function generateMediumClips(video, transcript, model, clipDirection, ideas) {
-  const systemPrompt = SYSTEM_PROMPT6 + (ideas?.length ? buildIdeaContext(ideas) : "");
+async function generateMediumClips(video, transcript, model, clipDirection, ideas, clipConfig) {
+  const basePrompt = clipConfig ? buildMediumSystemPrompt(clipConfig) : SYSTEM_PROMPT6;
+  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"),
@@ -17203,17 +17769,27 @@ init_paths();
 init_BaseAgent();
 init_configLogger();
 init_environment();
-init_types();
-var SYSTEM_PROMPT8 = `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.
@@ -17225,6 +17801,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_PROMPT8 = buildSocialMediaSystemPrompt();
 var SocialMediaAgent = class extends BaseAgent {
   collectedPosts = [];
   constructor(systemPrompt = SYSTEM_PROMPT8, model) {
@@ -17405,8 +17983,9 @@ async function generateShortPosts(video, short, transcript, model, summary) {
     await agent.destroy();
   }
 }
-async function generateSocialPosts(video, transcript, summary, outputDir, model, ideas) {
-  const systemPrompt = SYSTEM_PROMPT8 + (ideas?.length ? buildIdeaContextForPosts(ideas) : "");
+async function generateSocialPosts(video, transcript, summary, outputDir, model, ideas, toneStrategy) {
+  const basePrompt = toneStrategy ? buildSocialMediaSystemPrompt(toneStrategy) : SYSTEM_PROMPT8;
+  const systemPrompt = basePrompt + (ideas?.length ? buildIdeaContextForPosts(ideas) : "");
   const agent = new SocialMediaAgent(systemPrompt, model);
   try {
     const userMessage = [
@@ -17839,7 +18418,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;
@@ -17848,6 +18427,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;
@@ -18397,7 +18986,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;
   }
@@ -18429,7 +19029,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;
   }
@@ -18452,7 +19060,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;
   }
@@ -18826,7 +19443,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).
@@ -18838,7 +19456,7 @@ var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
 };
 
 // src/L6-pipeline/pipeline.ts
-init_types();
+init_types2();
 async function runStage(stageName, fn, stageResults) {
   const start = Date.now();
   if (progressEmitter.isEnabled()) {
@@ -18892,11 +19510,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);
@@ -18961,43 +19590,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) {
@@ -19024,13 +19654,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) {
@@ -19050,7 +19680,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());
@@ -19069,7 +19699,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) {
@@ -19093,14 +19723,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");
     }
@@ -19192,13 +19822,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) {
@@ -19811,6 +20441,19 @@ function createVidPipe(sdkConfig) {
     },
     schedule: {
       async findNextSlot(platform, clipType, options) {
+        const effectiveClipType = clipType || "short";
+        const queueId = await getQueueId(platform, effectiveClipType);
+        if (queueId) {
+          try {
+            const profileId = await getProfileId();
+            const client = createLateApiClient();
+            const preview = await client.previewQueue(profileId, queueId, 1);
+            if (preview.slots?.length > 0) {
+              return preview.slots[0];
+            }
+          } catch {
+          }
+        }
         return await findNextSlot(platform, clipType, {
           ideaIds: options?.ideaIds?.map((ideaId) => String(ideaId)),
           publishBy: options?.publishBy
@@ -19910,7 +20553,7 @@ function createVidPipe(sdkConfig) {
 }
 
 // src/index.ts
-init_types();
+init_types2();
 export {
   PLATFORM_CHAR_LIMITS,
   PipelineStage,