@github/copilot-sdk 1.0.13 → 1.0.14-preview.1

package/README.md

@@ -267,11 +267,26 @@ Send a message to the session. Returns immediately after the message is queued;
 **Options:**
 
 - `prompt: string` - The message/prompt to send
+- `source?: MessageSource` - `"user"`, `"system"`, or `` `agent-${string}` `` provenance; omitted by default
 - `attachments?: Array<{type, path, displayName}>` - File attachments
 - `mode?: "enqueue" | "immediate"` - Delivery mode
 
 Returns the message ID.
 
+Use `source: "system"` for automated messages from your application:
+
+```typescript
+await session.send({ prompt: "Context updated", source: "system" });
+```
+
+For a message from another agent, use its trusted sender ID:
+
+```typescript
+await session.send({ prompt: "Review complete", source: "agent-reviewer-id" });
+```
+
+Source is independent of delivery mode. Leaving it unset preserves the existing human-message payload; it does not set billing flags or use the notification API.
+
 ##### `sendAndWait(options: MessageOptions, timeout?: number): Promise<AssistantMessageEvent | undefined>`
 
 Send a message and wait until the session becomes idle.
@@ -279,6 +294,7 @@ Send a message and wait until the session becomes idle.
 **Options:**
 
 - `prompt: string` - The message/prompt to send
+- `source?: MessageSource` - Same optional provenance as `send`
 - `attachments?: Array<{type, path, displayName}>` - File attachments
 - `mode?: "enqueue" | "immediate"` - Delivery mode
 - `timeout?: number` - Optional timeout in milliseconds

package/dist/cjs/cliVersion.js

@@ -22,7 +22,7 @@ __export(cliVersion_exports, {
   COPILOT_CLI_VERSION: () => COPILOT_CLI_VERSION
 });
 module.exports = __toCommonJS(cliVersion_exports);
-const COPILOT_CLI_VERSION = "1.0.83";
+const COPILOT_CLI_VERSION = "1.0.84-5";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/client.js

