vidpipe 1.3.12 → 1.3.14

package/dist/index.js

@@ -93,7 +93,6 @@ var init_types = __esm({
       PipelineStage2["MediumClipPosts"] = "medium-clip-posts";
       PipelineStage2["Blog"] = "blog";
       PipelineStage2["QueueBuild"] = "queue-build";
-      PipelineStage2["GitPush"] = "git-push";
       return PipelineStage2;
     })(PipelineStage || {});
     PIPELINE_STAGES = [
@@ -111,8 +110,7 @@ var init_types = __esm({
       { stage: "short-posts" /* ShortPosts */, name: "Short Posts", stageNumber: 12 },
       { stage: "medium-clip-posts" /* MediumClipPosts */, name: "Medium Clip Posts", stageNumber: 13 },
       { stage: "queue-build" /* QueueBuild */, name: "Queue Build", stageNumber: 14 },
-      { stage: "blog" /* Blog */, name: "Blog", stageNumber: 15 },
-      { stage: "git-push" /* GitPush */, name: "Git Push", stageNumber: 16 }
+      { stage: "blog" /* Blog */, name: "Blog", stageNumber: 15 }
     ];
     TOTAL_STAGES = PIPELINE_STAGES.length;
     PLATFORM_CHAR_LIMITS = {
@@ -143,7 +141,7 @@ function findRoot(startDir) {
   }
 }
 function projectRoot() {
-  if (!_cachedRoot) _cachedRoot = findRoot(__dirname);
+  if (!_cachedRoot) _cachedRoot = findRoot(__dirname2);
   return _cachedRoot;
 }
 function assetsDir(...segments) {
@@ -157,11 +155,11 @@ function modelsDir() {
   const bundled = resolve2(projectRoot(), "dist", "models");
   return existsSync(bundled) ? bundled : assetsDir("models");
 }
-var __dirname, _cachedRoot;
+var __dirname2, _cachedRoot;
 var init_paths = __esm({
   "src/L1-infra/paths/paths.ts"() {
     "use strict";
-    __dirname = dirname2(fileURLToPath2(import.meta.url));
+    __dirname2 = dirname2(fileURLToPath2(import.meta.url));
   }
 });
 
@@ -448,6 +446,12 @@ function saveGlobalConfig(config2) {
     chmodSync(configPath, 384);
   }
 }
+function getGlobalConfigValue(section, key) {
+  const config2 = loadGlobalConfig();
+  const sectionValues = config2[section];
+  const value = sectionValues[key];
+  return typeof value === "string" ? value : void 0;
+}
 function setGlobalConfigValue(section, key, value) {
   const config2 = loadGlobalConfig();
   const sectionValues = config2[section];
@@ -471,8 +475,9 @@ var init_globalConfig = __esm({
 
 // src/L1-infra/config/configResolver.ts
 import { join as join4 } from "path";
-function resolveString(...sources) {
-  for (const source of sources) {
+function resolveString(cliValue, ...fallbacks) {
+  if (cliValue !== void 0) return cliValue;
+  for (const source of fallbacks) {
     if (source !== void 0 && source !== "") {
       return source;
     }
@@ -490,7 +495,11 @@ function resolveBoolean(cliValue, envValue, defaultValue) {
 }
 function resolveConfig(cliOptions = {}) {
   const globalConfig = loadGlobalConfig();
-  const repoRoot = process.env.REPO_ROOT || process.cwd();
+  const repoRoot = resolveString(
+    cliOptions.repoRoot,
+    process.env.REPO_ROOT,
+    process.cwd()
+  );
   return {
     OPENAI_API_KEY: resolveString(
       cliOptions.openaiKey,
@@ -504,14 +513,22 @@ function resolveConfig(cliOptions = {}) {
       join4(repoRoot, "watch")
     ),
     REPO_ROOT: repoRoot,
-    FFMPEG_PATH: resolveString(process.env.FFMPEG_PATH, "ffmpeg"),
-    FFPROBE_PATH: resolveString(process.env.FFPROBE_PATH, "ffprobe"),
+    FFMPEG_PATH: resolveString(
+      cliOptions.ffmpegPath,
+      process.env.FFMPEG_PATH,
+      "ffmpeg"
+    ),
+    FFPROBE_PATH: resolveString(
+      cliOptions.ffprobePath,
+      process.env.FFPROBE_PATH,
+      "ffprobe"
+    ),
     EXA_API_KEY: resolveString(
       cliOptions.exaKey,
       process.env.EXA_API_KEY,
       globalConfig.credentials.exaApiKey
     ),
-    EXA_MCP_URL: resolveString(process.env.EXA_MCP_URL, "https://mcp.exa.ai/mcp"),
+    EXA_MCP_URL: resolveString(void 0, process.env.EXA_MCP_URL, "https://mcp.exa.ai/mcp"),
     YOUTUBE_API_KEY: resolveString(
       cliOptions.youtubeKey,
       process.env.YOUTUBE_API_KEY,
@@ -523,12 +540,18 @@ function resolveConfig(cliOptions = {}) {
       globalConfig.credentials.perplexityApiKey
     ),
     LLM_PROVIDER: resolveString(
+      cliOptions.llmProvider,
       process.env.LLM_PROVIDER,
       globalConfig.defaults.llmProvider,
       "copilot"
     ),
-    LLM_MODEL: resolveString(process.env.LLM_MODEL, globalConfig.defaults.llmModel),
+    LLM_MODEL: resolveString(
+      cliOptions.llmModel,
+      process.env.LLM_MODEL,
+      globalConfig.defaults.llmModel
+    ),
     ANTHROPIC_API_KEY: resolveString(
+      cliOptions.anthropicKey,
       process.env.ANTHROPIC_API_KEY,
       globalConfig.credentials.anthropicApiKey
     ),
@@ -545,7 +568,6 @@ function resolveConfig(cliOptions = {}) {
       join4(repoRoot, "brand.json")
     ),
     VERBOSE: cliOptions.verbose ?? false,
-    SKIP_GIT: resolveBoolean(cliOptions.git === void 0 ? void 0 : !cliOptions.git, process.env.SKIP_GIT, false),
     SKIP_SILENCE_REMOVAL: resolveBoolean(
       cliOptions.silenceRemoval === void 0 ? void 0 : !cliOptions.silenceRemoval,
       process.env.SKIP_SILENCE_REMOVAL,
@@ -592,10 +614,12 @@ function resolveConfig(cliOptions = {}) {
       false
     ),
     GEMINI_API_KEY: resolveString(
+      cliOptions.geminiKey,
       process.env.GEMINI_API_KEY,
       globalConfig.credentials.geminiApiKey
     ),
     GEMINI_MODEL: resolveString(
+      cliOptions.geminiModel,
       process.env.GEMINI_MODEL,
       globalConfig.defaults.geminiModel,
       "gemini-2.5-pro"
@@ -610,9 +634,19 @@ function resolveConfig(cliOptions = {}) {
       cliOptions.githubToken,
       process.env.GITHUB_TOKEN,
       globalConfig.credentials.githubToken
-    )
+    ),
+    MODEL_OVERRIDES: resolveModelOverrides()
   };
 }
+function resolveModelOverrides() {
+  const overrides = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith("MODEL_") && value) {
+      overrides[key] = value;
+    }
+  }
+  return overrides;
+}
 var init_configResolver = __esm({
   "src/L1-infra/config/configResolver.ts"() {
     "use strict";
@@ -628,7 +662,7 @@ __export(environment_exports, {
   validateRequiredKeys: () => validateRequiredKeys
 });
 function validateRequiredKeys() {
-  if (!config?.OPENAI_API_KEY && !process.env.OPENAI_API_KEY) {
+  if (!config?.OPENAI_API_KEY) {
     throw new Error("Missing required: OPENAI_API_KEY (set via --openai-key, env var, or vidpipe configure)");
   }
 }
@@ -1439,7 +1473,7 @@ var require_messages = __commonJS({
       ErrorCodes2.jsonrpcReservedErrorRangeEnd = -32e3;
       ErrorCodes2.serverErrorEnd = -32e3;
     })(ErrorCodes || (exports.ErrorCodes = ErrorCodes = {}));
-    var ResponseError = class _ResponseError extends Error {
+    var ResponseError2 = class _ResponseError extends Error {
       constructor(code, message, data) {
         super(message);
         this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
@@ -1457,7 +1491,7 @@ var require_messages = __commonJS({
         return result;
       }
     };
-    exports.ResponseError = ResponseError;
+    exports.ResponseError = ResponseError2;
     var ParameterStructures = class _ParameterStructures {
       constructor(kind) {
         this.kind = kind;
@@ -3010,14 +3044,14 @@ var require_connection = __commonJS({
       ConnectionErrors2[ConnectionErrors2["Disposed"] = 2] = "Disposed";
       ConnectionErrors2[ConnectionErrors2["AlreadyListening"] = 3] = "AlreadyListening";
     })(ConnectionErrors || (exports.ConnectionErrors = ConnectionErrors = {}));
-    var ConnectionError = class _ConnectionError extends Error {
+    var ConnectionError2 = class _ConnectionError extends Error {
       constructor(code, message) {
         super(message);
         this.code = code;
         Object.setPrototypeOf(this, _ConnectionError.prototype);
       }
     };
-    exports.ConnectionError = ConnectionError;
+    exports.ConnectionError = ConnectionError2;
     var ConnectionStrategy;
     (function(ConnectionStrategy2) {
       function is(value) {
@@ -3640,15 +3674,15 @@ ${JSON.stringify(message, null, 4)}`);
       }
       function throwIfClosedOrDisposed() {
         if (isClosed()) {
-          throw new ConnectionError(ConnectionErrors.Closed, "Connection is closed.");
+          throw new ConnectionError2(ConnectionErrors.Closed, "Connection is closed.");
         }
         if (isDisposed()) {
-          throw new ConnectionError(ConnectionErrors.Disposed, "Connection is disposed.");
+          throw new ConnectionError2(ConnectionErrors.Disposed, "Connection is disposed.");
         }
       }
       function throwIfListening() {
         if (isListening()) {
-          throw new ConnectionError(ConnectionErrors.AlreadyListening, "Connection is already listening");
+          throw new ConnectionError2(ConnectionErrors.AlreadyListening, "Connection is already listening");
         }
       }
       function throwIfNotListening() {
@@ -4633,6 +4667,150 @@ var require_node = __commonJS({
   }
 });
 
+// src/L3-services/postStore/postStore.ts
+function getQueueDir() {
+  const { OUTPUT_DIR } = getConfig();
+  return join(OUTPUT_DIR, "publish-queue");
+}
+function getPublishedDir() {
+  const { OUTPUT_DIR } = getConfig();
+  return join(OUTPUT_DIR, "published");
+}
+async function readQueueItem(folderPath, id) {
+  const metadataPath = join(folderPath, "metadata.json");
+  const postPath = join(folderPath, "post.md");
+  try {
+    const metadataRaw = await readTextFile(metadataPath);
+    const metadata = JSON.parse(metadataRaw);
+    let postContent = "";
+    try {
+      postContent = await readTextFile(postPath);
+    } catch {
+      logger_default.debug(`No post.md found for ${String(id).replace(/[\r\n]/g, "")}`);
+    }
+    const videoPath = join(folderPath, "media.mp4");
+    const imagePath = join(folderPath, "media.png");
+    let mediaPath = null;
+    let hasMedia = false;
+    if (await fileExists(videoPath)) {
+      mediaPath = videoPath;
+      hasMedia = true;
+    } else if (await fileExists(imagePath)) {
+      mediaPath = imagePath;
+      hasMedia = true;
+    }
+    return {
+      id,
+      metadata,
+      postContent,
+      hasMedia,
+      mediaPath,
+      folderPath
+    };
+  } catch (err) {
+    logger_default.debug(`Failed to read queue item ${String(id).replace(/[\r\n]/g, "")}: ${String(err).replace(/[\r\n]/g, "")}`);
+    return null;
+  }
+}
+async function getPendingItems() {
+  const queueDir = getQueueDir();
+  await ensureDirectory(queueDir);
+  let entries;
+  try {
+    const dirents = await listDirectoryWithTypes(queueDir);
+    entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const items = [];
+  for (const name of entries) {
+    const item = await readQueueItem(join(queueDir, name), name);
+    if (item) items.push(item);
+  }
+  items.sort((a, b) => {
+    if (a.hasMedia !== b.hasMedia) return a.hasMedia ? -1 : 1;
+    return a.metadata.createdAt.localeCompare(b.metadata.createdAt);
+  });
+  return items;
+}
+async function createItem(id, metadata, postContent, mediaSourcePath) {
+  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
+    throw new Error(`Invalid ID format: ${id}`);
+  }
+  const folderPath = join(getQueueDir(), basename(id));
+  await ensureDirectory(folderPath);
+  await writeJsonFile(join(folderPath, "metadata.json"), metadata);
+  await writeTextFile(join(folderPath, "post.md"), postContent);
+  let hasMedia = false;
+  const ext = mediaSourcePath ? extname(mediaSourcePath) : ".mp4";
+  const mediaFilename = `media${ext}`;
+  const mediaPath = join(folderPath, mediaFilename);
+  if (mediaSourcePath) {
+    await copyFile(mediaSourcePath, mediaPath);
+    hasMedia = true;
+  }
+  logger_default.debug(`Created queue item: ${String(id).replace(/[\r\n]/g, "")}`);
+  return {
+    id,
+    metadata,
+    postContent,
+    hasMedia,
+    mediaPath: hasMedia ? mediaPath : null,
+    folderPath
+  };
+}
+async function getPublishedItems() {
+  const publishedDir = getPublishedDir();
+  await ensureDirectory(publishedDir);
+  let entries;
+  try {
+    const dirents = await listDirectoryWithTypes(publishedDir);
+    entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const items = [];
+  for (const name of entries) {
+    const item = await readQueueItem(join(publishedDir, name), name);
+    if (item) items.push(item);
+  }
+  items.sort((a, b) => a.metadata.createdAt.localeCompare(b.metadata.createdAt));
+  return items;
+}
+async function getScheduledItemsByIdeaIds(ideaIds) {
+  if (ideaIds.length === 0) return [];
+  const ideaIdSet = new Set(ideaIds);
+  const [pendingItems, publishedItems] = await Promise.all([
+    getPendingItems(),
+    getPublishedItems()
+  ]);
+  return [...pendingItems, ...publishedItems].filter(
+    (item) => item.metadata.ideaIds?.some((id) => ideaIdSet.has(id)) ?? false
+  );
+}
+async function itemExists(id) {
+  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
+    throw new Error(`Invalid ID format: ${id}`);
+  }
+  if (await fileExists(join(getQueueDir(), basename(id)))) {
+    return "pending";
+  }
+  if (await fileExists(join(getPublishedDir(), basename(id)))) {
+    return "published";
+  }
+  return null;
+}
+var init_postStore = __esm({
+  "src/L3-services/postStore/postStore.ts"() {
+    "use strict";
+    init_types();
+    init_environment();
+    init_configLogger();
+    init_fileSystem();
+    init_paths();
+  }
+});
+
 // src/L7-app/sdk/VidPipeSDK.ts
 init_types();
 init_environment();
@@ -4640,6 +4818,47 @@ init_globalConfig();
 init_fileSystem();
 init_paths();
 
+// src/L1-infra/progress/progressEmitter.ts
+var ProgressEmitter = class {
+  enabled = false;
+  listeners = /* @__PURE__ */ new Set();
+  /** Turn on progress event output to stderr. */
+  enable() {
+    this.enabled = true;
+  }
+  /** Turn off progress event output. */
+  disable() {
+    this.enabled = false;
+  }
+  /** Whether the emitter is currently active (stderr or listeners). */
+  isEnabled() {
+    return this.enabled || this.listeners.size > 0;
+  }
+  /** Register a programmatic listener for progress events. */
+  addListener(fn) {
+    this.listeners.add(fn);
+  }
+  /** Remove a previously registered listener. */
+  removeListener(fn) {
+    this.listeners.delete(fn);
+  }
+  /**
+   * Write a progress event as a single JSON line to stderr (if enabled)
+   * and dispatch to all registered listeners.
+   * No-op when neither stderr output nor listeners are active.
+   */
+  emit(event) {
+    if (!this.enabled && this.listeners.size === 0) return;
+    if (this.enabled) {
+      process.stderr.write(JSON.stringify(event) + "\n");
+    }
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+};
+var progressEmitter = new ProgressEmitter();
+
 // src/L1-infra/process/process.ts
 import { execFile as nodeExecFile, execSync as nodeExecSync, spawnSync as nodeSpawnSync } from "child_process";
 import { createRequire } from "module";
@@ -4648,9 +4867,6 @@ function execFileRaw(cmd, args, opts, callback) {
     callback(error, String(stdout ?? ""), String(stderr ?? ""));
   });
 }
-function execCommandSync(cmd, opts) {
-  return nodeExecSync(cmd, { encoding: "utf-8", ...opts }).toString().trim();
-}
 function spawnCommand(cmd, args, opts) {
   return nodeSpawnSync(cmd, args, { encoding: "utf-8", ...opts });
 }
@@ -4744,12 +4960,13 @@ var AGENT_MODEL_MAP = {
   ProducerAgent: PREMIUM_MODEL
 };
 function getModelForAgent(agentName) {
+  const config2 = getConfig();
   const envKey = `MODEL_${agentName.replace(/([a-z])([A-Z])/g, "$1_$2").toUpperCase()}`;
-  const envOverride = process.env[envKey];
+  const envOverride = config2.MODEL_OVERRIDES[envKey];
   if (envOverride) return envOverride;
   const mapped = AGENT_MODEL_MAP[agentName];
   if (mapped) return mapped;
-  const global = getConfig().LLM_MODEL;
+  const global = config2.LLM_MODEL;
   if (global) return global;
   return void 0;
 }
@@ -4765,20 +4982,77 @@ import { default as default4 } from "openai";
 import { default as default5 } from "@anthropic-ai/sdk";
 
 // node_modules/@github/copilot-sdk/dist/client.js
-var import_node = __toESM(require_node(), 1);
+var import_node2 = __toESM(require_node(), 1);
 import { spawn } from "child_process";
 import { existsSync as existsSync4 } from "fs";
 import { Socket } from "net";
 import { dirname as dirname3, join as join5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
+// node_modules/@github/copilot-sdk/dist/generated/rpc.js
+function createServerRpc(connection) {
+  return {
+    ping: async (params) => connection.sendRequest("ping", params),
+    models: {
+      list: async () => connection.sendRequest("models.list", {})
+    },
+    tools: {
+      list: async (params) => connection.sendRequest("tools.list", params)
+    },
+    account: {
+      getQuota: async () => connection.sendRequest("account.getQuota", {})
+    }
+  };
+}
+function createSessionRpc(connection, sessionId) {
+  return {
+    model: {
+      getCurrent: async () => connection.sendRequest("session.model.getCurrent", { sessionId }),
+      switchTo: async (params) => connection.sendRequest("session.model.switchTo", { sessionId, ...params })
+    },
+    mode: {
+      get: async () => connection.sendRequest("session.mode.get", { sessionId }),
+      set: async (params) => connection.sendRequest("session.mode.set", { sessionId, ...params })
+    },
+    plan: {
+      read: async () => connection.sendRequest("session.plan.read", { sessionId }),
+      update: async (params) => connection.sendRequest("session.plan.update", { sessionId, ...params }),
+      delete: async () => connection.sendRequest("session.plan.delete", { sessionId })
+    },
+    workspace: {
+      listFiles: async () => connection.sendRequest("session.workspace.listFiles", { sessionId }),
+      readFile: async (params) => connection.sendRequest("session.workspace.readFile", { sessionId, ...params }),
+      createFile: async (params) => connection.sendRequest("session.workspace.createFile", { sessionId, ...params })
+    },
+    fleet: {
+      start: async (params) => connection.sendRequest("session.fleet.start", { sessionId, ...params })
+    },
+    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 })
+    },
+    compaction: {
+      compact: async () => connection.sendRequest("session.compaction.compact", { sessionId })
+    },
+    tools: {
+      handlePendingToolCall: async (params) => connection.sendRequest("session.tools.handlePendingToolCall", { sessionId, ...params })
+    },
+    permissions: {
+      handlePendingPermissionRequest: async (params) => connection.sendRequest("session.permissions.handlePendingPermissionRequest", { sessionId, ...params })
+    }
+  };
+}
+
 // node_modules/@github/copilot-sdk/dist/sdkProtocolVersion.js
-var SDK_PROTOCOL_VERSION = 2;
+var SDK_PROTOCOL_VERSION = 3;
 function getSdkProtocolVersion() {
   return SDK_PROTOCOL_VERSION;
 }
 
 // node_modules/@github/copilot-sdk/dist/session.js
+var import_node = __toESM(require_node(), 1);
 var CopilotSession = class {
   /**
    * Creates a new CopilotSession instance.
@@ -4799,6 +5073,16 @@ var CopilotSession = class {
   permissionHandler;
   userInputHandler;
   hooks;
+  _rpc = null;
+  /**
+   * Typed session-scoped RPC methods.
+   */
+  get rpc() {
+    if (!this._rpc) {
+      this._rpc = createSessionRpc(this.connection, this.sessionId);
+    }
+    return this._rpc;
+  }
   /**
    * Path to the session workspace directory when infinite sessions are enabled.
    * Contains checkpoints/, plan.md, and files/ subdirectories.
@@ -4815,7 +5099,7 @@ var CopilotSession = class {
    *
    * @param options - The message options including the prompt and optional attachments
    * @returns A promise that resolves with the message ID of the response
-   * @throws Error if the session has been destroyed or the connection fails
+   * @throws Error if the session has been disconnected or the connection fails
    *
    * @example
    * ```typescript
@@ -4848,7 +5132,7 @@ var CopilotSession = class {
    * @returns A promise that resolves with the final assistant message when the session becomes idle,
    *          or undefined if no assistant message was received
    * @throws Error if the timeout is reached before the session becomes idle
-   * @throws Error if the session has been destroyed or the connection fails
+   * @throws Error if the session has been disconnected or the connection fails
    *
    * @example
    * ```typescript
@@ -4922,11 +5206,13 @@ var CopilotSession = class {
   }
   /**
    * Dispatches an event to all registered handlers.
+   * Also handles broadcast request events internally (external tool calls, permissions).
    *
    * @param event - The session event to dispatch
    * @internal This method is for internal use by the SDK.
    */
   _dispatchEvent(event) {
+    this._handleBroadcastEvent(event);
     const typedHandlers = this.typedEventHandlers.get(event.type);
     if (typedHandlers) {
       for (const handler of typedHandlers) {
@@ -4943,6 +5229,85 @@ var CopilotSession = class {
       }
     }
   }
+  /**
+   * Handles broadcast request events by executing local handlers and responding via RPC.
+   * Handlers are dispatched as fire-and-forget — rejections propagate as unhandled promise
+   * rejections, consistent with standard EventEmitter / event handler semantics.
+   * @internal
+   */
+  _handleBroadcastEvent(event) {
+    if (event.type === "external_tool.requested") {
+      const { requestId, toolName } = event.data;
+      const args = event.data.arguments;
+      const toolCallId = event.data.toolCallId;
+      const handler = this.toolHandlers.get(toolName);
+      if (handler) {
+        void this._executeToolAndRespond(requestId, toolName, toolCallId, args, handler);
+      }
+    } else if (event.type === "permission.requested") {
+      const { requestId, permissionRequest } = event.data;
+      if (this.permissionHandler) {
+        void this._executePermissionAndRespond(requestId, permissionRequest);
+      }
+    }
+  }
+  /**
+   * Executes a tool handler and sends the result back via RPC.
+   * @internal
+   */
+  async _executeToolAndRespond(requestId, toolName, toolCallId, args, handler) {
+    try {
+      const rawResult = await handler(args, {
+        sessionId: this.sessionId,
+        toolCallId,
+        toolName,
+        arguments: args
+      });
+      let result;
+      if (rawResult == null) {
+        result = "";
+      } else if (typeof rawResult === "string") {
+        result = rawResult;
+      } else {
+        result = JSON.stringify(rawResult);
+      }
+      await this.rpc.tools.handlePendingToolCall({ requestId, result });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      try {
+        await this.rpc.tools.handlePendingToolCall({ requestId, error: message });
+      } catch (rpcError) {
+        if (!(rpcError instanceof import_node.ConnectionError || rpcError instanceof import_node.ResponseError)) {
+          throw rpcError;
+        }
+      }
+    }
+  }
+  /**
+   * Executes a permission handler and sends the result back via RPC.
+   * @internal
+   */
+  async _executePermissionAndRespond(requestId, permissionRequest) {
+    try {
+      const result = await this.permissionHandler(permissionRequest, {
+        sessionId: this.sessionId
+      });
+      await this.rpc.permissions.handlePendingPermissionRequest({ requestId, result });
+    } catch (_error) {
+      try {
+        await this.rpc.permissions.handlePendingPermissionRequest({
+          requestId,
+          result: {
+            kind: "denied-no-approval-rule-and-could-not-request-from-user"
+          }
+        });
+      } catch (rpcError) {
+        if (!(rpcError instanceof import_node.ConnectionError || rpcError instanceof import_node.ResponseError)) {
+          throw rpcError;
+        }
+      }
+    }
+  }
   /**
    * Registers custom tool handlers for this session.
    *
@@ -5008,13 +5373,14 @@ var CopilotSession = class {
     this.hooks = hooks;
   }
   /**
-   * Handles a permission request from the Copilot CLI.
+   * Handles a permission request in the v2 protocol format (synchronous RPC).
+   * Used as a back-compat adapter when connected to a v2 server.
    *
    * @param request - The permission request data from the CLI
    * @returns A promise that resolves with the permission decision
    * @internal This method is for internal use by the SDK.
    */
-  async _handlePermissionRequest(request) {
+  async _handlePermissionRequestV2(request) {
     if (!this.permissionHandler) {
       return { kind: "denied-no-approval-rule-and-could-not-request-from-user" };
     }
@@ -5085,7 +5451,7 @@ var CopilotSession = class {
    * assistant responses, tool executions, and other session events.
    *
    * @returns A promise that resolves with an array of all session events
-   * @throws Error if the session has been destroyed or the connection fails
+   * @throws Error if the session has been disconnected or the connection fails
    *
    * @example
    * ```typescript
@@ -5104,22 +5470,27 @@ var CopilotSession = class {
     return response.events;
   }
   /**
-   * Destroys this session and releases all associated resources.
+   * Disconnects this session and releases all in-memory resources (event handlers,
+   * tool handlers, permission handlers).
    *
-   * After calling this method, the session can no longer be used. All event
-   * handlers and tool handlers are cleared. To continue the conversation,
-   * use {@link CopilotClient.resumeSession} with the session ID.
+   * Session state on disk (conversation history, planning state, artifacts) is
+   * preserved, so the conversation can be resumed later by calling
+   * {@link CopilotClient.resumeSession} with the session ID. To permanently
+   * remove all session data including files on disk, use
+   * {@link CopilotClient.deleteSession} instead.
    *
-   * @returns A promise that resolves when the session is destroyed
+   * After calling this method, the session object can no longer be used.
+   *
+   * @returns A promise that resolves when the session is disconnected
    * @throws Error if the connection fails
    *
    * @example
    * ```typescript
-   * // Clean up when done
-   * await session.destroy();
+   * // Clean up when done — session can still be resumed later
+   * await session.disconnect();
    * ```
    */
-  async destroy() {
+  async disconnect() {
     await this.connection.sendRequest("session.destroy", {
       sessionId: this.sessionId
     });
@@ -5128,6 +5499,22 @@ var CopilotSession = class {
     this.toolHandlers.clear();
     this.permissionHandler = void 0;
   }
+  /**
+   * @deprecated Use {@link disconnect} instead. This method will be removed in a future release.
+   *
+   * Disconnects this session and releases all in-memory resources.
+   * Session data on disk is preserved for later resumption.
+   *
+   * @returns A promise that resolves when the session is disconnected
+   * @throws Error if the connection fails
+   */
+  async destroy() {
+    return this.disconnect();
+  }
+  /** Enables `await using session = ...` syntax for automatic cleanup. */
+  async [Symbol.asyncDispose]() {
+    return this.disconnect();
+  }
   /**
    * Aborts the currently processing message in this session.
    *
@@ -5135,7 +5522,7 @@ var CopilotSession = class {
    * and can continue to be used for new messages.
    *
    * @returns A promise that resolves when the abort request is acknowledged
-   * @throws Error if the session has been destroyed or the connection fails
+   * @throws Error if the session has been disconnected or the connection fails
    *
    * @example
    * ```typescript
@@ -5153,12 +5540,27 @@ var CopilotSession = class {
       sessionId: this.sessionId
     });
   }
-};
-
-// node_modules/@github/copilot-sdk/dist/client.js
-function isZodSchema(value) {
-  return value != null && typeof value === "object" && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
-}
+  /**
+   * Change the model for this session.
+   * The new model takes effect for the next message. Conversation history is preserved.
+   *
+   * @param model - Model ID to switch to
+   *
+   * @example
+   * ```typescript
+   * await session.setModel("gpt-4.1");
+   * ```
+   */
+  async setModel(model) {
+    await this.rpc.model.switchTo({ modelId: model });
+  }
+};
+
+// node_modules/@github/copilot-sdk/dist/client.js
+var MIN_PROTOCOL_VERSION = 2;
+function isZodSchema(value) {
+  return value != null && typeof value === "object" && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
+}
 function toJsonSchema(parameters) {
   if (!parameters) return void 0;
   if (isZodSchema(parameters)) {
@@ -5166,6 +5568,12 @@ function toJsonSchema(parameters) {
   }
   return parameters;
 }
+function getNodeExecPath() {
+  if (process.versions.bun) {
+    return "node";
+  }
+  return process.execPath;
+}
 function getBundledCliPath() {
   const sdkUrl = import.meta.resolve("@github/copilot/sdk");
   const sdkPath = fileURLToPath3(sdkUrl);
@@ -5179,6 +5587,8 @@ var CopilotClient = class {
   actualHost = "localhost";
   state = "disconnected";
   sessions = /* @__PURE__ */ new Map();
+  stderrBuffer = "";
+  // Captures CLI stderr for error messages
   options;
   isExternalServer = false;
   forceStopping = false;
@@ -5186,6 +5596,23 @@ var CopilotClient = class {
   modelsCacheLock = Promise.resolve();
   sessionLifecycleHandlers = /* @__PURE__ */ new Set();
   typedLifecycleHandlers = /* @__PURE__ */ new Map();
+  _rpc = null;
+  processExitPromise = null;
+  // Rejects when CLI process exits
+  negotiatedProtocolVersion = null;
+  /**
+   * Typed server-scoped RPC methods.
+   * @throws Error if the client is not connected
+   */
+  get rpc() {
+    if (!this.connection) {
+      throw new Error("Client is not connected. Call start() first.");
+    }
+    if (!this._rpc) {
+      this._rpc = createServerRpc(this.connection);
+    }
+    return this._rpc;
+  }
   /**
    * Creates a new CopilotClient instance.
    *
@@ -5211,6 +5638,11 @@ var CopilotClient = class {
     if (options.cliUrl && (options.useStdio === true || options.cliPath)) {
       throw new Error("cliUrl is mutually exclusive with useStdio and cliPath");
     }
+    if (options.isChildProcess && (options.cliUrl || options.useStdio === false)) {
+      throw new Error(
+        "isChildProcess must be used in conjunction with useStdio and not with cliUrl"
+      );
+    }
     if (options.cliUrl && (options.githubToken || options.useLoggedInUser !== void 0)) {
       throw new Error(
         "githubToken and useLoggedInUser cannot be used with cliUrl (external server manages its own auth)"
@@ -5222,6 +5654,9 @@ var CopilotClient = class {
       this.actualPort = port;
       this.isExternalServer = true;
     }
+    if (options.isChildProcess) {
+      this.isExternalServer = true;
+    }
     this.options = {
       cliPath: options.cliPath || getBundledCliPath(),
       cliArgs: options.cliArgs ?? [],
@@ -5229,6 +5664,7 @@ var CopilotClient = class {
       port: options.port || 0,
       useStdio: options.cliUrl ? false : options.useStdio ?? true,
       // Default to stdio unless cliUrl is provided
+      isChildProcess: options.isChildProcess ?? false,
       cliUrl: options.cliUrl,
       logLevel: options.logLevel || "debug",
       autoStart: options.autoStart ?? true,
@@ -5300,10 +5736,14 @@ var CopilotClient = class {
    * Stops the CLI server and closes all active sessions.
    *
    * This method performs graceful cleanup:
-   * 1. Destroys all active sessions with retry logic
+   * 1. Closes all active sessions (releases in-memory resources)
    * 2. Closes the JSON-RPC connection
    * 3. Terminates the CLI server process (if spawned by this client)
    *
+   * Note: session data on disk is preserved, so sessions can be resumed later.
+   * To permanently remove session data before stopping, call
+   * {@link deleteSession} for each session first.
+   *
    * @returns A promise that resolves with an array of errors encountered during cleanup.
    *          An empty array indicates all cleanup succeeded.
    *
@@ -5322,7 +5762,7 @@ var CopilotClient = class {
       let lastError = null;
       for (let attempt = 1; attempt <= 3; attempt++) {
         try {
-          await session.destroy();
+          await session.disconnect();
           lastError = null;
           break;
         } catch (error) {
@@ -5336,7 +5776,7 @@ var CopilotClient = class {
       if (lastError) {
         errors.push(
           new Error(
-            `Failed to destroy session ${sessionId} after 3 attempts: ${lastError.message}`
+            `Failed to disconnect session ${sessionId} after 3 attempts: ${lastError.message}`
           )
         );
       }
@@ -5353,6 +5793,7 @@ var CopilotClient = class {
         );
       }
       this.connection = null;
+      this._rpc = null;
     }
     this.modelsCache = null;
     if (this.socket) {
@@ -5381,6 +5822,8 @@ var CopilotClient = class {
     }
     this.state = "disconnected";
     this.actualPort = null;
+    this.stderrBuffer = "";
+    this.processExitPromise = null;
     return errors;
   }
   /**
@@ -5417,6 +5860,7 @@ var CopilotClient = class {
       } catch {
       }
       this.connection = null;
+      this._rpc = null;
     }
     this.modelsCache = null;
     if (this.socket) {
@@ -5435,6 +5879,8 @@ var CopilotClient = class {
     }
     this.state = "disconnected";
     this.actualPort = null;
+    this.stderrBuffer = "";
+    this.processExitPromise = null;
   }
   /**
    * Creates a new conversation session with the Copilot CLI.
@@ -5450,10 +5896,11 @@ var CopilotClient = class {
    * @example
    * ```typescript
    * // Basic session
-   * const session = await client.createSession();
+   * const session = await client.createSession({ onPermissionRequest: approveAll });
    *
    * // Session with model and tools
    * const session = await client.createSession({
+   *   onPermissionRequest: approveAll,
    *   model: "gpt-4",
    *   tools: [{
    *     name: "get_weather",
@@ -5464,7 +5911,12 @@ var CopilotClient = class {
    * });
    * ```
    */
-  async createSession(config2 = {}) {
+  async createSession(config2) {
+    if (!config2?.onPermissionRequest) {
+      throw new Error(
+        "An onPermissionRequest handler is required when creating a session. For example, to allow all permissions, use { onPermissionRequest: approveAll }."
+      );
+    }
     if (!this.connection) {
       if (this.options.autoStart) {
         await this.start();
@@ -5475,22 +5927,25 @@ var CopilotClient = class {
     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)
+        parameters: toJsonSchema(tool.parameters),
+        overridesBuiltInTool: tool.overridesBuiltInTool
       })),
       systemMessage: config2.systemMessage,
       availableTools: config2.availableTools,
       excludedTools: config2.excludedTools,
       provider: config2.provider,
-      requestPermission: !!config2.onPermissionRequest,
+      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,
@@ -5500,9 +5955,7 @@ var CopilotClient = class {
     const { sessionId, workspacePath } = response;
     const session = new CopilotSession(sessionId, this.connection, workspacePath);
     session.registerTools(config2.tools);
-    if (config2.onPermissionRequest) {
-      session.registerPermissionHandler(config2.onPermissionRequest);
-    }
+    session.registerPermissionHandler(config2.onPermissionRequest);
     if (config2.onUserInputRequest) {
       session.registerUserInputHandler(config2.onUserInputRequest);
     }
@@ -5527,15 +5980,21 @@ var CopilotClient = class {
    * @example
    * ```typescript
    * // Resume a previous session
-   * const session = await client.resumeSession("session-123");
+   * const session = await client.resumeSession("session-123", { onPermissionRequest: approveAll });
    *
    * // Resume with new tools
    * const session = await client.resumeSession("session-123", {
+   *   onPermissionRequest: approveAll,
    *   tools: [myNewTool]
    * });
    * ```
    */
-  async resumeSession(sessionId, config2 = {}) {
+  async resumeSession(sessionId, config2) {
+    if (!config2?.onPermissionRequest) {
+      throw new Error(
+        "An onPermissionRequest handler is required when resuming a session. For example, to allow all permissions, use { onPermissionRequest: approveAll }."
+      );
+    }
     if (!this.connection) {
       if (this.options.autoStart) {
         await this.start();
@@ -5545,6 +6004,7 @@ var CopilotClient = class {
     }
     const response = await this.connection.sendRequest("session.resume", {
       sessionId,
+      clientName: config2.clientName,
       model: config2.model,
       reasoningEffort: config2.reasoningEffort,
       systemMessage: config2.systemMessage,
@@ -5553,16 +6013,18 @@ var CopilotClient = class {
       tools: config2.tools?.map((tool) => ({
         name: tool.name,
         description: tool.description,
-        parameters: toJsonSchema(tool.parameters)
+        parameters: toJsonSchema(tool.parameters),
+        overridesBuiltInTool: tool.overridesBuiltInTool
       })),
       provider: config2.provider,
-      requestPermission: !!config2.onPermissionRequest,
+      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,
@@ -5572,9 +6034,7 @@ var CopilotClient = class {
     const { sessionId: resumedSessionId, workspacePath } = response;
     const session = new CopilotSession(resumedSessionId, this.connection, workspacePath);
     session.registerTools(config2.tools);
-    if (config2.onPermissionRequest) {
-      session.registerPermissionHandler(config2.onPermissionRequest);
-    }
+    session.registerPermissionHandler(config2.onPermissionRequest);
     if (config2.onUserInputRequest) {
       session.registerUserInputHandler(config2.onUserInputRequest);
     }
@@ -5592,7 +6052,7 @@ var CopilotClient = class {
    * @example
    * ```typescript
    * if (client.getState() === "connected") {
-   *   const session = await client.createSession();
+   *   const session = await client.createSession({ onPermissionRequest: approveAll });
    * }
    * ```
    */
@@ -5670,22 +6130,29 @@ var CopilotClient = class {
     }
   }
   /**
-   * Verify that the server's protocol version matches the SDK's expected version
+   * Verify that the server's protocol version is within the supported range
+   * and store the negotiated version.
    */
   async verifyProtocolVersion() {
-    const expectedVersion = getSdkProtocolVersion();
-    const pingResult = await this.ping();
+    const maxVersion = getSdkProtocolVersion();
+    let pingResult;
+    if (this.processExitPromise) {
+      pingResult = await Promise.race([this.ping(), this.processExitPromise]);
+    } else {
+      pingResult = await this.ping();
+    }
     const serverVersion = pingResult.protocolVersion;
     if (serverVersion === void 0) {
       throw new Error(
-        `SDK protocol version mismatch: SDK expects version ${expectedVersion}, but server does not report a protocol version. Please update your server to ensure compatibility.`
+        `SDK protocol version mismatch: SDK supports versions ${MIN_PROTOCOL_VERSION}-${maxVersion}, but server does not report a protocol version. Please update your server to ensure compatibility.`
       );
     }
-    if (serverVersion !== expectedVersion) {
+    if (serverVersion < MIN_PROTOCOL_VERSION || serverVersion > maxVersion) {
       throw new Error(
-        `SDK protocol version mismatch: SDK expects version ${expectedVersion}, but server reports version ${serverVersion}. Please update your SDK or server to ensure compatibility.`
+        `SDK protocol version mismatch: SDK supports versions ${MIN_PROTOCOL_VERSION}-${maxVersion}, but server reports version ${serverVersion}. Please update your SDK or server to ensure compatibility.`
       );
     }
+    this.negotiatedProtocolVersion = serverVersion;
   }
   /**
    * Gets the ID of the most recently updated session.
@@ -5700,7 +6167,7 @@ var CopilotClient = class {
    * ```typescript
    * const lastId = await client.getLastSessionId();
    * if (lastId) {
-   *   const session = await client.resumeSession(lastId);
+   *   const session = await client.resumeSession(lastId, { onPermissionRequest: approveAll });
    * }
    * ```
    */
@@ -5712,10 +6179,12 @@ var CopilotClient = class {
     return response.sessionId;
   }
   /**
-   * Deletes a session and its data from disk.
+   * Permanently deletes a session and all its data from disk, including
+   * conversation history, planning state, and artifacts.
    *
-   * This permanently removes the session and all its conversation history.
-   * The session cannot be resumed after deletion.
+   * Unlike {@link CopilotSession.disconnect}, which only releases in-memory
+   * resources and preserves session data for later resumption, this method
+   * is irreversible. The session cannot be resumed after deletion.
    *
    * @param sessionId - The ID of the session to delete
    * @returns A promise that resolves when the session is deleted
@@ -5740,33 +6209,31 @@ var CopilotClient = class {
     this.sessions.delete(sessionId);
   }
   /**
-   * Lists all available sessions known to the server.
+   * List all available sessions.
    *
-   * Returns metadata about each session including ID, timestamps, and summary.
-   *
-   * @returns A promise that resolves with an array of session metadata
-   * @throws Error if the client is not connected
+   * @param filter - Optional filter to limit returned sessions by context fields
    *
    * @example
-   * ```typescript
+   * // List all sessions
    * const sessions = await client.listSessions();
-   * for (const session of sessions) {
-   *   console.log(`${session.sessionId}: ${session.summary}`);
-   * }
-   * ```
+   *
+   * @example
+   * // List sessions for a specific repository
+   * const sessions = await client.listSessions({ repository: "owner/repo" });
    */
-  async listSessions() {
+  async listSessions(filter) {
     if (!this.connection) {
       throw new Error("Client not connected");
     }
-    const response = await this.connection.sendRequest("session.list", {});
+    const response = await this.connection.sendRequest("session.list", { filter });
     const { sessions } = response;
     return sessions.map((s) => ({
       sessionId: s.sessionId,
       startTime: new Date(s.startTime),
       modifiedTime: new Date(s.modifiedTime),
       summary: s.summary,
-      isRemote: s.isRemote
+      isRemote: s.isRemote,
+      context: s.context
     }));
   }
   /**
@@ -5845,6 +6312,7 @@ var CopilotClient = class {
    */
   async startCLIServer() {
     return new Promise((resolve3, reject) => {
+      this.stderrBuffer = "";
       const args = [
         ...this.options.cliArgs,
         "--headless",
@@ -5876,16 +6344,18 @@ var CopilotClient = class {
       const stdioConfig = this.options.useStdio ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"];
       const isJsFile = this.options.cliPath.endsWith(".js");
       if (isJsFile) {
-        this.cliProcess = spawn(process.execPath, [this.options.cliPath, ...args], {
+        this.cliProcess = spawn(getNodeExecPath(), [this.options.cliPath, ...args], {
           stdio: stdioConfig,
           cwd: this.options.cwd,
-          env: envWithoutNodeDebug
+          env: envWithoutNodeDebug,
+          windowsHide: true
         });
       } else {
         this.cliProcess = spawn(this.options.cliPath, args, {
           stdio: stdioConfig,
           cwd: this.options.cwd,
-          env: envWithoutNodeDebug
+          env: envWithoutNodeDebug,
+          windowsHide: true
         });
       }
       let stdout = "";
@@ -5905,6 +6375,7 @@ var CopilotClient = class {
         });
       }
       this.cliProcess.stderr?.on("data", (data) => {
+        this.stderrBuffer += data.toString();
         const lines = data.toString().split("\n");
         for (const line of lines) {
           if (line.trim()) {
@@ -5916,13 +6387,54 @@ var CopilotClient = class {
       this.cliProcess.on("error", (error) => {
         if (!resolved) {
           resolved = true;
-          reject(new Error(`Failed to start CLI server: ${error.message}`));
+          const stderrOutput = this.stderrBuffer.trim();
+          if (stderrOutput) {
+            reject(
+              new Error(
+                `Failed to start CLI server: ${error.message}
+stderr: ${stderrOutput}`
+              )
+            );
+          } else {
+            reject(new Error(`Failed to start CLI server: ${error.message}`));
+          }
         }
       });
+      this.processExitPromise = new Promise((_, rejectProcessExit) => {
+        this.cliProcess.on("exit", (code) => {
+          setTimeout(() => {
+            const stderrOutput = this.stderrBuffer.trim();
+            if (stderrOutput) {
+              rejectProcessExit(
+                new Error(
+                  `CLI server exited with code ${code}
+stderr: ${stderrOutput}`
+                )
+              );
+            } else {
+              rejectProcessExit(
+                new Error(`CLI server exited unexpectedly with code ${code}`)
+              );
+            }
+          }, 50);
+        });
+      });
+      this.processExitPromise.catch(() => {
+      });
       this.cliProcess.on("exit", (code) => {
         if (!resolved) {
           resolved = true;
-          reject(new Error(`CLI server exited with code ${code}`));
+          const stderrOutput = this.stderrBuffer.trim();
+          if (stderrOutput) {
+            reject(
+              new Error(
+                `CLI server exited with code ${code}
+stderr: ${stderrOutput}`
+              )
+            );
+          } else {
+            reject(new Error(`CLI server exited with code ${code}`));
+          }
         } else if (this.options.autoRestart && this.state === "connected") {
           void this.reconnect();
         }
@@ -5939,16 +6451,18 @@ var CopilotClient = class {
    * Connect to the CLI server (via socket or stdio)
    */
   async connectToServer() {
-    if (this.options.useStdio) {
-      return this.connectViaStdio();
+    if (this.options.isChildProcess) {
+      return this.connectToParentProcessViaStdio();
+    } else if (this.options.useStdio) {
+      return this.connectToChildProcessViaStdio();
     } else {
       return this.connectViaTcp();
     }
   }
   /**
-   * Connect via stdio pipes
+   * Connect to child via stdio pipes
    */
-  async connectViaStdio() {
+  async connectToChildProcessViaStdio() {
     if (!this.cliProcess) {
       throw new Error("CLI process not started");
     }
@@ -5957,9 +6471,23 @@ var CopilotClient = class {
         throw err;
       }
     });
-    this.connection = (0, import_node.createMessageConnection)(
-      new import_node.StreamMessageReader(this.cliProcess.stdout),
-      new import_node.StreamMessageWriter(this.cliProcess.stdin)
+    this.connection = (0, import_node2.createMessageConnection)(
+      new import_node2.StreamMessageReader(this.cliProcess.stdout),
+      new import_node2.StreamMessageWriter(this.cliProcess.stdin)
+    );
+    this.attachConnectionHandlers();
+    this.connection.listen();
+  }
+  /**
+   * Connect to parent via stdio pipes
+   */
+  async connectToParentProcessViaStdio() {
+    if (this.cliProcess) {
+      throw new Error("CLI child process was unexpectedly started in parent process mode");
+    }
+    this.connection = (0, import_node2.createMessageConnection)(
+      new import_node2.StreamMessageReader(process.stdin),
+      new import_node2.StreamMessageWriter(process.stdout)
     );
     this.attachConnectionHandlers();
     this.connection.listen();
@@ -5974,9 +6502,9 @@ var CopilotClient = class {
     return new Promise((resolve3, reject) => {
       this.socket = new Socket();
       this.socket.connect(this.actualPort, this.actualHost, () => {
-        this.connection = (0, import_node.createMessageConnection)(
-          new import_node.StreamMessageReader(this.socket),
-          new import_node.StreamMessageWriter(this.socket)
+        this.connection = (0, import_node2.createMessageConnection)(
+          new import_node2.StreamMessageReader(this.socket),
+          new import_node2.StreamMessageWriter(this.socket)
         );
         this.attachConnectionHandlers();
         this.connection.listen();
@@ -5999,11 +6527,11 @@ var CopilotClient = class {
     });
     this.connection.onRequest(
       "tool.call",
-      async (params) => await this.handleToolCallRequest(params)
+      async (params) => await this.handleToolCallRequestV2(params)
     );
     this.connection.onRequest(
       "permission.request",
-      async (params) => await this.handlePermissionRequest(params)
+      async (params) => await this.handlePermissionRequestV2(params)
     );
     this.connection.onRequest(
       "userInput.request",
@@ -6051,7 +6579,41 @@ var CopilotClient = class {
       }
     }
   }
-  async handleToolCallRequest(params) {
+  async handleUserInputRequest(params) {
+    if (!params || typeof params.sessionId !== "string" || typeof params.question !== "string") {
+      throw new Error("Invalid user input request payload");
+    }
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${params.sessionId}`);
+    }
+    const result = await session._handleUserInputRequest({
+      question: params.question,
+      choices: params.choices,
+      allowFreeform: params.allowFreeform
+    });
+    return result;
+  }
+  async handleHooksInvoke(params) {
+    if (!params || typeof params.sessionId !== "string" || typeof params.hookType !== "string") {
+      throw new Error("Invalid hooks invoke payload");
+    }
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${params.sessionId}`);
+    }
+    const output = await session._handleHooksInvoke(params.hookType, params.input);
+    return { output };
+  }
+  // ========================================================================
+  // Protocol v2 backward-compatibility adapters
+  // ========================================================================
+  /**
+   * Handles a v2-style tool.call RPC request from the server.
+   * Looks up the session and tool handler, executes it, and returns the result
+   * in the v2 response format.
+   */
+  async handleToolCallRequestV2(params) {
     if (!params || typeof params.sessionId !== "string" || typeof params.toolCallId !== "string" || typeof params.toolName !== "string") {
       throw new Error("Invalid tool call payload");
     }
@@ -6061,25 +6623,28 @@ var CopilotClient = class {
     }
     const handler = session.getToolHandler(params.toolName);
     if (!handler) {
-      return { result: this.buildUnsupportedToolResult(params.toolName) };
+      return {
+        result: {
+          textResultForLlm: `Tool '${params.toolName}' is not supported by this client instance.`,
+          resultType: "failure",
+          error: `tool '${params.toolName}' not supported`,
+          toolTelemetry: {}
+        }
+      };
     }
-    return await this.executeToolCall(handler, params);
-  }
-  async executeToolCall(handler, request) {
     try {
       const invocation = {
-        sessionId: request.sessionId,
-        toolCallId: request.toolCallId,
-        toolName: request.toolName,
-        arguments: request.arguments
+        sessionId: params.sessionId,
+        toolCallId: params.toolCallId,
+        toolName: params.toolName,
+        arguments: params.arguments
       };
-      const result = await handler(request.arguments, invocation);
-      return { result: this.normalizeToolResult(result) };
+      const result = await handler(params.arguments, invocation);
+      return { result: this.normalizeToolResultV2(result) };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       return {
         result: {
-          // Don't expose detailed error information to the LLM for security reasons
           textResultForLlm: "Invoking this tool produced an error. Detailed information is not available.",
           resultType: "failure",
           error: message,
@@ -6088,7 +6653,10 @@ var CopilotClient = class {
       };
     }
   }
-  async handlePermissionRequest(params) {
+  /**
+   * Handles a v2-style permission.request RPC request from the server.
+   */
+  async handlePermissionRequestV2(params) {
     if (!params || typeof params.sessionId !== "string" || !params.permissionRequest) {
       throw new Error("Invalid permission request payload");
     }
@@ -6097,7 +6665,7 @@ var CopilotClient = class {
       throw new Error(`Session not found: ${params.sessionId}`);
     }
     try {
-      const result = await session._handlePermissionRequest(params.permissionRequest);
+      const result = await session._handlePermissionRequestV2(params.permissionRequest);
       return { result };
     } catch (_error) {
       return {
@@ -6107,33 +6675,7 @@ var CopilotClient = class {
       };
     }
   }
-  async handleUserInputRequest(params) {
-    if (!params || typeof params.sessionId !== "string" || typeof params.question !== "string") {
-      throw new Error("Invalid user input request payload");
-    }
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
-    }
-    const result = await session._handleUserInputRequest({
-      question: params.question,
-      choices: params.choices,
-      allowFreeform: params.allowFreeform
-    });
-    return result;
-  }
-  async handleHooksInvoke(params) {
-    if (!params || typeof params.sessionId !== "string" || typeof params.hookType !== "string") {
-      throw new Error("Invalid hooks invoke payload");
-    }
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
-    }
-    const output = await session._handleHooksInvoke(params.hookType, params.input);
-    return { output };
-  }
-  normalizeToolResult(result) {
+  normalizeToolResultV2(result) {
     if (result === void 0 || result === null) {
       return {
         textResultForLlm: "Tool returned no result",
@@ -6155,14 +6697,6 @@ var CopilotClient = class {
   isToolResultObject(value) {
     return typeof value === "object" && value !== null && "textResultForLlm" in value && typeof value.textResultForLlm === "string" && "resultType" in value;
   }
-  buildUnsupportedToolResult(toolName) {
-    return {
-      textResultForLlm: `Tool '${toolName}' is not supported by this client instance.`,
-      resultType: "failure",
-      error: `tool '${toolName}' not supported`,
-      toolTelemetry: {}
-    };
-  }
   /**
    * Attempt to reconnect to the server
    */
@@ -6176,6 +6710,38 @@ var CopilotClient = class {
   }
 };
 
+// node_modules/@github/copilot-sdk/dist/types.js
+var approveAll = () => ({ kind: "approved" });
+
+// 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";
+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 searchPaths = require_.resolve.paths(platformPkg) ?? [];
+    for (const base of searchPaths) {
+      const candidate = join6(base, platformPkg, binaryName);
+      if (existsSync5(candidate)) return candidate;
+    }
+  } catch {
+  }
+  let dir = dirname4(import.meta.dirname ?? __dirname);
+  for (let i = 0; i < 10; i++) {
+    const candidate = join6(dir, "node_modules", platformPkg, binaryName);
+    if (existsSync5(candidate)) return candidate;
+    const parent = dirname4(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+
 // src/L2-clients/llm/ai.ts
 function createOpenAI(...args) {
   return new default4(...args);
@@ -6191,6 +6757,7 @@ function createCopilotClient(...args) {
 init_configLogger();
 var DEFAULT_MODEL = "claude-opus-4.5";
 var DEFAULT_TIMEOUT_MS = 3e5;
+var SESSION_CREATE_TIMEOUT_MS = 3e4;
 var CopilotProvider = class {
   name = "copilot";
   client = null;
@@ -6202,21 +6769,57 @@ var CopilotProvider = class {
   }
   async createSession(config2) {
     if (!this.client) {
-      this.client = createCopilotClient({ autoStart: true, logLevel: "error" });
+      const cliPath = resolveCopilotCliPath();
+      if (cliPath) {
+        logger_default.info(`[CopilotProvider] Using native CLI binary: ${cliPath}`);
+      }
+      this.client = createCopilotClient({
+        autoStart: true,
+        autoRestart: true,
+        logLevel: "error",
+        env: buildChildEnv(),
+        ...cliPath ? { cliPath } : {}
+      });
     }
-    const copilotSession = await this.client.createSession({
-      model: config2.model,
-      mcpServers: config2.mcpServers,
-      systemMessage: { mode: "replace", content: config2.systemPrompt },
-      tools: config2.tools.map((t) => ({
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters,
-        handler: t.handler
-      })),
-      streaming: config2.streaming ?? true,
-      onUserInputRequest: config2.onUserInputRequest ? (request) => config2.onUserInputRequest(request) : void 0
-    });
+    logger_default.info("[CopilotProvider] Creating session\u2026");
+    let copilotSession;
+    try {
+      copilotSession = await new Promise((resolve3, reject) => {
+        const timeoutId = setTimeout(
+          () => reject(new Error(
+            `[CopilotProvider] createSession timed out after ${SESSION_CREATE_TIMEOUT_MS / 1e3}s \u2014 the Copilot SDK language server may not be reachable. Check GitHub authentication and network connectivity.`
+          )),
+          SESSION_CREATE_TIMEOUT_MS
+        );
+        this.client.createSession({
+          model: config2.model,
+          mcpServers: config2.mcpServers,
+          systemMessage: { mode: "replace", content: config2.systemPrompt },
+          tools: config2.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+            handler: t.handler
+          })),
+          streaming: config2.streaming ?? true,
+          onPermissionRequest: approveAll,
+          onUserInputRequest: config2.onUserInputRequest ? (request) => config2.onUserInputRequest(request) : void 0
+        }).then(
+          (session) => {
+            clearTimeout(timeoutId);
+            resolve3(session);
+          },
+          (err) => {
+            clearTimeout(timeoutId);
+            reject(err);
+          }
+        );
+      });
+    } catch (err) {
+      this.client = null;
+      throw err;
+    }
+    logger_default.info("[CopilotProvider] Session created successfully");
     return new CopilotSessionWrapper(
       copilotSession,
       config2.timeoutMs ?? DEFAULT_TIMEOUT_MS
@@ -6361,6 +6964,15 @@ var CopilotSessionWrapper = class {
     }
   }
 };
+function buildChildEnv() {
+  const env = { ...process.env };
+  const flag = "--disable-warning=ExperimentalWarning";
+  const current = env.NODE_OPTIONS ?? "";
+  if (!current.includes(flag)) {
+    env.NODE_OPTIONS = current ? `${current} ${flag}` : flag;
+  }
+  return env;
+}
 
 // src/L0-pure/pricing/pricing.ts
 var COPILOT_PRU_OVERAGE_RATE = 0.04;
@@ -6611,7 +7223,8 @@ var OpenAIProvider = class {
     return "gpt-4o";
   }
   async createSession(config2) {
-    const client = createOpenAI();
+    const appConfig = getConfig();
+    const client = createOpenAI({ apiKey: appConfig.OPENAI_API_KEY });
     const model = config2.model ?? this.getDefaultModel();
     logger_default.info(`OpenAI session created (model=${model}, tools=${config2.tools.length})`);
     return new OpenAISession(client, config2, model);
@@ -6940,16 +7553,10 @@ var LateApiClient = class {
     return data.accounts ?? [];
   }
   async getScheduledPosts(platform) {
-    const params = new URLSearchParams({ status: "scheduled" });
-    if (platform) params.set("platform", platform);
-    const data = await this.request(`/posts?${params}`);
-    return data.posts ?? [];
+    return this.listPosts({ status: "scheduled", platform });
   }
   async getDraftPosts(platform) {
-    const params = new URLSearchParams({ status: "draft" });
-    if (platform) params.set("platform", platform);
-    const data = await this.request(`/posts?${params}`);
-    return data.posts ?? [];
+    return this.listPosts({ status: "draft", platform });
   }
   async createPost(params) {
     const data = await this.request("/posts", {
@@ -7055,6 +7662,7 @@ function createLateApiClient(...args) {
 // src/L2-clients/scheduleStore/scheduleStore.ts
 init_fileSystem();
 init_paths();
+init_globalConfig();
 async function readScheduleFile(filePath) {
   return readTextFile(filePath);
 }
@@ -7066,7 +7674,10 @@ async function writeScheduleFile(filePath, content) {
   });
 }
 function resolveSchedulePath(configPath) {
-  return configPath ?? join(process.cwd(), "schedule.json");
+  if (configPath) return configPath;
+  const globalPath = getGlobalConfigValue("defaults", "scheduleConfig");
+  if (globalPath) return globalPath;
+  return join(process.cwd(), "schedule.json");
 }
 
 // src/L3-services/scheduler/scheduleConfig.ts
@@ -7331,7 +7942,7 @@ function getPlatformSchedule(platform, clipType) {
       avoidDays: sub.avoidDays
     };
   }
-  if (clipType && schedule.slots.length === 0 && schedule.byClipType) {
+  if (schedule.slots.length === 0 && schedule.byClipType) {
     const allSlots = [];
     const allAvoidDays = /* @__PURE__ */ new Set();
     for (const sub of Object.values(schedule.byClipType)) {
@@ -7352,403 +7963,23 @@ function getDisplacementConfig() {
   return cachedConfig?.displacement ?? { ...defaultDisplacement };
 }
 
-// src/L3-services/postStore/postStore.ts
-init_types();
-init_environment();
-init_configLogger();
-init_fileSystem();
-init_paths();
-function getQueueDir() {
-  const { OUTPUT_DIR } = getConfig();
-  return join(OUTPUT_DIR, "publish-queue");
-}
-function getPublishedDir() {
-  const { OUTPUT_DIR } = getConfig();
-  return join(OUTPUT_DIR, "published");
-}
-async function readQueueItem(folderPath, id) {
-  const metadataPath = join(folderPath, "metadata.json");
-  const postPath = join(folderPath, "post.md");
-  try {
-    const metadataRaw = await readTextFile(metadataPath);
-    const metadata = JSON.parse(metadataRaw);
-    let postContent = "";
-    try {
-      postContent = await readTextFile(postPath);
-    } catch {
-      logger_default.debug(`No post.md found for ${String(id).replace(/[\r\n]/g, "")}`);
-    }
-    const videoPath = join(folderPath, "media.mp4");
-    const imagePath = join(folderPath, "media.png");
-    let mediaPath = null;
-    let hasMedia = false;
-    if (await fileExists(videoPath)) {
-      mediaPath = videoPath;
-      hasMedia = true;
-    } else if (await fileExists(imagePath)) {
-      mediaPath = imagePath;
-      hasMedia = true;
-    }
-    return {
-      id,
-      metadata,
-      postContent,
-      hasMedia,
-      mediaPath,
-      folderPath
-    };
-  } catch (err) {
-    logger_default.debug(`Failed to read queue item ${String(id).replace(/[\r\n]/g, "")}: ${String(err).replace(/[\r\n]/g, "")}`);
-    return null;
-  }
-}
-async function getPendingItems() {
-  const queueDir = getQueueDir();
-  await ensureDirectory(queueDir);
-  let entries;
-  try {
-    const dirents = await listDirectoryWithTypes(queueDir);
-    entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
-  } catch {
-    return [];
-  }
-  const items = [];
-  for (const name of entries) {
-    const item = await readQueueItem(join(queueDir, name), name);
-    if (item) items.push(item);
-  }
-  items.sort((a, b) => {
-    if (a.hasMedia !== b.hasMedia) return a.hasMedia ? -1 : 1;
-    return a.metadata.createdAt.localeCompare(b.metadata.createdAt);
-  });
-  return items;
-}
-async function createItem(id, metadata, postContent, mediaSourcePath) {
-  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
-    throw new Error(`Invalid ID format: ${id}`);
-  }
-  const folderPath = join(getQueueDir(), basename(id));
-  await ensureDirectory(folderPath);
-  await writeJsonFile(join(folderPath, "metadata.json"), metadata);
-  await writeTextFile(join(folderPath, "post.md"), postContent);
-  let hasMedia = false;
-  const ext = mediaSourcePath ? extname(mediaSourcePath) : ".mp4";
-  const mediaFilename = `media${ext}`;
-  const mediaPath = join(folderPath, mediaFilename);
-  if (mediaSourcePath) {
-    await copyFile(mediaSourcePath, mediaPath);
-    hasMedia = true;
-  }
-  logger_default.debug(`Created queue item: ${String(id).replace(/[\r\n]/g, "")}`);
-  return {
-    id,
-    metadata,
-    postContent,
-    hasMedia,
-    mediaPath: hasMedia ? mediaPath : null,
-    folderPath
-  };
-}
-async function getPublishedItems() {
-  const publishedDir = getPublishedDir();
-  await ensureDirectory(publishedDir);
-  let entries;
-  try {
-    const dirents = await listDirectoryWithTypes(publishedDir);
-    entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
-  } catch {
-    return [];
-  }
-  const items = [];
-  for (const name of entries) {
-    const item = await readQueueItem(join(publishedDir, name), name);
-    if (item) items.push(item);
-  }
-  items.sort((a, b) => a.metadata.createdAt.localeCompare(b.metadata.createdAt));
-  return items;
-}
-async function getScheduledItemsByIdeaIds(ideaIds) {
-  if (ideaIds.length === 0) return [];
-  const ideaIdSet = new Set(ideaIds);
-  const [pendingItems, publishedItems] = await Promise.all([
-    getPendingItems(),
-    getPublishedItems()
-  ]);
-  return [...pendingItems, ...publishedItems].filter(
-    (item) => item.metadata.ideaIds?.some((id) => ideaIdSet.has(id)) ?? false
-  );
-}
-async function getPublishedItemByLatePostId(latePostId) {
-  const publishedItems = await getPublishedItems();
-  return publishedItems.find((item) => item.metadata.latePostId === latePostId) ?? null;
-}
-async function itemExists(id) {
-  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
-    throw new Error(`Invalid ID format: ${id}`);
-  }
-  if (await fileExists(join(getQueueDir(), basename(id)))) {
-    return "pending";
-  }
-  if (await fileExists(join(getPublishedDir(), basename(id)))) {
-    return "published";
-  }
-  return null;
-}
-
 // src/L3-services/scheduler/realign.ts
+init_postStore();
 init_configLogger();
-function getTimezoneOffset(timezone, date) {
-  const formatter = new Intl.DateTimeFormat("en-US", {
-    timeZone: timezone,
-    timeZoneName: "longOffset"
-  });
-  const parts = formatter.formatToParts(date);
-  const tzPart = parts.find((p) => p.type === "timeZoneName");
-  const match = tzPart?.value?.match(/GMT([+-]\d{2}:\d{2})/);
-  if (match) return match[1];
-  if (tzPart?.value === "GMT") return "+00:00";
-  return "+00:00";
-}
-function buildSlotDatetime(date, time, timezone) {
-  const formatter = new Intl.DateTimeFormat("en-US", {
-    timeZone: timezone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit"
-  });
-  const parts = formatter.formatToParts(date);
-  const year = parts.find((p) => p.type === "year")?.value ?? String(date.getFullYear());
-  const month = (parts.find((p) => p.type === "month")?.value ?? String(date.getMonth() + 1)).padStart(2, "0");
-  const day = (parts.find((p) => p.type === "day")?.value ?? String(date.getDate())).padStart(2, "0");
-  const offset = getTimezoneOffset(timezone, date);
-  return `${year}-${month}-${day}T${time}:00${offset}`;
-}
-function getDayOfWeekInTimezone(date, timezone) {
-  const formatter = new Intl.DateTimeFormat("en-US", {
-    timeZone: timezone,
-    weekday: "short"
-  });
-  const short = formatter.format(date).toLowerCase().slice(0, 3);
-  const map = {
-    sun: "sun",
-    mon: "mon",
-    tue: "tue",
-    wed: "wed",
-    thu: "thu",
-    fri: "fri",
-    sat: "sat"
-  };
-  return map[short] ?? "mon";
-}
-var PLATFORM_ALIASES2 = { twitter: "x" };
-function normalizeSchedulePlatform(platform) {
-  return PLATFORM_ALIASES2[platform] ?? platform;
-}
-function normalizeContent(content) {
-  return content.toLowerCase().replace(/\s+/g, " ").trim().slice(0, 200);
-}
-async function buildClipTypeMaps() {
-  const published = await getPublishedItems();
-  const byLatePostId = /* @__PURE__ */ new Map();
-  const byContent = /* @__PURE__ */ new Map();
-  for (const item of published) {
-    if (item.metadata.latePostId) {
-      byLatePostId.set(item.metadata.latePostId, item.metadata.clipType);
-    }
-    if (item.postContent) {
-      const contentKey = `${item.metadata.platform}::${normalizeContent(item.postContent)}`;
-      byContent.set(contentKey, item.metadata.clipType);
-    }
-  }
-  logger_default.debug(`Built clipType maps: ${byLatePostId.size} by latePostId, ${byContent.size} by content`);
-  return { byLatePostId, byContent };
-}
-async function fetchAllPosts(client, statuses, platform) {
-  const allPosts = [];
-  for (const status of statuses) {
-    const posts = await client.listPosts({ status, platform });
-    allPosts.push(...posts);
-    logger_default.info(`Fetched ${posts.length} ${status} post(s)${platform ? ` for ${platform}` : ""}`);
-  }
-  return allPosts;
-}
-function generateSlots(platform, clipType, count, bookedMs, timezone) {
-  const schedule = getPlatformSchedule(platform, clipType);
-  if (!schedule || schedule.slots.length === 0) {
-    logger_default.warn(`No schedule slots for ${platform}/${clipType}`);
-    return [];
-  }
-  const available = [];
-  const now = /* @__PURE__ */ new Date();
-  const nowMs = now.getTime();
-  for (let dayOffset = 0; dayOffset < 730 && available.length < count; dayOffset++) {
-    const day = new Date(now);
-    day.setDate(day.getDate() + dayOffset);
-    const dayOfWeek = getDayOfWeekInTimezone(day, timezone);
-    if (schedule.avoidDays.includes(dayOfWeek)) continue;
-    for (const slot of schedule.slots) {
-      if (available.length >= count) break;
-      if (!slot.days.includes(dayOfWeek)) continue;
-      const iso = buildSlotDatetime(day, slot.time, timezone);
-      const ms = new Date(iso).getTime();
-      if (ms <= nowMs) continue;
-      if (!bookedMs.has(ms)) {
-        available.push(iso);
-        bookedMs.add(ms);
-      }
-    }
-  }
-  return available;
-}
-async function buildRealignPlan(options = {}) {
-  const config2 = await loadScheduleConfig();
-  const { timezone } = config2;
-  const client = new LateApiClient();
-  const statuses = ["scheduled", "draft", "cancelled", "failed"];
-  const allPosts = await fetchAllPosts(client, statuses, options.platform);
-  if (allPosts.length === 0) {
-    return { posts: [], toCancel: [], skipped: 0, unmatched: 0, totalFetched: 0 };
-  }
-  const { byLatePostId, byContent } = options.clipTypeMaps ?? await buildClipTypeMaps();
-  const grouped = /* @__PURE__ */ new Map();
-  let unmatched = 0;
-  let contentMatched = 0;
-  for (const post of allPosts) {
-    const platform = post.platforms[0]?.platform;
-    if (!platform) continue;
-    let clipType = byLatePostId.get(post._id) ?? null;
-    if (!clipType && post.content) {
-      const contentKey = `${platform}::${normalizeContent(post.content)}`;
-      clipType = byContent.get(contentKey) ?? null;
-      if (clipType) contentMatched++;
-    }
-    if (!clipType) {
-      clipType = "short";
-      unmatched++;
-    }
-    const key = `${platform}::${clipType}`;
-    if (!grouped.has(key)) grouped.set(key, []);
-    grouped.get(key).push({ post, platform, clipType });
-  }
-  const bookedMs = /* @__PURE__ */ new Set();
-  if (contentMatched > 0) {
-    logger_default.info(`${contentMatched} post(s) matched by content fallback (no latePostId)`);
-  }
-  const result = [];
-  const toCancel = [];
-  let skipped = 0;
-  for (const [key, posts] of grouped) {
-    const [platform, clipType] = key.split("::");
-    const schedulePlatform = normalizeSchedulePlatform(platform);
-    const schedule = getPlatformSchedule(schedulePlatform, clipType);
-    const hasSlots = schedule && schedule.slots.length > 0;
-    if (!hasSlots) {
-      for (const { post, clipType: ct } of posts) {
-        if (post.status === "cancelled") continue;
-        toCancel.push({
-          post,
-          platform,
-          clipType: ct,
-          reason: `No schedule slots for ${schedulePlatform}/${clipType}`
-        });
-      }
-      continue;
-    }
-    posts.sort((a, b) => {
-      const aTime = a.post.scheduledFor ? new Date(a.post.scheduledFor).getTime() : Infinity;
-      const bTime = b.post.scheduledFor ? new Date(b.post.scheduledFor).getTime() : Infinity;
-      return aTime - bTime;
-    });
-    const slots = generateSlots(schedulePlatform, clipType, posts.length, bookedMs, timezone);
-    for (let i = 0; i < posts.length; i++) {
-      const { post } = posts[i];
-      const newSlot = slots[i];
-      if (!newSlot) {
-        if (post.status !== "cancelled") {
-          toCancel.push({
-            post,
-            platform,
-            clipType: posts[i].clipType,
-            reason: `No more available slots for ${schedulePlatform}/${clipType}`
-          });
-        }
-        continue;
-      }
-      const currentMs = post.scheduledFor ? new Date(post.scheduledFor).getTime() : 0;
-      const newMs = new Date(newSlot).getTime();
-      if (currentMs === newMs && post.status === "scheduled") {
-        skipped++;
-        continue;
-      }
-      result.push({
-        post,
-        platform,
-        clipType: posts[i].clipType,
-        oldScheduledFor: post.scheduledFor ?? null,
-        newScheduledFor: newSlot
-      });
-    }
-  }
-  result.sort((a, b) => new Date(a.newScheduledFor).getTime() - new Date(b.newScheduledFor).getTime());
-  return { posts: result, toCancel, skipped, unmatched, totalFetched: allPosts.length };
-}
-async function executeRealignPlan(plan, onProgress) {
-  const client = new LateApiClient();
-  let updated = 0;
-  let cancelled = 0;
-  let failed = 0;
-  const errors = [];
-  const totalOps = plan.toCancel.length + plan.posts.length;
-  let completed = 0;
-  for (const entry of plan.toCancel) {
-    completed++;
-    try {
-      await client.updatePost(entry.post._id, { status: "cancelled" });
-      cancelled++;
-      const preview = entry.post.content.slice(0, 40).replace(/\n/g, " ");
-      logger_default.info(`[${completed}/${totalOps}] \u{1F6AB} Cancelled ${entry.platform}/${entry.clipType}: "${preview}..."`);
-      onProgress?.(completed, totalOps, "cancelling");
-      await new Promise((r) => setTimeout(r, 300));
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      errors.push({ postId: entry.post._id, error: msg });
-      failed++;
-      logger_default.error(`[${completed}/${totalOps}] \u274C Failed to cancel ${entry.post._id}: ${msg}`);
-    }
-  }
-  for (const entry of plan.posts) {
-    completed++;
-    try {
-      await client.schedulePost(entry.post._id, entry.newScheduledFor);
-      updated++;
-      const preview = entry.post.content.slice(0, 40).replace(/\n/g, " ");
-      logger_default.info(`[${completed}/${totalOps}] \u2705 ${entry.platform}/${entry.clipType}: "${preview}..." \u2192 ${entry.newScheduledFor}`);
-      onProgress?.(completed, totalOps, "updating");
-      await new Promise((r) => setTimeout(r, 300));
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      errors.push({ postId: entry.post._id, error: msg });
-      failed++;
-      logger_default.error(`[${completed}/${totalOps}] \u274C Failed to update ${entry.post._id}: ${msg}`);
-    }
-  }
-  return { updated, cancelled, failed, errors };
-}
 
 // src/L3-services/scheduler/scheduler.ts
 init_configLogger();
-function normalizeDateTime(isoString) {
-  return new Date(isoString).getTime();
-}
-var CHUNK_DAYS = 14;
+init_postStore();
 var MAX_LOOKAHEAD_DAYS = 730;
-var DEFAULT_IDEA_WINDOW_DAYS = 14;
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var HOUR_MS = 60 * 60 * 1e3;
+function normalizeDateTime(isoString) {
+  return new Date(isoString).getTime();
+}
 function sanitizeLogValue(value) {
   return value.replace(/[\r\n]/g, "");
 }
-function getTimezoneOffset2(timezone, date) {
+function getTimezoneOffset(timezone, date) {
   const formatter = new Intl.DateTimeFormat("en-US", {
     timeZone: timezone,
     timeZoneName: "longOffset"
@@ -7763,7 +7994,7 @@ function getTimezoneOffset2(timezone, date) {
   );
   return "+00:00";
 }
-function buildSlotDatetime2(date, time, timezone) {
+function buildSlotDatetime(date, time, timezone) {
   const formatter = new Intl.DateTimeFormat("en-US", {
     timeZone: timezone,
     year: "numeric",
@@ -7777,10 +8008,10 @@ function buildSlotDatetime2(date, time, timezone) {
   const year = yearPart ?? String(date.getFullYear());
   const month = (monthPart ?? String(date.getMonth() + 1)).padStart(2, "0");
   const day = (dayPart ?? String(date.getDate())).padStart(2, "0");
-  const offset = getTimezoneOffset2(timezone, date);
+  const offset = getTimezoneOffset(timezone, date);
   return `${year}-${month}-${day}T${time}:00${offset}`;
 }
-function getDayOfWeekInTimezone2(date, timezone) {
+function getDayOfWeekInTimezone(date, timezone) {
   const formatter = new Intl.DateTimeFormat("en-US", {
     timeZone: timezone,
     weekday: "short"
@@ -7807,22 +8038,30 @@ async function fetchScheduledPostsSafe(platform) {
     return [];
   }
 }
-async function buildBookedSlots(platform) {
+async function buildBookedMap(platform) {
   const [latePosts, publishedItems] = await Promise.all([
     fetchScheduledPostsSafe(platform),
     getPublishedItems()
   ]);
-  const slots = [];
+  const ideaLinkedPostIds = /* @__PURE__ */ new Set();
+  for (const item of publishedItems) {
+    if (item.metadata.latePostId && item.metadata.ideaIds?.length) {
+      ideaLinkedPostIds.add(item.metadata.latePostId);
+    }
+  }
+  const map = /* @__PURE__ */ new Map();
   for (const post of latePosts) {
     if (!post.scheduledFor) continue;
     for (const scheduledPlatform of post.platforms) {
       if (!platform || scheduledPlatform.platform === platform) {
-        slots.push({
+        const ms = normalizeDateTime(post.scheduledFor);
+        map.set(ms, {
           scheduledFor: post.scheduledFor,
           source: "late",
           postId: post._id,
           platform: scheduledPlatform.platform,
-          status: post.status
+          status: post.status,
+          ideaLinked: ideaLinkedPostIds.has(post._id)
         });
       }
     }
@@ -7830,207 +8069,168 @@ async function buildBookedSlots(platform) {
   for (const item of publishedItems) {
     if (platform && item.metadata.platform !== platform) continue;
     if (!item.metadata.scheduledFor) continue;
-    slots.push({
-      scheduledFor: item.metadata.scheduledFor,
-      source: "local",
-      itemId: item.id,
-      platform: item.metadata.platform
-    });
+    const ms = normalizeDateTime(item.metadata.scheduledFor);
+    if (!map.has(ms)) {
+      map.set(ms, {
+        scheduledFor: item.metadata.scheduledFor,
+        source: "local",
+        itemId: item.id,
+        platform: item.metadata.platform,
+        ideaLinked: Boolean(item.metadata.ideaIds?.length)
+      });
+    }
   }
-  return slots;
+  return map;
 }
-function buildIdeaReferences(sameIdeaPosts, allBookedSlots) {
+async function getIdeaLinkedLatePostIds() {
+  const publishedItems = await getPublishedItems();
+  const ids = /* @__PURE__ */ new Set();
+  for (const item of publishedItems) {
+    if (item.metadata.latePostId && item.metadata.ideaIds?.length) {
+      ids.add(item.metadata.latePostId);
+    }
+  }
+  return ids;
+}
+function* generateTimeslots(platformConfig, timezone, fromMs, maxMs) {
+  const baseDate = new Date(fromMs);
+  const upperMs = maxMs ?? fromMs + MAX_LOOKAHEAD_DAYS * DAY_MS;
+  for (let dayOffset = 0; dayOffset <= MAX_LOOKAHEAD_DAYS; dayOffset++) {
+    const day = new Date(baseDate);
+    day.setDate(day.getDate() + dayOffset);
+    const dayOfWeek = getDayOfWeekInTimezone(day, timezone);
+    if (platformConfig.avoidDays.includes(dayOfWeek)) continue;
+    const dayCandidates = [];
+    for (const slot of platformConfig.slots) {
+      if (!slot.days.includes(dayOfWeek)) continue;
+      const datetime = buildSlotDatetime(day, slot.time, timezone);
+      const ms = normalizeDateTime(datetime);
+      if (ms <= fromMs) continue;
+      if (ms > upperMs) continue;
+      dayCandidates.push({ datetime, ms });
+    }
+    dayCandidates.sort((a, b) => a.ms - b.ms);
+    for (const candidate of dayCandidates) yield candidate;
+    if (dayCandidates.length === 0) {
+      const dayStartMs = normalizeDateTime(buildSlotDatetime(day, "00:00", timezone));
+      if (dayStartMs > upperMs) break;
+    }
+  }
+}
+function passesIdeaSpacing(candidateMs, candidatePlatform, ideaRefs, samePlatformMs, crossPlatformMs) {
+  for (const ref of ideaRefs) {
+    const diff = Math.abs(candidateMs - ref.scheduledForMs);
+    if (ref.platform === candidatePlatform && diff < samePlatformMs) return false;
+    if (diff < crossPlatformMs) return false;
+  }
+  return true;
+}
+async function getIdeaReferences(ideaIds, bookedMap) {
+  const sameIdeaPosts = await getScheduledItemsByIdeaIds(ideaIds);
   const lateSlotsByPostId = /* @__PURE__ */ new Map();
   const localSlotsByItemId = /* @__PURE__ */ new Map();
-  for (const slot of allBookedSlots) {
+  for (const slot of bookedMap.values()) {
     if (slot.postId) {
-      const slots = lateSlotsByPostId.get(slot.postId) ?? [];
-      slots.push(slot);
-      lateSlotsByPostId.set(slot.postId, slots);
+      const arr = lateSlotsByPostId.get(slot.postId) ?? [];
+      arr.push(slot);
+      lateSlotsByPostId.set(slot.postId, arr);
     }
     if (slot.itemId) {
-      const slots = localSlotsByItemId.get(slot.itemId) ?? [];
-      slots.push(slot);
-      localSlotsByItemId.set(slot.itemId, slots);
+      const arr = localSlotsByItemId.get(slot.itemId) ?? [];
+      arr.push(slot);
+      localSlotsByItemId.set(slot.itemId, arr);
     }
   }
-  const references = [];
+  const refs = [];
   const seen = /* @__PURE__ */ new Set();
-  const addReference = (platformName, scheduledFor) => {
+  const addRef = (platform, scheduledFor) => {
     if (!scheduledFor) return;
-    const key = `${platformName}@${scheduledFor}`;
+    const key = `${platform}@${scheduledFor}`;
     if (seen.has(key)) return;
     seen.add(key);
-    references.push({ platform: platformName, scheduledFor });
+    refs.push({ platform, scheduledForMs: normalizeDateTime(scheduledFor) });
   };
   for (const item of sameIdeaPosts) {
-    addReference(item.metadata.platform, item.metadata.scheduledFor);
+    addRef(item.metadata.platform, item.metadata.scheduledFor);
     if (item.metadata.latePostId) {
       for (const slot of lateSlotsByPostId.get(item.metadata.latePostId) ?? []) {
-        addReference(slot.platform, slot.scheduledFor);
+        addRef(slot.platform, slot.scheduledFor);
       }
     }
     for (const slot of localSlotsByItemId.get(item.id) ?? []) {
-      addReference(slot.platform, slot.scheduledFor);
+      addRef(slot.platform, slot.scheduledFor);
+    }
+  }
+  return refs;
+}
+async function schedulePost(platformConfig, fromMs, isIdeaPost, label, ctx) {
+  const indent = "  ".repeat(ctx.depth);
+  let checked = 0;
+  let skippedBooked = 0;
+  let skippedSpacing = 0;
+  logger_default.debug(`${indent}[schedulePost] Looking for slot for ${label} (idea=${isIdeaPost}) from ${new Date(fromMs).toISOString()}`);
+  for (const { datetime, ms } of generateTimeslots(platformConfig, ctx.timezone, fromMs)) {
+    checked++;
+    const booked = ctx.bookedMap.get(ms);
+    if (!booked) {
+      if (isIdeaPost && ctx.ideaRefs.length > 0 && !passesIdeaSpacing(ms, ctx.platform, ctx.ideaRefs, ctx.samePlatformMs, ctx.crossPlatformMs)) {
+        skippedSpacing++;
+        if (skippedSpacing <= 5 || skippedSpacing % 50 === 0) {
+          logger_default.debug(`${indent}[schedulePost] \u23ED\uFE0F Slot ${datetime} too close to same-idea post \u2014 skipping`);
+        }
+        continue;
+      }
+      logger_default.debug(`${indent}[schedulePost] \u2705 Found empty slot: ${datetime} (checked ${checked} candidates, skipped ${skippedBooked} booked, ${skippedSpacing} spacing)`);
+      return datetime;
     }
-  }
-  return references;
-}
-function createSpacingGuard(ideaReferences, samePlatformHours, crossPlatformHours) {
-  const samePlatformWindowMs = samePlatformHours * HOUR_MS;
-  const crossPlatformWindowMs = crossPlatformHours * HOUR_MS;
-  return (candidateMs, candidatePlatform) => {
-    for (const reference of ideaReferences) {
-      const referenceMs = normalizeDateTime(reference.scheduledFor);
-      const diff = Math.abs(candidateMs - referenceMs);
-      if (reference.platform === candidatePlatform && diff < samePlatformWindowMs) {
-        return false;
+    if (isIdeaPost && ctx.displacementEnabled && !booked.ideaLinked && booked.source === "late" && booked.postId) {
+      if (ctx.ideaRefs.length > 0 && !passesIdeaSpacing(ms, ctx.platform, ctx.ideaRefs, ctx.samePlatformMs, ctx.crossPlatformMs)) {
+        skippedSpacing++;
+        if (skippedSpacing <= 5 || skippedSpacing % 50 === 0) {
+          logger_default.debug(`${indent}[schedulePost] \u23ED\uFE0F Slot ${datetime} too close to same-idea post \u2014 skipping (even though displaceable)`);
+        }
+        continue;
       }
-      if (diff < crossPlatformWindowMs) {
-        return false;
+      logger_default.info(`${indent}[schedulePost] \u{1F504} Slot ${datetime} taken by non-idea post ${booked.postId} \u2014 displacing`);
+      const newHome = await schedulePost(
+        platformConfig,
+        ms,
+        false,
+        `displaced:${booked.postId}`,
+        { ...ctx, depth: ctx.depth + 1 }
+      );
+      if (newHome) {
+        if (!ctx.dryRun) {
+          try {
+            await ctx.lateClient.schedulePost(booked.postId, newHome);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger_default.warn(`${indent}[schedulePost] \u26A0\uFE0F Failed to displace ${booked.postId} via Late API: ${msg} \u2014 skipping slot`);
+            continue;
+          }
+        }
+        logger_default.info(`${indent}[schedulePost] \u{1F4E6} Displaced ${booked.postId}: ${datetime} \u2192 ${newHome}`);
+        ctx.bookedMap.delete(ms);
+        const newMs = normalizeDateTime(newHome);
+        ctx.bookedMap.set(newMs, { ...booked, scheduledFor: newHome });
+        logger_default.debug(`${indent}[schedulePost] \u2705 Taking slot: ${datetime} (checked ${checked} candidates)`);
+        return datetime;
       }
+      logger_default.warn(`${indent}[schedulePost] \u26A0\uFE0F Could not displace ${booked.postId} \u2014 no empty slot found after ${datetime}`);
     }
-    return true;
-  };
-}
-function resolveSearchWindow(nowMs, options) {
-  const defaultWindowEndMs = nowMs + DEFAULT_IDEA_WINDOW_DAYS * DAY_MS;
-  const publishBy = options?.publishBy;
-  if (!publishBy) {
-    return {
-      emptyWindowEndMs: defaultWindowEndMs,
-      displacementWindowEndMs: defaultWindowEndMs
-    };
-  }
-  const publishByMs = normalizeDateTime(publishBy);
-  if (Number.isNaN(publishByMs)) {
-    logger_default.warn(`Invalid publishBy "${sanitizeLogValue(publishBy)}" provided; scheduling normally without urgency bias`);
-    return {};
-  }
-  const daysUntilPublishBy = (publishByMs - nowMs) / DAY_MS;
-  if (daysUntilPublishBy <= 0) {
-    logger_default.warn(`publishBy "${sanitizeLogValue(publishBy)}" has already passed; scheduling normally without urgency bias`);
-    return {};
-  }
-  if (daysUntilPublishBy < 3) {
-    logger_default.debug(`Urgent publishBy "${sanitizeLogValue(publishBy)}"; prioritizing earliest displaceable slot`);
-  }
-  return {
-    emptyWindowEndMs: publishByMs,
-    displacementWindowEndMs: daysUntilPublishBy < 7 ? Math.min(publishByMs, nowMs + 3 * DAY_MS) : publishByMs
-  };
-}
-function findEmptySlot({
-  platformConfig,
-  timezone,
-  bookedDatetimes,
-  platform,
-  searchFromMs,
-  includeSearchDay = false,
-  maxCandidateMs,
-  passesCandidate
-}) {
-  if (maxCandidateMs !== void 0 && maxCandidateMs < searchFromMs) {
-    return null;
-  }
-  const baseDate = new Date(searchFromMs);
-  const initialOffset = includeSearchDay ? 0 : 1;
-  let maxDayOffset = MAX_LOOKAHEAD_DAYS;
-  if (maxCandidateMs !== void 0) {
-    maxDayOffset = Math.min(
-      MAX_LOOKAHEAD_DAYS,
-      Math.max(initialOffset, Math.ceil((maxCandidateMs - searchFromMs) / DAY_MS))
-    );
-  }
-  let startOffset = initialOffset;
-  while (startOffset <= maxDayOffset) {
-    const endOffset = Math.min(startOffset + CHUNK_DAYS - 1, maxDayOffset);
-    const candidates = [];
-    for (let dayOffset = startOffset; dayOffset <= endOffset; dayOffset++) {
-      const candidateDate = new Date(baseDate);
-      candidateDate.setDate(candidateDate.getDate() + dayOffset);
-      const dayOfWeek = getDayOfWeekInTimezone2(candidateDate, timezone);
-      if (platformConfig.avoidDays.includes(dayOfWeek)) continue;
-      for (const slot of platformConfig.slots) {
-        if (!slot.days.includes(dayOfWeek)) continue;
-        const candidate = buildSlotDatetime2(candidateDate, slot.time, timezone);
-        const candidateMs = normalizeDateTime(candidate);
-        if (candidateMs <= searchFromMs) continue;
-        if (maxCandidateMs !== void 0 && candidateMs > maxCandidateMs) continue;
-        if (bookedDatetimes.has(candidateMs)) continue;
-        if (passesCandidate && !passesCandidate(candidateMs, platform)) continue;
-        candidates.push(candidate);
-      }
-    }
-    candidates.sort((left, right) => normalizeDateTime(left) - normalizeDateTime(right));
-    if (candidates.length > 0) {
-      return candidates[0];
-    }
-    startOffset = endOffset + 1;
-  }
-  return null;
-}
-async function tryDisplacement({
-  bookedSlots,
-  platform,
-  platformConfig,
-  timezone,
-  bookedDatetimes,
-  options,
-  nowMs,
-  maxCandidateMs,
-  passesSpacing
-}) {
-  const displacementConfig = getDisplacementConfig();
-  if (!displacementConfig.enabled || !options.ideaIds?.length) {
-    return null;
-  }
-  const candidateSlots = bookedSlots.filter((slot) => {
-    const slotMs = normalizeDateTime(slot.scheduledFor);
-    if (slotMs <= nowMs) return false;
-    if (maxCandidateMs !== void 0 && slotMs > maxCandidateMs) return false;
-    return true;
-  }).sort((left, right) => normalizeDateTime(left.scheduledFor) - normalizeDateTime(right.scheduledFor));
-  const lateClient = new LateApiClient();
-  const publishedItemCache = /* @__PURE__ */ new Map();
-  for (const slot of candidateSlots) {
-    if (slot.source !== "late" || !slot.postId) continue;
-    const candidateMs = normalizeDateTime(slot.scheduledFor);
-    if (passesSpacing && !passesSpacing(candidateMs, platform)) continue;
-    let publishedItem = publishedItemCache.get(slot.postId);
-    if (publishedItem === void 0) {
-      publishedItem = await getPublishedItemByLatePostId(slot.postId);
-      publishedItemCache.set(slot.postId, publishedItem);
-    }
-    if (!publishedItem) {
+    if (booked.ideaLinked) {
+      skippedBooked++;
+      if (skippedBooked <= 5 || skippedBooked % 50 === 0) {
+        logger_default.debug(`${indent}[schedulePost] \u23ED\uFE0F Slot ${datetime} taken by idea post ${booked.postId ?? booked.itemId} \u2014 skipping`);
+      }
       continue;
     }
-    if (publishedItem.metadata.ideaIds?.length) {
-      continue;
+    skippedBooked++;
+    if (skippedBooked <= 5 || skippedBooked % 50 === 0) {
+      logger_default.debug(`${indent}[schedulePost] \u23ED\uFE0F Slot ${datetime} taken (${booked.source}/${booked.postId ?? booked.itemId}) \u2014 skipping`);
     }
-    const displacedPlatformConfig = publishedItem?.metadata.clipType ? getPlatformSchedule(platform, publishedItem.metadata.clipType) ?? platformConfig : platformConfig;
-    const newSlot = findEmptySlot({
-      platformConfig: displacedPlatformConfig,
-      timezone,
-      bookedDatetimes,
-      platform,
-      searchFromMs: candidateMs,
-      includeSearchDay: true
-    });
-    if (!newSlot) continue;
-    await lateClient.schedulePost(slot.postId, newSlot);
-    logger_default.info(
-      `Displaced post ${sanitizeLogValue(slot.postId)} from ${sanitizeLogValue(slot.scheduledFor)} to ${sanitizeLogValue(newSlot)} for idea-linked content`
-    );
-    return {
-      slot: slot.scheduledFor,
-      displaced: {
-        postId: slot.postId,
-        originalSlot: slot.scheduledFor,
-        newSlot
-      }
-    };
   }
+  logger_default.warn(`[schedulePost] \u274C No slot found for ${label} \u2014 checked ${checked} candidates, skipped ${skippedBooked} booked, ${skippedSpacing} spacing`);
   return null;
 }
 async function findNextSlot(platform, clipType, options) {
@@ -8040,58 +8240,46 @@ async function findNextSlot(platform, clipType, options) {
     logger_default.warn(`No schedule config found for platform "${sanitizeLogValue(platform)}"`);
     return null;
   }
+  const { timezone } = config2;
+  const nowMs = Date.now();
   const ideaIds = options?.ideaIds?.filter(Boolean) ?? [];
   const isIdeaAware = ideaIds.length > 0;
-  const nowMs = Date.now();
-  const { timezone } = config2;
-  const [allBookedSlots, sameIdeaPosts] = await Promise.all([
-    isIdeaAware ? buildBookedSlots() : Promise.resolve([]),
-    isIdeaAware ? getScheduledItemsByIdeaIds(ideaIds) : Promise.resolve([])
-  ]);
-  const bookedSlots = isIdeaAware ? allBookedSlots.filter((slot) => slot.platform === platform) : await buildBookedSlots(platform);
-  const bookedDatetimes = new Set(bookedSlots.map((slot) => normalizeDateTime(slot.scheduledFor)));
-  const spacingConfig = isIdeaAware ? getIdeaSpacingConfig() : null;
-  const spacingGuard = spacingConfig ? createSpacingGuard(
-    buildIdeaReferences(sameIdeaPosts, allBookedSlots),
-    spacingConfig.samePlatformHours,
-    spacingConfig.crossPlatformHours
-  ) : void 0;
-  const searchWindow = isIdeaAware ? resolveSearchWindow(nowMs, options) : {};
-  const emptySlot = findEmptySlot({
-    platformConfig,
-    timezone,
-    bookedDatetimes,
-    platform,
-    searchFromMs: nowMs,
-    maxCandidateMs: searchWindow.emptyWindowEndMs,
-    passesCandidate: spacingGuard
-  });
-  if (emptySlot) {
-    logger_default.debug(`Found available slot for ${sanitizeLogValue(platform)}: ${sanitizeLogValue(emptySlot)}`);
-    return emptySlot;
-  }
+  const bookedMap = await buildBookedMap(platform);
+  const ideaLinkedPostIds = await getIdeaLinkedLatePostIds();
+  const label = `${platform}/${clipType ?? "default"}`;
+  let ideaRefs = [];
+  let samePlatformMs = 0;
+  let crossPlatformMs = 0;
   if (isIdeaAware) {
-    const displaced = await tryDisplacement({
-      bookedSlots,
-      platform,
-      platformConfig,
-      timezone,
-      bookedDatetimes,
-      options: { ...options, ideaIds },
-      nowMs,
-      maxCandidateMs: searchWindow.displacementWindowEndMs,
-      passesSpacing: spacingGuard
-    });
-    if (displaced) {
-      return displaced.slot;
-    }
+    const allBookedMap = await buildBookedMap();
+    ideaRefs = await getIdeaReferences(ideaIds, allBookedMap);
+    const spacingConfig = getIdeaSpacingConfig();
+    samePlatformMs = spacingConfig.samePlatformHours * HOUR_MS;
+    crossPlatformMs = spacingConfig.crossPlatformHours * HOUR_MS;
+  }
+  logger_default.info(`[findNextSlot] Scheduling ${label} (idea=${isIdeaAware}, booked=${bookedMap.size} slots, spacingRefs=${ideaRefs.length})`);
+  const ctx = {
+    timezone,
+    bookedMap,
+    ideaLinkedPostIds,
+    lateClient: new LateApiClient(),
+    displacementEnabled: getDisplacementConfig().enabled,
+    dryRun: false,
+    depth: 0,
+    ideaRefs,
+    samePlatformMs,
+    crossPlatformMs,
+    platform
+  };
+  const result = await schedulePost(platformConfig, nowMs, isIdeaAware, label, ctx);
+  if (!result) {
+    logger_default.warn(`[findNextSlot] No available slot for "${sanitizeLogValue(platform)}" within ${MAX_LOOKAHEAD_DAYS} days`);
   }
-  logger_default.warn(`No available slot found for "${sanitizeLogValue(platform)}" within ${MAX_LOOKAHEAD_DAYS} days`);
-  return null;
+  return result;
 }
 async function getScheduleCalendar(startDate, endDate) {
-  const slots = await buildBookedSlots();
-  let filtered = slots.filter((slot) => slot.source === "local" || slot.status === "scheduled").map((slot) => ({
+  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,
@@ -8110,6 +8298,206 @@ async function getScheduleCalendar(startDate, endDate) {
   return filtered;
 }
 
+// src/L3-services/scheduler/realign.ts
+var PLATFORM_ALIASES2 = { twitter: "x" };
+function normalizeSchedulePlatform(platform) {
+  return PLATFORM_ALIASES2[platform] ?? platform;
+}
+function normalizeContent(content) {
+  return content.toLowerCase().replace(/\s+/g, " ").trim().slice(0, 200);
+}
+async function buildClipTypeMaps() {
+  const published = await getPublishedItems();
+  const byLatePostId = /* @__PURE__ */ new Map();
+  const byContent = /* @__PURE__ */ new Map();
+  for (const item of published) {
+    if (item.metadata.latePostId) {
+      byLatePostId.set(item.metadata.latePostId, item.metadata.clipType);
+    }
+    if (item.postContent) {
+      const contentKey = `${item.metadata.platform}::${normalizeContent(item.postContent)}`;
+      byContent.set(contentKey, item.metadata.clipType);
+    }
+  }
+  logger_default.debug(`Built clipType maps: ${byLatePostId.size} by latePostId, ${byContent.size} by content`);
+  return { byLatePostId, byContent };
+}
+async function fetchAllPosts(client, statuses, platform) {
+  const allPosts = [];
+  for (const status of statuses) {
+    const posts = await client.listPosts({ status, platform });
+    allPosts.push(...posts);
+    logger_default.info(`Fetched ${posts.length} ${status} post(s)${platform ? ` for ${platform}` : ""}`);
+  }
+  return allPosts;
+}
+function isOnValidSlot(iso, schedule, timezone) {
+  if (schedule.slots.length === 0) return false;
+  const date = new Date(iso);
+  const dayOfWeek = getDayOfWeekInTimezone(date, timezone);
+  if (schedule.avoidDays.includes(dayOfWeek)) return false;
+  const timeFormatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  const timeParts = timeFormatter.formatToParts(date);
+  const hour = timeParts.find((p) => p.type === "hour")?.value ?? "00";
+  const minute = timeParts.find((p) => p.type === "minute")?.value ?? "00";
+  const timeKey = `${hour}:${minute}`;
+  return schedule.slots.some((slot) => slot.time === timeKey && slot.days.includes(dayOfWeek));
+}
+async function buildRealignPlan(options = {}) {
+  const config2 = await loadScheduleConfig();
+  const { timezone } = config2;
+  const client = new LateApiClient();
+  const statuses = ["scheduled", "draft", "cancelled", "failed"];
+  const allPosts = await fetchAllPosts(client, statuses, options.platform);
+  if (allPosts.length === 0) {
+    return { posts: [], toCancel: [], skipped: 0, unmatched: 0, totalFetched: 0 };
+  }
+  const { byLatePostId, byContent } = options.clipTypeMaps ?? await buildClipTypeMaps();
+  let unmatched = 0;
+  const tagged = [];
+  for (const post of allPosts) {
+    const platform = post.platforms[0]?.platform;
+    if (!platform) continue;
+    let clipType = byLatePostId.get(post._id) ?? null;
+    if (!clipType && post.content) {
+      const contentKey = `${platform}::${normalizeContent(post.content)}`;
+      clipType = byContent.get(contentKey) ?? null;
+    }
+    if (!clipType) {
+      clipType = "short";
+      unmatched++;
+    }
+    tagged.push({ post, platform, clipType });
+  }
+  const bookedMap = await buildBookedMap();
+  const ctx = {
+    timezone,
+    bookedMap,
+    ideaLinkedPostIds: /* @__PURE__ */ new Set(),
+    lateClient: client,
+    displacementEnabled: getDisplacementConfig().enabled,
+    dryRun: true,
+    depth: 0,
+    ideaRefs: [],
+    samePlatformMs: 0,
+    crossPlatformMs: 0,
+    platform: ""
+  };
+  for (const [, slot] of bookedMap) {
+    if (slot.ideaLinked && slot.postId) {
+      ctx.ideaLinkedPostIds.add(slot.postId);
+    }
+  }
+  const result = [];
+  const toCancel = [];
+  let skipped = 0;
+  tagged.sort((a, b) => {
+    const aIdea = ctx.ideaLinkedPostIds.has(a.post._id) ? 0 : 1;
+    const bIdea = ctx.ideaLinkedPostIds.has(b.post._id) ? 0 : 1;
+    return aIdea - bIdea;
+  });
+  const nowMs = Date.now();
+  for (const { post, platform, clipType } of tagged) {
+    const schedulePlatform = normalizeSchedulePlatform(platform);
+    const platformConfig = getPlatformSchedule(schedulePlatform, clipType);
+    if (!platformConfig || platformConfig.slots.length === 0) {
+      if (post.status !== "cancelled") {
+        toCancel.push({ post, platform, clipType, reason: `No schedule slots for ${schedulePlatform}/${clipType}` });
+      }
+      continue;
+    }
+    if (post.scheduledFor && post.status === "scheduled" && isOnValidSlot(post.scheduledFor, platformConfig, timezone)) {
+      skipped++;
+      continue;
+    }
+    if (post.scheduledFor) {
+      const currentMs2 = new Date(post.scheduledFor).getTime();
+      const currentBooked = bookedMap.get(currentMs2);
+      if (currentBooked?.postId === post._id) {
+        bookedMap.delete(currentMs2);
+      }
+    }
+    const isIdea = ctx.ideaLinkedPostIds.has(post._id);
+    const label = `${schedulePlatform}/${clipType}:${post._id.slice(-6)}`;
+    const newSlot = await schedulePost(platformConfig, nowMs, isIdea, label, ctx);
+    if (!newSlot) {
+      if (post.status !== "cancelled") {
+        toCancel.push({ post, platform, clipType, reason: `No available slot for ${schedulePlatform}/${clipType}` });
+      }
+      continue;
+    }
+    const newMs = new Date(newSlot).getTime();
+    ctx.bookedMap.set(newMs, {
+      scheduledFor: newSlot,
+      source: "late",
+      postId: post._id,
+      platform: schedulePlatform,
+      ideaLinked: isIdea
+    });
+    const currentMs = post.scheduledFor ? new Date(post.scheduledFor).getTime() : 0;
+    if (currentMs === newMs && post.status === "scheduled") {
+      skipped++;
+      continue;
+    }
+    result.push({
+      post,
+      platform,
+      clipType,
+      oldScheduledFor: post.scheduledFor ?? null,
+      newScheduledFor: newSlot
+    });
+  }
+  result.sort((a, b) => new Date(a.newScheduledFor).getTime() - new Date(b.newScheduledFor).getTime());
+  return { posts: result, toCancel, skipped, unmatched, totalFetched: allPosts.length };
+}
+async function executeRealignPlan(plan, onProgress) {
+  const client = new LateApiClient();
+  let updated = 0;
+  let cancelled = 0;
+  let failed = 0;
+  const errors = [];
+  const totalOps = plan.toCancel.length + plan.posts.length;
+  let completed = 0;
+  for (const entry of plan.toCancel) {
+    completed++;
+    try {
+      await client.updatePost(entry.post._id, { status: "cancelled" });
+      cancelled++;
+      const preview = entry.post.content.slice(0, 40).replace(/\n/g, " ");
+      logger_default.info(`[${completed}/${totalOps}] \u{1F6AB} Cancelled ${entry.platform}/${entry.clipType}: "${preview}..."`);
+      onProgress?.(completed, totalOps, "cancelling");
+      await new Promise((r) => setTimeout(r, 300));
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push({ postId: entry.post._id, error: msg });
+      failed++;
+      logger_default.error(`[${completed}/${totalOps}] \u274C Failed to cancel ${entry.post._id}: ${msg}`);
+    }
+  }
+  for (const entry of plan.posts) {
+    completed++;
+    try {
+      await client.schedulePost(entry.post._id, entry.newScheduledFor);
+      updated++;
+      const preview = entry.post.content.slice(0, 40).replace(/\n/g, " ");
+      logger_default.info(`[${completed}/${totalOps}] \u2705 ${entry.platform}/${entry.clipType}: "${preview}..." \u2192 ${entry.newScheduledFor}`);
+      onProgress?.(completed, totalOps, "updating");
+      await new Promise((r) => setTimeout(r, 300));
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push({ postId: entry.post._id, error: msg });
+      failed++;
+      logger_default.error(`[${completed}/${totalOps}] \u274C Failed to update ${entry.post._id}: ${msg}`);
+    }
+  }
+  return { updated, cancelled, failed, errors };
+}
+
 // src/L2-clients/ffmpeg/audioExtraction.ts
 init_fileSystem();
 init_paths();
@@ -9271,6 +9659,8 @@ function transcodeToMp4(inputPath, outputPath) {
       createFFmpeg(inputPath).outputOptions([
         "-c:v",
         "libx264",
+        "-pix_fmt",
+        "yuv420p",
         "-preset",
         "ultrafast",
         "-crf",
@@ -9574,32 +9964,6 @@ async function markFailed(slug, error) {
   logger_default.info(`[ProcessingState] Marked failed: ${slug} \u2014 ${error}`);
 }
 
-// src/L3-services/gitOperations/gitOperations.ts
-init_environment();
-init_configLogger();
-async function commitAndPush(videoSlug, message) {
-  const { REPO_ROOT } = getConfig();
-  const commitMessage = message || `Auto-processed video: ${videoSlug}`;
-  try {
-    logger_default.info(`Staging all changes in ${REPO_ROOT}`);
-    execCommandSync("git add -A", { cwd: REPO_ROOT, stdio: "pipe" });
-    logger_default.info(`Committing: ${commitMessage}`);
-    execCommandSync(`git commit -m "${commitMessage}"`, { cwd: REPO_ROOT, stdio: "pipe" });
-    const branch = execCommandSync("git rev-parse --abbrev-ref HEAD", { cwd: REPO_ROOT, stdio: "pipe" });
-    logger_default.info(`Pushing to origin ${branch}`);
-    execCommandSync(`git push origin ${branch}`, { cwd: REPO_ROOT, stdio: "pipe" });
-    logger_default.info("Git commit and push completed successfully");
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    if (msg.includes("nothing to commit")) {
-      logger_default.info("Nothing to commit, working tree clean");
-      return;
-    }
-    logger_default.error(`Git operation failed: ${msg}`);
-    throw error;
-  }
-}
-
 // src/L3-services/queueBuilder/queueBuilder.ts
 init_fileSystem();
 init_paths();
@@ -9640,6 +10004,9 @@ function platformAcceptsMedia(platform, clipType) {
   return getMediaRule(platform, clipType) !== null;
 }
 
+// src/L3-services/queueBuilder/queueBuilder.ts
+init_postStore();
+
 // src/L1-infra/image/image.ts
 import { default as default7 } from "sharp";
 
@@ -9904,9 +10271,6 @@ function markCompleted2(...args) {
 function markFailed2(...args) {
   return markFailed(...args);
 }
-function commitAndPush2(...args) {
-  return commitAndPush(...args);
-}
 function buildPublishQueue2(...args) {
   return buildPublishQueue(...args);
 }
@@ -9960,6 +10324,7 @@ var BaseAgent = class _BaseAgent {
     for (let attempt = 1; attempt <= _BaseAgent.MAX_RETRIES; attempt++) {
       try {
         if (!this.session) {
+          logger_default.info(`[${this.agentName}] Creating LLM session (provider=${this.provider.name})\u2026`);
           this.session = await this.provider.createSession({
             systemPrompt: this.systemPrompt,
             tools: this.getTools(),
@@ -9970,6 +10335,7 @@ var BaseAgent = class _BaseAgent {
             onUserInputRequest: this.getUserInputHandler()
           });
           this.setupEventHandlers(this.session);
+          logger_default.info(`[${this.agentName}] LLM session ready`);
         }
         logger_default.info(`[${this.agentName}] Sending message (attempt ${attempt}/${_BaseAgent.MAX_RETRIES}): ${userMessage.substring(0, 80)}\u2026`);
         costTracker.setAgent(this.agentName);
@@ -10007,11 +10373,12 @@ var BaseAgent = class _BaseAgent {
   }
   /** Check if an error message indicates a transient/retryable failure. */
   static isRetryableError(message) {
-    const retryablePatterns = [
+    const lower = message.toLowerCase();
+    return [
       "missing finish_reason",
-      "ECONNRESET",
-      "ETIMEDOUT",
-      "ECONNREFUSED",
+      "econnreset",
+      "etimedout",
+      "econnrefused",
       "socket hang up",
       "network error",
       "rate limit",
@@ -10021,10 +10388,9 @@ var BaseAgent = class _BaseAgent {
       "503",
       "504",
       "stream ended",
-      "aborted"
-    ];
-    const lower = message.toLowerCase();
-    return retryablePatterns.some((p) => lower.includes(p.toLowerCase()));
+      "aborted",
+      "cli server exited"
+    ].some((p) => lower.includes(p));
   }
   /** Wire up session event listeners for logging. Override for custom display. */
   setupEventHandlers(session) {
@@ -10328,7 +10694,7 @@ function buildSystemPrompt(brand, existingIdeas, seedTopics, count, ideaRepo) {
   }
   return promptSections.join("\n");
 }
-function buildUserMessage(count, seedTopics, hasMcpServers) {
+function buildUserMessage(count, seedTopics, hasMcpServers, userPrompt) {
   const focusText = seedTopics.length > 0 ? `Focus areas: ${seedTopics.join(", ")}` : "Focus areas: choose the strongest timely opportunities from the creator context and current trends.";
   const steps = [
     "1. Call get_brand_context to load the creator profile.",
@@ -10352,13 +10718,15 @@ function buildUserMessage(count, seedTopics, hasMcpServers) {
       "5. Call finalize_ideas when done."
     );
   }
-  return [
+  const sections = [
     `Generate ${count} new content ideas.`,
-    focusText,
-    "",
-    "Follow this exact workflow:",
-    ...steps
-  ].join("\n");
+    focusText
+  ];
+  if (userPrompt) {
+    sections.push("", `## User Prompt`, userPrompt);
+  }
+  sections.push("", "Follow this exact workflow:", ...steps);
+  return sections.join("\n");
 }
 async function loadBrandContext(brandPath) {
   if (!brandPath) {
@@ -10875,7 +11243,7 @@ async function generateIdeas(options = {}) {
   });
   try {
     const hasMcpServers = !!(config2.EXA_API_KEY || config2.YOUTUBE_API_KEY || config2.PERPLEXITY_API_KEY);
-    const userMessage = buildUserMessage(count, seedTopics, hasMcpServers);
+    const userMessage = buildUserMessage(count, seedTopics, hasMcpServers, options.prompt);
     await agent.run(userMessage);
     const ideas = agent.getGeneratedIdeas();
     if (!agent.isFinalized()) {
@@ -10923,32 +11291,6 @@ init_fileSystem();
 init_configLogger();
 init_environment();
 
-// src/L1-infra/progress/progressEmitter.ts
-var ProgressEmitter = class {
-  enabled = false;
-  /** Turn on progress event output to stderr. */
-  enable() {
-    this.enabled = true;
-  }
-  /** Turn off progress event output. */
-  disable() {
-    this.enabled = false;
-  }
-  /** Whether the emitter is currently active. */
-  isEnabled() {
-    return this.enabled;
-  }
-  /**
-   * Write a progress event as a single JSON line to stderr.
-   * No-op when the emitter is disabled.
-   */
-  emit(event) {
-    if (!this.enabled) return;
-    process.stderr.write(JSON.stringify(event) + "\n");
-  }
-};
-var progressEmitter = new ProgressEmitter();
-
 // src/L5-assets/Asset.ts
 init_fileSystem();
 var Asset = class {
@@ -15860,12 +16202,6 @@ var MainVideoAsset = class _MainVideoAsset extends VideoAsset {
   async buildQueue(shorts, mediumClips, socialPosts, captionedVideoPath) {
     await this.buildPublishQueueData(shorts, mediumClips, socialPosts, captionedVideoPath);
   }
-  /**
-   * Commit and push all generated assets via git.
-   */
-  async commitAndPushChanges(message) {
-    return commitAndPush2(this.slug, message);
-  }
 };
 
 // src/L6-pipeline/pipeline.ts
@@ -16071,11 +16407,6 @@ async function processVideo(videoPath, ideas) {
       skipStage("queue-build" /* QueueBuild */, "NO_SOCIAL_POSTS");
     }
     const blogPost = await trackStage("blog" /* Blog */, () => asset.getBlog());
-    if (!cfg.SKIP_GIT) {
-      await trackStage("git-push" /* GitPush */, () => asset.commitAndPushChanges());
-    } else {
-      skipStage("git-push" /* GitPush */, "SKIP_GIT");
-    }
     const totalDuration = Date.now() - pipelineStart;
     const report = costTracker3.getReport();
     if (report.records.length > 0) {
@@ -16198,7 +16529,8 @@ var defaultKeys = [
   "brandPath",
   "ideasRepo",
   "lateProfileId",
-  "geminiModel"
+  "geminiModel",
+  "scheduleConfig"
 ];
 var configKeyMap = {
   "openai-key": { section: "credentials", key: "openaiApiKey" },
@@ -16216,7 +16548,8 @@ var configKeyMap = {
   "brand-path": { section: "defaults", key: "brandPath" },
   "ideas-repo": { section: "defaults", key: "ideasRepo" },
   "late-profile-id": { section: "defaults", key: "lateProfileId" },
-  "gemini-model": { section: "defaults", key: "geminiModel" }
+  "gemini-model": { section: "defaults", key: "geminiModel" },
+  "schedule-config": { section: "defaults", key: "scheduleConfig" }
 };
 var providerDefaults = {
   copilot: "Claude Opus 4.6",
@@ -16252,20 +16585,11 @@ var platformVariantMap = {
   youtube: "youtube",
   "youtube-shorts": "youtube-shorts"
 };
-function applySdkEnvironment(sdkConfig) {
-  if (!sdkConfig) {
-    return;
-  }
-  if (sdkConfig.anthropicApiKey) process.env.ANTHROPIC_API_KEY = sdkConfig.anthropicApiKey;
-  if (sdkConfig.geminiApiKey) process.env.GEMINI_API_KEY = sdkConfig.geminiApiKey;
-  if (sdkConfig.llmProvider) process.env.LLM_PROVIDER = sdkConfig.llmProvider;
-  if (sdkConfig.llmModel) process.env.LLM_MODEL = sdkConfig.llmModel;
-  if (sdkConfig.geminiModel) process.env.GEMINI_MODEL = sdkConfig.geminiModel;
-  if (sdkConfig.repoRoot) process.env.REPO_ROOT = sdkConfig.repoRoot;
-}
 function mapSdkConfigToCliOptions(sdkConfig) {
   return {
     openaiKey: sdkConfig?.openaiApiKey,
+    anthropicKey: sdkConfig?.anthropicApiKey,
+    geminiKey: sdkConfig?.geminiApiKey,
     exaKey: sdkConfig?.exaApiKey,
     youtubeKey: sdkConfig?.youtubeApiKey,
     perplexityKey: sdkConfig?.perplexityApiKey,
@@ -16276,12 +16600,15 @@ function mapSdkConfigToCliOptions(sdkConfig) {
     lateApiKey: sdkConfig?.lateApiKey,
     lateProfileId: sdkConfig?.lateProfileId,
     ideasRepo: sdkConfig?.ideasRepo,
-    githubToken: sdkConfig?.githubToken
+    githubToken: sdkConfig?.githubToken,
+    llmProvider: sdkConfig?.llmProvider,
+    llmModel: sdkConfig?.llmModel,
+    geminiModel: sdkConfig?.geminiModel,
+    repoRoot: sdkConfig?.repoRoot
   };
 }
 function mapProcessOptionsToCliOverrides(options) {
   const overrides = {};
-  if (options?.skipGit !== void 0) overrides.git = !options.skipGit;
   if (options?.skipSilenceRemoval !== void 0) overrides.silenceRemoval = !options.skipSilenceRemoval;
   if (options?.skipShorts !== void 0) overrides.shorts = !options.skipShorts;
   if (options?.skipMediumClips !== void 0) overrides.mediumClips = !options.skipMediumClips;
@@ -16346,10 +16673,10 @@ function applyPersistedConfigToRuntime(target, value, currentCliOptions) {
       currentCliOptions.githubToken = value;
       break;
     case "credentials.anthropicApiKey":
-      process.env.ANTHROPIC_API_KEY = value;
+      currentCliOptions.anthropicKey = value;
       break;
     case "credentials.geminiApiKey":
-      process.env.GEMINI_API_KEY = value;
+      currentCliOptions.geminiKey = value;
       break;
     case "defaults.outputDir":
       currentCliOptions.outputDir = value;
@@ -16367,13 +16694,13 @@ function applyPersistedConfigToRuntime(target, value, currentCliOptions) {
       currentCliOptions.lateProfileId = value;
       break;
     case "defaults.llmProvider":
-      process.env.LLM_PROVIDER = value;
+      currentCliOptions.llmProvider = value;
       break;
     case "defaults.llmModel":
-      process.env.LLM_MODEL = value;
+      currentCliOptions.llmModel = value;
       break;
     case "defaults.geminiModel":
-      process.env.GEMINI_MODEL = value;
+      currentCliOptions.geminiModel = value;
       break;
     default:
       break;
@@ -16386,10 +16713,6 @@ function applyRuntimeOnlyOverride(rawKey, value, currentCliOptions) {
     case "VERBOSE":
       currentCliOptions.verbose = Boolean(value);
       return true;
-    case "skipGit":
-    case "SKIP_GIT":
-      currentCliOptions.git = !Boolean(value);
-      return true;
     case "skipSilenceRemoval":
     case "SKIP_SILENCE_REMOVAL":
       currentCliOptions.silenceRemoval = !Boolean(value);
@@ -16420,15 +16743,15 @@ function applyRuntimeOnlyOverride(rawKey, value, currentCliOptions) {
       return true;
     case "repoRoot":
     case "REPO_ROOT":
-      process.env.REPO_ROOT = String(value);
+      currentCliOptions.repoRoot = String(value);
       return true;
     case "ffmpegPath":
     case "FFMPEG_PATH":
-      process.env.FFMPEG_PATH = String(value);
+      currentCliOptions.ffmpegPath = String(value);
       return true;
     case "ffprobePath":
     case "FFPROBE_PATH":
-      process.env.FFPROBE_PATH = String(value);
+      currentCliOptions.ffprobePath = String(value);
       return true;
     default:
       return false;
@@ -16587,7 +16910,6 @@ async function buildSocialPosts(context, platforms) {
   }));
 }
 function createVidPipe(sdkConfig) {
-  applySdkEnvironment(sdkConfig);
   let currentCliOptions = mapSdkConfigToCliOptions(sdkConfig);
   initConfig(currentCliOptions);
   function refreshConfig() {
@@ -16658,22 +16980,6 @@ function createVidPipe(sdkConfig) {
       status: buildDiagnosticStatus(false, Boolean(config2.EXA_API_KEY)),
       message: config2.EXA_API_KEY ? "EXA_API_KEY is configured" : "EXA_API_KEY is not configured (optional)"
     });
-    try {
-      const gitResult = spawnCommand("git", ["--version"], { timeout: 1e4 });
-      const passed = gitResult.status === 0 && typeof gitResult.stdout === "string" && gitResult.stdout.length > 0;
-      checks.push({
-        name: "git",
-        status: buildDiagnosticStatus(false, passed),
-        message: passed ? `Git ${parseVersionFromOutput(gitResult.stdout)} detected` : "Git is not available (optional for git-push stage)"
-      });
-    } catch (error) {
-      checks.push({
-        name: "git",
-        status: "warn",
-        message: "Git is not available (optional for git-push stage)",
-        details: error instanceof Error ? error.message : String(error)
-      });
-    }
     const watchFolder = config2.WATCH_FOLDER || join(process.cwd(), "watch");
     checks.push({
       name: "watch-folder",
@@ -16758,13 +17064,19 @@ function createVidPipe(sdkConfig) {
       const cliOverrides = mapProcessOptionsToCliOverrides(options);
       const ideaIds = options?.ideas?.map((ideaId) => String(ideaId));
       const ideas = ideaIds && ideaIds.length > 0 ? await getIdeasByIds(ideaIds) : void 0;
-      return await withTemporaryCliOverrides(cliOverrides, async () => {
-        const result = await processVideoSafe(videoPath, ideas);
-        if (!result) {
-          throw new Error(`VidPipe pipeline failed for "${videoPath}" with an uncaught error`);
-        }
-        return result;
-      });
+      const listener = options?.onProgress;
+      if (listener) progressEmitter.addListener(listener);
+      try {
+        return await withTemporaryCliOverrides(cliOverrides, async () => {
+          const result = await processVideoSafe(videoPath, ideas);
+          if (!result) {
+            throw new Error(`VidPipe pipeline failed for "${videoPath}" with an uncaught error`);
+          }
+          return result;
+        });
+      } finally {
+        if (listener) progressEmitter.removeListener(listener);
+      }
     },
     async ideate(options) {
       return await generateIdeas3({