vidpipe 1.3.12 → 1.3.13

package/dist/cli.js

@@ -56,7 +56,7 @@ function findRoot(startDir) {
   }
 }
 function projectRoot() {
-  if (!_cachedRoot) _cachedRoot = findRoot(__dirname);
+  if (!_cachedRoot) _cachedRoot = findRoot(__dirname2);
   return _cachedRoot;
 }
 function assetsDir(...segments) {
@@ -70,11 +70,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));
   }
 });
 
@@ -415,8 +415,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;
     }
@@ -434,7 +435,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,
@@ -448,14 +453,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,
@@ -467,12 +480,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
     ),
@@ -489,7 +508,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,
@@ -536,10 +554,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"
@@ -554,9 +574,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";
@@ -572,7 +602,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)");
   }
 }
@@ -720,8 +750,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 = {
@@ -870,7 +899,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;
@@ -888,7 +917,7 @@ var require_messages = __commonJS({
         return result;
       }
     };
-    exports.ResponseError = ResponseError;
+    exports.ResponseError = ResponseError2;
     var ParameterStructures = class _ParameterStructures {
       constructor(kind) {
         this.kind = kind;
@@ -2441,14 +2470,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) {
@@ -3071,15 +3100,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() {
@@ -4064,6 +4093,67 @@ var require_node = __commonJS({
   }
 });
 
+// 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 })
+    }
+  };
+}
+var init_rpc = __esm({
+  "node_modules/@github/copilot-sdk/dist/generated/rpc.js"() {
+    "use strict";
+  }
+});
+
 // node_modules/@github/copilot-sdk/dist/sdkProtocolVersion.js
 function getSdkProtocolVersion() {
   return SDK_PROTOCOL_VERSION;
@@ -4072,15 +4162,17 @@ var SDK_PROTOCOL_VERSION;
 var init_sdkProtocolVersion = __esm({
   "node_modules/@github/copilot-sdk/dist/sdkProtocolVersion.js"() {
     "use strict";
-    SDK_PROTOCOL_VERSION = 2;
+    SDK_PROTOCOL_VERSION = 3;
   }
 });
 
 // node_modules/@github/copilot-sdk/dist/session.js
-var CopilotSession;
+var import_node, CopilotSession;
 var init_session = __esm({
   "node_modules/@github/copilot-sdk/dist/session.js"() {
     "use strict";
+    import_node = __toESM(require_node(), 1);
+    init_rpc();
     CopilotSession = class {
       /**
        * Creates a new CopilotSession instance.
@@ -4101,6 +4193,16 @@ var init_session = __esm({
       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.
@@ -4117,7 +4219,7 @@ var init_session = __esm({
        *
        * @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
@@ -4150,7 +4252,7 @@ var init_session = __esm({
        * @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
@@ -4224,11 +4326,13 @@ var init_session = __esm({
       }
       /**
        * 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) {
@@ -4245,6 +4349,85 @@ var init_session = __esm({
           }
         }
       }
+      /**
+       * 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.
        *
@@ -4310,13 +4493,14 @@ var init_session = __esm({
         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" };
         }
@@ -4387,7 +4571,7 @@ var init_session = __esm({
        * 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
@@ -4406,22 +4590,27 @@ var init_session = __esm({
         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
         });
@@ -4430,6 +4619,22 @@ var init_session = __esm({
         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.
        *
@@ -4437,7 +4642,7 @@ var init_session = __esm({
        * 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
@@ -4455,6 +4660,20 @@ var init_session = __esm({
           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 });
+      }
     };
   }
 });
@@ -4475,18 +4694,26 @@ 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);
   return join5(dirname3(dirname3(sdkPath)), "index.js");
 }
-var import_node, CopilotClient;
+var import_node2, MIN_PROTOCOL_VERSION, CopilotClient;
 var init_client = __esm({
   "node_modules/@github/copilot-sdk/dist/client.js"() {
     "use strict";
-    import_node = __toESM(require_node(), 1);
+    import_node2 = __toESM(require_node(), 1);
+    init_rpc();
     init_sdkProtocolVersion();
     init_session();
+    MIN_PROTOCOL_VERSION = 2;
     CopilotClient = class {
       cliProcess = null;
       connection = null;
@@ -4495,6 +4722,8 @@ var init_client = __esm({
       actualHost = "localhost";
       state = "disconnected";
       sessions = /* @__PURE__ */ new Map();
+      stderrBuffer = "";
+      // Captures CLI stderr for error messages
       options;
       isExternalServer = false;
       forceStopping = false;
@@ -4502,6 +4731,23 @@ var init_client = __esm({
       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.
        *
@@ -4527,6 +4773,11 @@ var init_client = __esm({
         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)"
@@ -4538,6 +4789,9 @@ var init_client = __esm({
           this.actualPort = port;
           this.isExternalServer = true;
         }
+        if (options.isChildProcess) {
+          this.isExternalServer = true;
+        }
         this.options = {
           cliPath: options.cliPath || getBundledCliPath(),
           cliArgs: options.cliArgs ?? [],
@@ -4545,6 +4799,7 @@ var init_client = __esm({
           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,
@@ -4616,10 +4871,14 @@ var init_client = __esm({
        * 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.
        *
@@ -4638,7 +4897,7 @@ var init_client = __esm({
           let lastError = null;
           for (let attempt = 1; attempt <= 3; attempt++) {
             try {
-              await session.destroy();
+              await session.disconnect();
               lastError = null;
               break;
             } catch (error) {
@@ -4652,7 +4911,7 @@ var init_client = __esm({
           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}`
               )
             );
           }
@@ -4669,6 +4928,7 @@ var init_client = __esm({
             );
           }
           this.connection = null;
+          this._rpc = null;
         }
         this.modelsCache = null;
         if (this.socket) {
@@ -4697,6 +4957,8 @@ var init_client = __esm({
         }
         this.state = "disconnected";
         this.actualPort = null;
+        this.stderrBuffer = "";
+        this.processExitPromise = null;
         return errors;
       }
       /**
@@ -4733,6 +4995,7 @@ var init_client = __esm({
           } catch {
           }
           this.connection = null;
+          this._rpc = null;
         }
         this.modelsCache = null;
         if (this.socket) {
@@ -4751,6 +5014,8 @@ var init_client = __esm({
         }
         this.state = "disconnected";
         this.actualPort = null;
+        this.stderrBuffer = "";
+        this.processExitPromise = null;
       }
       /**
        * Creates a new conversation session with the Copilot CLI.
@@ -4766,10 +5031,11 @@ var init_client = __esm({
        * @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",
@@ -4780,7 +5046,12 @@ var init_client = __esm({
        * });
        * ```
        */
-      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();
@@ -4791,22 +5062,25 @@ var init_client = __esm({
         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,
@@ -4816,9 +5090,7 @@ var init_client = __esm({
         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);
         }
@@ -4843,15 +5115,21 @@ var init_client = __esm({
        * @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();
@@ -4861,6 +5139,7 @@ var init_client = __esm({
         }
         const response = await this.connection.sendRequest("session.resume", {
           sessionId,
+          clientName: config2.clientName,
           model: config2.model,
           reasoningEffort: config2.reasoningEffort,
           systemMessage: config2.systemMessage,
@@ -4869,16 +5148,18 @@ var init_client = __esm({
           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,
@@ -4888,9 +5169,7 @@ var init_client = __esm({
         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);
         }
@@ -4908,7 +5187,7 @@ var init_client = __esm({
        * @example
        * ```typescript
        * if (client.getState() === "connected") {
-       *   const session = await client.createSession();
+       *   const session = await client.createSession({ onPermissionRequest: approveAll });
        * }
        * ```
        */
@@ -4986,22 +5265,29 @@ var init_client = __esm({
         }
       }
       /**
-       * 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.
@@ -5016,7 +5302,7 @@ var init_client = __esm({
        * ```typescript
        * const lastId = await client.getLastSessionId();
        * if (lastId) {
-       *   const session = await client.resumeSession(lastId);
+       *   const session = await client.resumeSession(lastId, { onPermissionRequest: approveAll });
        * }
        * ```
        */
@@ -5028,10 +5314,12 @@ var init_client = __esm({
         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
@@ -5056,33 +5344,31 @@ var init_client = __esm({
         this.sessions.delete(sessionId);
       }
       /**
-       * Lists all available sessions known to the server.
-       *
-       * Returns metadata about each session including ID, timestamps, and summary.
+       * List all available sessions.
        *
-       * @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
         }));
       }
       /**
@@ -5161,6 +5447,7 @@ var init_client = __esm({
        */
       async startCLIServer() {
         return new Promise((resolve3, reject) => {
+          this.stderrBuffer = "";
           const args = [
             ...this.options.cliArgs,
             "--headless",
@@ -5192,16 +5479,18 @@ var init_client = __esm({
           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 = "";
@@ -5221,6 +5510,7 @@ var init_client = __esm({
             });
           }
           this.cliProcess.stderr?.on("data", (data) => {
+            this.stderrBuffer += data.toString();
             const lines = data.toString().split("\n");
             for (const line of lines) {
               if (line.trim()) {
@@ -5232,13 +5522,54 @@ var init_client = __esm({
           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();
             }
@@ -5255,16 +5586,18 @@ var init_client = __esm({
        * 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");
         }
@@ -5273,9 +5606,23 @@ var init_client = __esm({
             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();
@@ -5290,9 +5637,9 @@ var init_client = __esm({
         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();
@@ -5315,11 +5662,11 @@ var init_client = __esm({
         });
         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",
@@ -5367,7 +5714,41 @@ var init_client = __esm({
           }
         }
       }
-      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");
         }
@@ -5377,25 +5758,28 @@ var init_client = __esm({
         }
         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,
@@ -5404,7 +5788,10 @@ var init_client = __esm({
           };
         }
       }
-      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");
         }
@@ -5413,7 +5800,7 @@ var init_client = __esm({
           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 {
@@ -5423,33 +5810,7 @@ var init_client = __esm({
           };
         }
       }
-      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",
@@ -5471,14 +5832,6 @@ var init_client = __esm({
       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
        */
@@ -5495,9 +5848,11 @@ var init_client = __esm({
 });
 
 // node_modules/@github/copilot-sdk/dist/types.js
+var approveAll;
 var init_types2 = __esm({
   "node_modules/@github/copilot-sdk/dist/types.js"() {
     "use strict";
+    approveAll = () => ({ kind: "approved" });
   }
 });
 
@@ -5512,6 +5867,33 @@ var init_dist = __esm({
 });
 
 // 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;
+}
 var init_copilot = __esm({
   "src/L1-infra/ai/copilot.ts"() {
     "use strict";
@@ -5539,14 +5921,25 @@ var init_ai = __esm({
 });
 
 // src/L2-clients/llm/CopilotProvider.ts
-var DEFAULT_MODEL, DEFAULT_TIMEOUT_MS, CopilotProvider, CopilotSessionWrapper;
+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;
+}
+var DEFAULT_MODEL, DEFAULT_TIMEOUT_MS, SESSION_CREATE_TIMEOUT_MS, CopilotProvider, CopilotSessionWrapper;
 var init_CopilotProvider = __esm({
   "src/L2-clients/llm/CopilotProvider.ts"() {
     "use strict";
     init_ai();
+    init_copilot();
     init_configLogger();
     DEFAULT_MODEL = "claude-opus-4.5";
     DEFAULT_TIMEOUT_MS = 3e5;
+    SESSION_CREATE_TIMEOUT_MS = 3e4;
     CopilotProvider = class {
       name = "copilot";
       client = null;
@@ -5558,21 +5951,57 @@ var init_CopilotProvider = __esm({
       }
       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
@@ -5928,7 +6357,8 @@ var init_OpenAIProvider = __esm({
         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);
@@ -6192,12 +6622,13 @@ var init_providerFactory = __esm({
 
 // src/L1-infra/config/modelConfig.ts
 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;
 }
@@ -7330,6 +7761,7 @@ init_environment();
 // 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;
@@ -7338,17 +7770,31 @@ var ProgressEmitter = class {
   disable() {
     this.enabled = false;
   }
-  /** Whether the emitter is currently active. */
+  /** Whether the emitter is currently active (stderr or listeners). */
   isEnabled() {
-    return this.enabled;
+    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.
-   * No-op when the emitter is disabled.
+   * 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) return;
-    process.stderr.write(JSON.stringify(event) + "\n");
+    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();
@@ -7446,9 +7892,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 });
 }
@@ -8672,6 +9115,8 @@ function transcodeToMp4(inputPath, outputPath) {
       createFFmpeg(inputPath).outputOptions([
         "-c:v",
         "libx264",
+        "-pix_fmt",
+        "yuv420p",
         "-preset",
         "ultrafast",
         "-crf",
@@ -10468,6 +10913,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(),
@@ -10478,6 +10924,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);
@@ -10515,11 +10962,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",
@@ -10529,10 +10977,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) {
@@ -13000,32 +13447,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();
@@ -13643,9 +14064,6 @@ function markCompleted2(...args) {
 function markFailed2(...args) {
   return markFailed(...args);
 }
-function commitAndPush2(...args) {
-  return commitAndPush(...args);
-}
 function buildPublishQueue2(...args) {
   return buildPublishQueue(...args);
 }
@@ -14793,12 +15211,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/L2-clients/late/lateApi.ts
@@ -17480,11 +17892,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) {
@@ -17866,6 +18273,7 @@ async function checkScheduleConfig() {
 // src/L7-app/commands/init.ts
 init_fileSystem();
 init_paths();
+init_environment();
 
 // src/L3-services/diagnostics/diagnostics.ts
 function getFFmpegPath3(...args) {
@@ -17915,7 +18323,7 @@ async function runInit() {
     console.log("  \u274C FFprobe not found");
   }
   console.log("\nStep 2/5: OpenAI (Required for transcription)");
-  const currentOpenAI = existingVars.OPENAI_API_KEY || process.env.OPENAI_API_KEY;
+  const currentOpenAI = existingVars.OPENAI_API_KEY || getConfig().OPENAI_API_KEY;
   const hint = currentOpenAI ? ` (current: ${currentOpenAI.slice(0, 8)}...)` : "";
   const openaiKey = await ask(`  ? OpenAI API key${hint}: `);
   if (openaiKey.trim()) {
@@ -19281,7 +19689,7 @@ function createRouter() {
 // src/L7-app/review/server.ts
 init_environment();
 init_configLogger();
-var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var __dirname3 = dirname(fileURLToPath(import.meta.url));
 async function startReviewServer(options = {}) {
   const app = default8();
   const port = options.port || 3847;
@@ -19292,7 +19700,7 @@ async function startReviewServer(options = {}) {
   const publishedDir = join(cfg.OUTPUT_DIR, "published");
   app.use("/media/queue", default8.static(queueDir));
   app.use("/media/published", default8.static(publishedDir));
-  const publicDir = join(__dirname2, "public");
+  const publicDir = join(__dirname3, "public");
   app.use(default8.static(publicDir));
   app.get("/{*splat}", (req, res) => {
     if (!req.path.startsWith("/api/") && !req.path.startsWith("/media/")) {
@@ -19412,7 +19820,7 @@ program.command("configure [subcommand]").description("Manage global configurati
   await runConfigure(subcommand, args);
   process.exit(process.exitCode ?? 0);
 });
-var defaultCmd = program.command("process", { isDefault: true }).argument("[video-path]", "Path to a video file to process (implies --once)").option("--watch-dir <path>", "Folder to watch for new recordings (default: env WATCH_FOLDER)").option("--output-dir <path>", "Output directory for processed videos (default: ./recordings)").option("--openai-key <key>", "OpenAI API key (default: env OPENAI_API_KEY)").option("--exa-key <key>", "Exa AI API key for web search (default: env EXA_API_KEY)").option("--youtube-key <key>", "YouTube API key (default: env YOUTUBE_API_KEY)").option("--perplexity-key <key>", "Perplexity API key (default: env PERPLEXITY_API_KEY)").option("--once", "Process a single video and exit (no watching)").option("--brand <path>", "Path to brand.json config (default: ./brand.json)").option("--no-git", "Skip git commit/push stage").option("--no-silence-removal", "Skip silence removal stage").option("--no-shorts", "Skip shorts generation").option("--no-medium-clips", "Skip medium clip generation").option("--no-social", "Skip social media post generation").option("--no-captions", "Skip caption generation/burning").option("--no-visual-enhancement", "Skip visual enhancement (AI image overlays)").option("--no-social-publish", "Skip social media publishing/queue-build stage").option("--late-api-key <key>", "Late API key (default: env LATE_API_KEY)").option("--late-profile-id <id>", "Late profile ID (default: env LATE_PROFILE_ID)").option("--ideas <ids>", "Comma-separated idea IDs to link to this video").option("-v, --verbose", "Verbose logging").option("--progress", "Emit structured JSON progress events to stderr").option("--doctor", "Check all prerequisites and exit").action(async (videoPath) => {
+var defaultCmd = program.command("process", { isDefault: true }).argument("[video-path]", "Path to a video file to process (implies --once)").option("--watch-dir <path>", "Folder to watch for new recordings (default: env WATCH_FOLDER)").option("--output-dir <path>", "Output directory for processed videos (default: ./recordings)").option("--openai-key <key>", "OpenAI API key (default: env OPENAI_API_KEY)").option("--exa-key <key>", "Exa AI API key for web search (default: env EXA_API_KEY)").option("--youtube-key <key>", "YouTube API key (default: env YOUTUBE_API_KEY)").option("--perplexity-key <key>", "Perplexity API key (default: env PERPLEXITY_API_KEY)").option("--once", "Process a single video and exit (no watching)").option("--brand <path>", "Path to brand.json config (default: ./brand.json)").option("--no-silence-removal", "Skip silence removal stage").option("--no-shorts", "Skip shorts generation").option("--no-medium-clips", "Skip medium clip generation").option("--no-social", "Skip social media post generation").option("--no-captions", "Skip caption generation/burning").option("--no-visual-enhancement", "Skip visual enhancement (AI image overlays)").option("--no-social-publish", "Skip social media publishing/queue-build stage").option("--late-api-key <key>", "Late API key (default: env LATE_API_KEY)").option("--late-profile-id <id>", "Late profile ID (default: env LATE_PROFILE_ID)").option("--ideas <ids>", "Comma-separated idea IDs to link to this video").option("-v, --verbose", "Verbose logging").option("--progress", "Emit structured JSON progress events to stderr").option("--doctor", "Check all prerequisites and exit").action(async (videoPath) => {
   const opts = defaultCmd.opts();
   if (opts.doctor) {
     await runDoctor();
@@ -19428,7 +19836,6 @@ var defaultCmd = program.command("process", { isDefault: true }).argument("[vide
     perplexityKey: opts.perplexityKey,
     brand: opts.brand,
     verbose: opts.verbose,
-    git: opts.git,
     silenceRemoval: opts.silenceRemoval,
     shorts: opts.shorts,
     mediumClips: opts.mediumClips,