@@ -241,6 +241,8 @@ class CopilotClient {
   runtimePort = null;
   actualHost = "localhost";
   state = "disconnected";
+  /** Shared in-flight start; concurrent callers await it instead of spawning another CLI. */
+  startPromise = null;
   sessions = /* @__PURE__ */ new Map();
   stderrBuffer = "";
   // Captures CLI stderr for error messages
@@ -618,6 +620,17 @@ class CopilotClient {
     if (this.state === "connected") {
       return;
     }
+    if (this.startPromise) {
+      return this.startPromise;
+    }
+    this.startPromise = this.doStart();
+    try {
+      await this.startPromise;
+    } finally {
+      this.startPromise = null;
+    }
+  }
+  async doStart() {
     this.forceStopping = false;
     this.connectionClosed = false;
     this.processTransportError = null;
@@ -807,7 +820,7 @@ class CopilotClient {
       const host = this.ffiHost;
       this.ffiHost = null;
       try {
-        host.dispose();
+        await host.dispose();
       } catch (error) {
         errors.push(
           new Error(
@@ -902,11 +915,12 @@ class CopilotClient {
       this.cliProcess = null;
     }
     if (this.ffiHost) {
+      const host = this.ffiHost;
+      this.ffiHost = null;
       try {
-        this.ffiHost.dispose();
+        await host.dispose();
       } catch {
       }
-      this.ffiHost = null;
     }
     if (this.cliStartTimeout) {
       clearTimeout(this.cliStartTimeout);
@@ -1223,6 +1237,7 @@ class CopilotClient {
         ...this.onGitHubTelemetry != null ? { enableGitHubTelemetryForwarding: true } : {},
         mcpServers: toWireMcpServers(config.mcpServers),
         mcpOAuthTokenStorage: config.mcpOAuthTokenStorage,
+        authClientIdMetadataUrl: config.authClientIdMetadataUrl,
         envValueMode: "direct",
         customAgents: toWireCustomAgents(config.customAgents),
         customAgentsLocalOnly: config.customAgentsLocalOnly,
@@ -1468,6 +1483,7 @@ class CopilotClient {
         ...this.onGitHubTelemetry != null ? { enableGitHubTelemetryForwarding: true } : {},
         mcpServers: toWireMcpServers(config.mcpServers),
         mcpOAuthTokenStorage: config.mcpOAuthTokenStorage,
+        authClientIdMetadataUrl: config.authClientIdMetadataUrl,
         envValueMode: "direct",
         customAgents: toWireCustomAgents(config.customAgents),
         customAgentsLocalOnly: config.customAgentsLocalOnly,

package/dist/cjs/factory.js

@@ -28,6 +28,7 @@ module.exports = __toCommonJS(factory_exports);
 const FACTORY_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
   "completed",
   "halted",
+  "paused",
   "cancelled",
   "error"
 ]);

package/dist/cjs/ffiRuntimeHost.js

@@ -37,6 +37,7 @@ var import_node_path = require("node:path");
 var import_node_stream = require("node:stream");
 const SYMBOL_PREFIX = "copilot_runtime_";
 const KEEP_ALIVE_INTERVAL_MS = 1 << 30;
+const CLEANUP_RETRY_INTERVAL_MS = 100;
 let loadedLibraryPath;
 let loadedLibrary;
 function loadLibrary(libraryPath) {
@@ -129,12 +130,16 @@ class FfiRuntimeHost {
   cliEntrypoint;
   environment;
   args;
+  static quarantinedHosts = /* @__PURE__ */ new Set();
   lib;
   serverId = 0;
   connectionId = 0;
   disposed = false;
+  starting = false;
   outboundCallback;
   keepAliveTimer;
+  cleanupRetryTimer;
+  cleanupInProgress = false;
   /** The stream JSON-RPC reads server→client frames from. */
   receiveStream;
   /** The stream JSON-RPC writes client→server frames to. */
@@ -156,49 +161,65 @@ class FfiRuntimeHost {
   }
   /** Starts the in-process Rust runtime and opens the FFI JSON-RPC connection. */
   async start() {
+    if (this.disposed) {
+      throw new Error("The in-process runtime host is disposed.");
+    }
+    this.starting = true;
     const argvJson = buildArgvJson(this.cliEntrypoint, this.args);
     const envJson = buildEnvJson(this.environment);
-    this.serverId = await new Promise((resolvePromise, rejectPromise) => {
-      this.lib.hostStart.async(
-        argvJson,
-        argvJson.length,
-        envJson,
-        envJson ? envJson.length : 0,
-        (error, result) => {
-          if (error) {
-            rejectPromise(error);
-          } else {
-            resolvePromise(result);
+    try {
+      this.serverId = await new Promise((resolvePromise, rejectPromise) => {
+        this.lib.hostStart.async(
+          argvJson,
+          argvJson.length,
+          envJson,
+          envJson ? envJson.length : 0,
+          (error, result) => {
+            if (error) {
+              rejectPromise(error);
+            } else {
+              resolvePromise(result);
+            }
           }
-        }
+        );
+      });
+      if (!this.serverId) {
+        throw new Error(
+          `copilot_runtime_host_start failed (library '${this.libraryPath}').`
+        );
+      }
+      if (this.disposed) {
+        throw new Error("The in-process runtime host was disposed during startup.");
+      }
+      this.outboundCallback = import_koffi.default.register(
+        (_userData, bytesPtr, bytesLen) => this.feedInbound(bytesPtr, bytesLen),
+        this.lib.outboundCallbackType
       );
-    });
-    if (!this.serverId) {
-      throw new Error(`copilot_runtime_host_start failed (library '${this.libraryPath}').`);
-    }
-    this.outboundCallback = import_koffi.default.register(
-      (_userData, bytesPtr, bytesLen) => this.feedInbound(bytesPtr, bytesLen),
-      this.lib.outboundCallbackType
-    );
-    this.connectionId = this.lib.connectionOpen(
-      this.serverId,
-      this.outboundCallback,
-      null,
-      null,
-      0,
-      null,
-      0,
-      null,
-      0
-    );
-    if (!this.connectionId) {
-      this.unregisterCallback();
-      this.lib.hostShutdown(this.serverId);
-      this.serverId = 0;
-      throw new Error("copilot_runtime_connection_open failed.");
+      this.connectionId = this.lib.connectionOpen(
+        this.serverId,
+        this.outboundCallback,
+        null,
+        null,
+        0,
+        null,
+        0,
+        null,
+        0
+      );
+      if (!this.connectionId) {
+        this.unregisterCallback();
+        this.lib.hostShutdown(this.serverId);
+        this.serverId = 0;
+        throw new Error("copilot_runtime_connection_open failed.");
+      }
+      this.keepAliveTimer = setInterval(() => {
+      }, KEEP_ALIVE_INTERVAL_MS);
+    } finally {
+      this.starting = false;
+      if (this.disposed) {
+        void this.tryFinalizeCleanup();
+      }
     }
-    this.keepAliveTimer = setInterval(() => {
-    }, KEEP_ALIVE_INTERVAL_MS);
   }
   writeFrame(frame) {
     if (this.disposed || !this.connectionId) {
@@ -237,41 +258,105 @@ class FfiRuntimeHost {
   }
   unregisterCallback() {
     if (this.outboundCallback === void 0) {
-      return;
+      return true;
     }
     const callback = this.outboundCallback;
-    this.outboundCallback = void 0;
     try {
       import_koffi.default.unregister(callback);
-    } catch {
+      this.outboundCallback = void 0;
+      return true;
+    } catch (error) {
+      console.error(
+        `Failed to unregister in-process FFI callback: ${error instanceof Error ? error.stack ?? error.message : String(error)}`
+      );
+      FfiRuntimeHost.quarantinedHosts.add(this);
+      return false;
     }
   }
-  /** Closes the FFI connection, shuts down the native host, and releases resources. */
-  dispose() {
-    if (this.disposed) {
+  scheduleCleanupRetry() {
+    if (this.cleanupRetryTimer !== void 0) {
       return;
     }
-    this.disposed = true;
-    if (this.keepAliveTimer !== void 0) {
-      clearInterval(this.keepAliveTimer);
-      this.keepAliveTimer = void 0;
+    this.cleanupRetryTimer = setTimeout(() => {
+      this.cleanupRetryTimer = void 0;
+      void this.tryFinalizeCleanup();
+    }, CLEANUP_RETRY_INTERVAL_MS);
+  }
+  async tryFinalizeCleanup() {
+    if (this.cleanupInProgress) {
+      this.scheduleCleanupRetry();
+      return;
     }
+    this.cleanupInProgress = true;
     try {
       if (this.connectionId) {
-        this.lib.connectionClose(this.connectionId);
+        let closed = false;
+        try {
+          closed = await new Promise((resolvePromise, rejectPromise) => {
+            this.lib.connectionClose.async(
+              this.connectionId,
+              (error, result) => {
+                if (error) {
+                  rejectPromise(error);
+                } else {
+                  resolvePromise(result);
+                }
+              }
+            );
+          });
+        } catch (error) {
+          console.error(
+            `Failed to close in-process FFI connection: ${error instanceof Error ? error.stack ?? error.message : String(error)}`
+          );
+          FfiRuntimeHost.quarantinedHosts.add(this);
+          if (this.keepAliveTimer !== void 0) {
+            clearInterval(this.keepAliveTimer);
+            this.keepAliveTimer = void 0;
+          }
+          return;
+        }
+        if (!closed) {
+          this.scheduleCleanupRetry();
+          return;
+        }
         this.connectionId = 0;
       }
-    } catch {
-    }
-    try {
+      const callbackUnregistered = this.unregisterCallback();
+      if (this.keepAliveTimer !== void 0) {
+        clearInterval(this.keepAliveTimer);
+        this.keepAliveTimer = void 0;
+      }
       if (this.serverId) {
-        this.lib.hostShutdown(this.serverId);
+        try {
+          if (!this.lib.hostShutdown(this.serverId)) {
+            console.error(
+              `In-process FFI host shutdown did not recognize server ${this.serverId}.`
+            );
+          }
+        } catch (error) {
+          console.error(
+            `Failed to shut down in-process FFI host: ${error instanceof Error ? error.stack ?? error.message : String(error)}`
+          );
+        }
         this.serverId = 0;
       }
-    } catch {
+      if (callbackUnregistered) {
+        FfiRuntimeHost.quarantinedHosts.delete(this);
+      }
+    } finally {
+      this.cleanupInProgress = false;
+    }
+  }
+  /** Awaits the initial cleanup attempt; a non-quiescent close is retried in the background. */
+  async dispose() {
+    if (this.disposed) {
+      return;
     }
+    this.disposed = true;
     this.receiveStream.end();
-    this.unregisterCallback();
+    if (!this.starting) {
+      await this.tryFinalizeCleanup();
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/generated/rpc.js

@@ -266,13 +266,13 @@ function createServerRpc(connection) {
       /**
        * Enables installed plugins for new sessions.
        *
-       * @param params Plugin names (or specs) to enable.
+       * @param params Plugin names (or specs) to enable, plus the optional working directory the repository-controlled guard is evaluated against.
        */
       enable: async (params) => connection.sendRequest("plugins.enable", params),
       /**
        * Disables installed plugins for new sessions.
        *
-       * @param params Plugin names (or specs) to disable.
+       * @param params Plugin names (or specs) to disable, plus the optional working directory the repository-controlled guard is evaluated against.
        */
       disable: async (params) => connection.sendRequest("plugins.disable", params),
       /** @experimental */
@@ -522,7 +522,15 @@ function createServerRpc(connection) {
        */
       list: async (params) => connection.sendRequest("sessions.list", params),
       /**
-       * Reads a page of durable events directly from a local session's persisted journal without creating, resuming, or activating the session. The initial backward read uses a bounded tail scan for fast first paint; cursor continuations preserve the session event-log paging semantics. Persisted events may omit payloads that are reconstructed only for an active session.
+       * Reads client-owned metadata for multiple persisted local sessions without opening them. Results preserve request order and report missing, corrupt, unsupported, or temporarily unavailable sessions independently.
+       *
+       * @param params Bounded batch request for client-owned metadata from persisted local sessions.
+       *
+       * @returns Ordered client metadata outcomes for the requested local sessions.
+       */
+      getClientMetadata: async (params) => connection.sendRequest("sessions.getClientMetadata", params),
+      /**
+       * Reads a page of durable events directly from a local session's persisted journal without creating, resuming, or activating the session. The first read pins the currently opened journal generation and its byte-length boundary; opaque cursor continuations remain on that generation across runtime-owned compaction, truncation, and rewrite operations, which replace the live path atomically, and events appended after the boundary are excluded. For cold hydration, await the first successful page before activation and establish lossless live-event buffering before resume; merge subsequent live events by ID, preserving persisted order and letting live payloads win. Continuations are process-local, single-use capabilities bound to the originating session and storage context and must be paged sequentially; concurrent or repeated use of the same cursor expires that duplicate read rather than reading the generation twice. A complete snapshot has cursorStatus 'ok' and hasMore false. Snapshots expire after five idle minutes, with at most eight retained per process and idle-only eviction under pressure; completion and cancelled-worker exit release their handles. No transcript copy is created, but retained handles may keep replaced files' disk blocks alive until release. Pages have a soft 1 MiB serialized event-array budget including resolved binary assets; one oversized event is returned alone to guarantee progress. Working memory also includes a record/lookahead and asset resolution; resolving the first binary reference may scan the full pinned generation to build a bounded offset index. If the snapshot expires, is evicted, is cancelled before a continuation is established, or becomes unreadable after an observable unsupported in-place shortening, the continuation returns cursorStatus 'expired' with an empty terminal page and never falls back to a different generation. A missing or initially unreadable journal is an RPC error. Persisted history excludes ephemeral events and may omit payloads that are reconstructed only for an active session; use the active session event stream for post-resume live events.
        *
        * @param params Pagination options for reading an inactive or active local session's persisted event journal.
        *
@@ -803,7 +811,15 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Managed sandbox enforcement state for a session.
        */
-      getEnforcementStatus: async () => connection.sendRequest("session.sandbox.getEnforcementStatus", { sessionId })
+      getEnforcementStatus: async () => connection.sendRequest("session.sandbox.getEnforcementStatus", { sessionId }),
+      /**
+       * Disables sandboxing for the remainder of the current session and approves the referenced pending sandbox-bypass permission request. The request is rejected unless the exact request is still pending and the effective sandbox policy permits bypass.
+       *
+       * @param params Request to disable sandboxing for the current session while resolving an active sandbox-bypass permission prompt.
+       *
+       * @returns Result of attempting to disable sandboxing for the current session.
+       */
+      disableForSession: async (params) => connection.sendRequest("session.sandbox.disableForSession", { sessionId, ...params })
     },
     /**
      * Aborts the current agent turn.
@@ -967,6 +983,14 @@ function createSessionRpc(connection, sessionId) {
        * @returns Complete current or terminal factory run envelope.
        */
       cancel: async (params) => connection.sendRequest("session.factory.cancel", { sessionId, ...params }),
+      /**
+       * Pauses a running factory and returns its settled run envelope.
+       *
+       * @param params Parameters for pausing a running factory.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      pause: async (params) => connection.sendRequest("session.factory.pause", { sessionId, ...params }),
       /**
        * Records a batch of ordered factory progress lines.
        *
@@ -1027,6 +1051,14 @@ function createSessionRpc(connection, sessionId) {
        * @returns Immediate acknowledgement and Auto preference snapshot after a switch request. This result never implies that a pending preference committed.
        */
       switchAutoTier: async (params) => connection.sendRequest("session.model.switchAutoTier", { sessionId, ...params }),
+      /**
+       * Replaces or clears the host-supplied model allowlist for a running session.
+       *
+       * @param params Host-supplied exact model selection IDs to allow for this running session. CAPI IDs are intersected with repository `.github/allowed_models.txt` policy; provider-qualified IDs remain exempt from repository-only policy but are restricted by this host list. Omit or pass null to clear the host restriction; an explicit empty or disjoint list is rejected. Validation and pre-selection fallback failures preserve the previous restriction. Failures after a fallback selection commits retain the new restriction and selected model; callers should inspect current session state after such an error.
+       *
+       * @returns The applied host allowlist and effective session model policy after intersection.
+       */
+      setAllowedModels: async (params) => connection.sendRequest("session.model.setAllowedModels", { sessionId, ...params }),
       /**
        * Updates the session's reasoning effort without changing the selected model.
        *
@@ -1272,7 +1304,7 @@ function createSessionRpc(connection, sessionId) {
       /**
        * Starts fleet mode by submitting the fleet orchestration prompt to the session.
        *
-       * @param params Optional user prompt to combine with the fleet orchestration instructions.
+       * @param params Parameters for starting fleet orchestration: an optional user prompt combined with the fleet instructions, plus the send options forwarded to the resulting turn.
        *
        * @returns Indicates whether fleet mode was successfully activated.
        */
@@ -1814,7 +1846,7 @@ function createSessionRpc(connection, sessionId) {
        */
       set: async (params) => connection.sendRequest("session.tools.set", { sessionId, ...params }),
       /**
-       * Updates the current session's live subagent settings after user settings change. The persisted user settings remain the source of truth for future sessions.
+       * Sets the current session's live subagent settings override, which takes precedence over persisted user settings until cleared. Persisted user settings remain the source of truth for future sessions.
        *
        * @param params Subagent settings to apply to the current session
        *
@@ -2164,6 +2196,20 @@ function createSessionRpc(connection, sessionId) {
        * @returns Point-in-time snapshot of slow-changing session identifier and state fields
        */
       snapshot: async () => connection.sendRequest("session.metadata.snapshot", { sessionId }),
+      /**
+       * Returns the client-owned string metadata persisted with this local session. The metadata is not included in model context, events, telemetry, snapshots, or remote exports.
+       *
+       * @returns Client-owned, case-sensitive string metadata persisted with a local session. Clients should namespace keys by owner. Keys must be non-empty and at most 256 UTF-8 bytes; keys under `copilot/` and `github/` are reserved. Values may contain at most 16 KiB of UTF-8 data. A bag may contain at most 128 entries and its serialized sidecar may contain at most 64 KiB. The runtime stores but never interprets these values.
+       */
+      getClientMetadata: async () => connection.sendRequest("session.metadata.getClientMetadata", { sessionId }),
+      /**
+       * Atomically patches the client-owned string metadata persisted with this local session and returns the committed bag.
+       *
+       * @param params Atomic patch for client-owned session metadata. Operations apply in clear, remove, then set order. The resulting bag must satisfy the ClientMetadata entry and serialized-size limits. Local storage coordinates concurrent runtime processes; custom SessionFs providers must serialize writers that access the same session from multiple processes.
+       *
+       * @returns Client-owned, case-sensitive string metadata persisted with a local session. Clients should namespace keys by owner. Keys must be non-empty and at most 256 UTF-8 bytes; keys under `copilot/` and `github/` are reserved. Values may contain at most 16 KiB of UTF-8 data. A bag may contain at most 128 entries and its serialized sidecar may contain at most 64 KiB. The runtime stores but never interprets these values.
+       */
+      updateClientMetadata: async (params) => connection.sendRequest("session.metadata.updateClientMetadata", { sessionId, ...params }),
       /**
        * Reports whether the local session is currently processing user/agent messages.
        *
@@ -2621,7 +2667,13 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Resolved persisted factory identity and resumed run envelope.
        */
-      resumeFromTool: async (params) => connection.sendRequest("session.factory.resumeFromTool", { sessionId, ...params })
+      resumeFromTool: async (params) => connection.sendRequest("session.factory.resumeFromTool", { sessionId, ...params }),
+      /**
+       * Atomically pauses an owned factory attempt at a durable checkpoint.
+       *
+       * @param params Parameters for an owned durable pause checkpoint.
+       */
+      pauseAtCheckpoint: async (params) => connection.sendRequest("session.factory.pauseAtCheckpoint", { sessionId, ...params })
     },
     /** @experimental */
     model: {

package/dist/cjs/session.js

@@ -41,10 +41,14 @@ const factoryExecutionStore = new import_node_async_hooks.AsyncLocalStorage();
 function throwIfFactoryExecutionIsActive() {
   if (factoryExecutionStore.getStore()?.active) {
     throw new Error(
-      "factory.run and factory.resume are not allowed while a factory body is running on this call path."
+      "factory.run, factory.resume, and factory.pause are not allowed while a factory body is running on this call path."
     );
   }
 }
+function runInFactoryHelperScope(helperScope, callback) {
+  const current = factoryExecutionStore.getStore();
+  return factoryExecutionStore.run({ active: current?.active ?? false, helperScope }, callback);
+}
 function deserializeHookInput(raw) {
   if (!raw || typeof raw !== "object" || typeof raw.timestamp !== "number") {
     return raw;
@@ -88,7 +92,7 @@ async function runFactoryParallel(thunks) {
   }
   return Promise.all(
     thunks.map(
-      (thunk) => Promise.resolve().then(() => thunk()).catch((error) => {
+      (thunk) => Promise.resolve().then(() => runInFactoryHelperScope("parallel", thunk)).catch((error) => {
         if (isFactoryFatalError(error)) {
           throw error;
         }
@@ -107,7 +111,10 @@ async function runFactoryPipeline(items, ...stages) {
       let previous = item;
       for (const stage of stages) {
         try {
-          previous = await stage(previous, item, index);
+          previous = await runInFactoryHelperScope(
+            "pipeline",
+            () => stage(previous, item, index)
+          );
         } catch (error) {
           if (isFactoryFatalError(error)) {
             throw error;
@@ -264,6 +271,7 @@ class CopilotSession {
   hooks;
   transformCallbacks;
   _rpc = null;
+  _internalRpc = null;
   traceContextProvider;
   managedSettingsEnabled;
   _capabilities = {};
@@ -330,6 +338,10 @@ class CopilotSession {
     }),
     getRunDetail: (runId) => this.rpc.factory.getRunDetail({ runId }),
     getRunProgress: (runId, options = {}) => this.rpc.factory.getRunProgress({ runId, ...options }),
+    pause: async (runId) => {
+      throwIfFactoryExecutionIsActive();
+      return this.rpc.factory.pause({ runId });
+    },
     cancel: async (runId) => this.rpc.factory.cancel({ runId })
   };
   /**
@@ -428,6 +440,13 @@ class CopilotSession {
     }
     return this._rpc;
   }
+  /** @internal */
+  get internalRpc() {
+    if (!this._internalRpc) {
+      this._internalRpc = (0, import_rpc.createInternalSessionRpc)(this.connection, this.sessionId);
+    }
+    return this._internalRpc;
+  }
   /**
    * Path to the session workspace directory when infinite sessions are enabled.
    * Contains checkpoints/, plan.md, and files/ subdirectories.
@@ -469,6 +488,7 @@ class CopilotSession {
       ...await (0, import_telemetry.getTraceContext)(this.traceContextProvider),
       sessionId: this.sessionId,
       prompt: options.prompt,
+      source: options.source,
       displayPrompt: options.displayPrompt,
       attachments: options.attachments,
       mode: options.mode,
@@ -1109,6 +1129,36 @@ class CopilotSession {
               );
               return result2;
             },
+            pause: async (key) => {
+              if (typeof key !== "string" || key.length === 0) {
+                throw new Error("Factory pause checkpoint key must not be empty");
+              }
+              const helperScope = factoryExecutionStore.getStore()?.helperScope;
+              if (helperScope !== void 0) {
+                throw new Error(
+                  `Factory pause checkpoints are not allowed inside ${helperScope}() branches`
+                );
+              }
+              await progress.flush();
+              const response = await awaitFactoryOperation(
+                () => self.internalRpc.factory.pauseAtCheckpoint({
+                  runId: params.runId,
+                  executionToken: params.executionToken,
+                  key
+                }),
+                controller.signal
+              );
+              switch (response.action) {
+                case "continue":
+                  return;
+                case "pause":
+                  await awaitFactoryOperation(
+                    () => new Promise(() => {
+                    }),
+                    controller.signal
+                  );
+              }
+            },
             parallel: runFactoryParallel,
             pipeline: runFactoryPipeline,
             factory: async () => {
@@ -1144,11 +1194,9 @@ class CopilotSession {
       },
       async abort(params) {
         const controllersForRun = self.factoryAbortControllers.get(params.runId);
-        if (controllersForRun !== void 0) {
-          const reason = new DOMException("Factory run was aborted", "AbortError");
-          for (const controller of controllersForRun.values()) {
-            controller.abort(reason);
-          }
+        const controller = controllersForRun?.get(params.executionToken);
+        if (controller !== void 0) {
+          controller.abort(new DOMException("Factory run was aborted", "AbortError"));
         }
         return {};
       }

package/dist/cliVersion.d.ts

@@ -1,2 +1,2 @@
-export declare const COPILOT_CLI_VERSION = "1.0.83";
+export declare const COPILOT_CLI_VERSION = "1.0.84-5";
 export declare const COPILOT_CLI_USE_NPM_PACKAGE = false;

package/dist/cliVersion.js

@@ -1,4 +1,4 @@
-const COPILOT_CLI_VERSION = "1.0.83";
+const COPILOT_CLI_VERSION = "1.0.84-5";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 export {
   COPILOT_CLI_USE_NPM_PACKAGE,

package/dist/client.d.ts

@@ -12,6 +12,8 @@ export declare class CopilotClient {
     private runtimePort;
     private actualHost;
     private state;
+    /** Shared in-flight start; concurrent callers await it instead of spawning another CLI. */
+    private startPromise;
     private sessions;
     private stderrBuffer;
     /** Resolved connection mode chosen in the constructor. */
@@ -122,6 +124,7 @@ export declare class CopilotClient {
      * ```
      */
     start(): Promise<void>;
+    private doStart;
     /**
      * Stops the CLI server and closes all active sessions.
      *