vidpipe 1.3.12 → 1.3.13

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));
   }
 });
 
@@ -471,8 +469,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 +489,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 +507,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 +534,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 +562,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 +608,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 +628,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 +656,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 +1467,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 +1485,7 @@ var require_messages = __commonJS({
         return result;
       }
     };
-    exports.ResponseError = ResponseError;
+    exports.ResponseError = ResponseError2;
     var ParameterStructures = class _ParameterStructures {
       constructor(kind) {
         this.kind = kind;
@@ -3010,14 +3038,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 +3668,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() {
@@ -4640,6 +4668,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 +4717,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 +4810,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 +4832,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 +4923,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 +4949,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 +4982,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 +5056,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 +5079,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 +5223,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 +5301,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 +5320,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 +5349,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 +5372,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,9 +5390,24 @@ var CopilotSession = class {
       sessionId: this.sessionId
     });
   }
+  /**
+   * 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";
 }
@@ -5166,6 +5418,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 +5437,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 +5446,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 +5488,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 +5504,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 +5514,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 +5586,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 +5612,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 +5626,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 +5643,7 @@ var CopilotClient = class {
         );
       }
       this.connection = null;
+      this._rpc = null;
     }
     this.modelsCache = null;
     if (this.socket) {
@@ -5381,6 +5672,8 @@ var CopilotClient = class {
     }
     this.state = "disconnected";
     this.actualPort = null;
+    this.stderrBuffer = "";
+    this.processExitPromise = null;
     return errors;
   }
   /**
@@ -5417,6 +5710,7 @@ var CopilotClient = class {
       } catch {
       }
       this.connection = null;
+      this._rpc = null;
     }
     this.modelsCache = null;
     if (this.socket) {
@@ -5435,6 +5729,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 +5746,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 +5761,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 +5777,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 +5805,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 +5830,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 +5854,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 +5863,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 +5884,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 +5902,7 @@ var CopilotClient = class {
    * @example
    * ```typescript
    * if (client.getState() === "connected") {
-   *   const session = await client.createSession();
+   *   const session = await client.createSession({ onPermissionRequest: approveAll });
    * }
    * ```
    */
@@ -5670,22 +5980,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 +6017,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 +6029,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 +6059,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 +6162,7 @@ var CopilotClient = class {
    */
   async startCLIServer() {
     return new Promise((resolve3, reject) => {
+      this.stderrBuffer = "";
       const args = [
         ...this.options.cliArgs,
         "--headless",
@@ -5876,16 +6194,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 +6225,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 +6237,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 +6301,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 +6321,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 +6352,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 +6377,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 +6429,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 +6473,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 +6503,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 +6515,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 +6525,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 +6547,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 +6560,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 +6607,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 +6619,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 +6814,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 +7073,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);
@@ -9271,6 +9734,8 @@ function transcodeToMp4(inputPath, outputPath) {
       createFFmpeg(inputPath).outputOptions([
         "-c:v",
         "libx264",
+        "-pix_fmt",
+        "yuv420p",
         "-preset",
         "ultrafast",
         "-crf",
@@ -9574,32 +10039,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();
@@ -9904,9 +10343,6 @@ function markCompleted2(...args) {
 function markFailed2(...args) {
   return markFailed(...args);
 }
-function commitAndPush2(...args) {
-  return commitAndPush(...args);
-}
 function buildPublishQueue2(...args) {
   return buildPublishQueue(...args);
 }
@@ -9960,6 +10396,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 +10407,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 +10445,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 +10460,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) {
@@ -10923,32 +11361,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 +16272,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 +16477,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) {
@@ -16252,20 +16653,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 +16668,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 +16741,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 +16762,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 +16781,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 +16811,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 +16978,6 @@ async function buildSocialPosts(context, platforms) {
   }));
 }
 function createVidPipe(sdkConfig) {
-  applySdkEnvironment(sdkConfig);
   let currentCliOptions = mapSdkConfigToCliOptions(sdkConfig);
   initConfig(currentCliOptions);
   function refreshConfig() {
@@ -16658,22 +17048,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 +17132,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({