@github/copilot-sdk 1.0.20 → 1.0.21-preview.0

package/README.md

@@ -671,6 +671,23 @@ if (result.status === "pending") {
 
 See [Auto tier persistence](../docs/features/session-persistence.md#auto-tier-persistence) for the full lifecycle rules.
 
+##### `rpc.model.getReasoningSummaries(params)` (experimental)
+
+Read the current model's reasoning-summary presentation policy without changing session state. Call `session.rpc.model.list()` first to load the model catalog; otherwise the result may have `ready: false`. The request and result types are exported from `@github/copilot-sdk`.
+
+```typescript
+import type {
+    ModelGetReasoningSummariesRequest,
+    ModelGetReasoningSummariesResult,
+} from "@github/copilot-sdk";
+
+const presentation: ModelGetReasoningSummariesRequest = { summariesVisible: false };
+const policy: ModelGetReasoningSummariesResult =
+    await session.rpc.model.getReasoningSummaries(presentation);
+```
+
+Omit `persistedShowReasoning` when no visibility setting is saved. `visibility` can remain unset while experiment assignment is pending; `clearRedundantSetting` tells the host when its persisted setting matches the model default.
+
 ##### `setTools(tools: Tool[]): Promise<void>`
 
 Replace the tools this client supplies to the session, together with the handlers that serve them (experimental). `tools` takes the same definitions as `createSession` and becomes this client's complete tool set; pass `[]` to remove all of this client's tools. Built-in, MCP, and plugin tools, and tools other connected clients supply, are unaffected.
@@ -1635,6 +1652,26 @@ npm ci
 npm test
 ```
 
+### Internal feature-flag example
+
+[`examples/internal-feature-flags.ts`](examples/internal-feature-flags.ts) uses
+the generated internal RPC factory against a real runtime over stdio.
+It lists the catalog and shows environment, settings, and explicit-override
+precedence. It also checks that static resolution does not apply `COPILOT_EXP_*`
+experiment assignments. It creates no session and sends no model request.
+
+After you prepare matching runtime artifacts, run this from the runtime repository root:
+
+```bash
+COPILOT_RUNTIME_PROVIDER_LIB="$PWD/bazel-bin/src/native/runtime/runtime.node" \
+  src/sdk/nodejs/node_modules/.bin/tsx \
+  src/sdk/nodejs/examples/internal-feature-flags.ts \
+  "$PWD/bazel-bin/src/runtime-bin/copilot-runtime"
+```
+
+The JSON output includes `staticResolution` values of `false`, `true`, `false`,
+and `true`, in that order. These methods are internal, not public SDK APIs.
+
 ## License
 
 MIT

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.96";
+const COPILOT_CLI_VERSION = "1.0.97-0";
 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

@@ -1299,6 +1299,7 @@ class CopilotClient {
         model: config.model,
         allowedModels: config.allowedModels,
         sessionId: localSessionId,
+        name: config.name,
         clientName: config.clientName,
         reasoningEffort: config.reasoningEffort,
         reasoningSummary: config.reasoningSummary,
@@ -1377,6 +1378,8 @@ class CopilotClient {
         enableSkills: config.enableSkills,
         skillDirectories: config.skillDirectories,
         ...config.skillProvider ? { hasSkillProvider: true } : {},
+        agentDirectories: config.agentDirectories,
+        hookDirectories: config.hookDirectories,
         pluginDirectories: config.pluginDirectories,
         instructionDirectories: config.instructionDirectories,
         disabledSkills: config.disabledSkills,
@@ -1645,6 +1648,8 @@ class CopilotClient {
         agent: config.agent,
         skillDirectories: config.skillDirectories,
         ...config.skillProvider ? { hasSkillProvider: true } : {},
+        agentDirectories: config.agentDirectories,
+        hookDirectories: config.hookDirectories,
         pluginDirectories: config.pluginDirectories,
         instructionDirectories: config.instructionDirectories,
         disabledSkills: config.disabledSkills,

package/dist/cjs/generated/rpc.js

@@ -390,6 +390,25 @@ function createServerRpc(connection) {
       disable: async (params) => connection.sendRequest("extensions.disable", params)
     },
     /** @experimental */
+    instructions: {
+      /**
+       * Discovers instruction sources across user, repository, and plugin sources.
+       *
+       * @param params Optional project paths to include in instruction discovery.
+       *
+       * @returns Instruction sources discovered across user, repository, and plugin sources.
+       */
+      discover: async (params) => connection.sendRequest("instructions.discover", params),
+      /**
+       * Returns the canonical files and directories where a client may create custom instructions that the runtime will recognize, including ones that do not exist yet. Repository targets become active once created.
+       *
+       * @param params Optional project paths to include when enumerating instruction discovery targets.
+       *
+       * @returns Canonical files and directories where custom instructions can be created so the runtime will recognize them.
+       */
+      getDiscoveryPaths: async (params) => connection.sendRequest("instructions.getDiscoveryPaths", params)
+    },
+    /** @experimental */
     skills: {
       /**
        * Plans installation of a verified Agent Finder Skill candidate without writing files. The returned review is safe to present to a user and installing always leaves the Skill disabled until separately enabled.
@@ -642,25 +661,6 @@ function createServerRpc(connection) {
       getDiscoveryPaths: async (params) => connection.sendRequest("agents.getDiscoveryPaths", params)
     },
     /** @experimental */
-    instructions: {
-      /**
-       * Discovers instruction sources across user, repository, and plugin sources.
-       *
-       * @param params Optional project paths to include in instruction discovery.
-       *
-       * @returns Instruction sources discovered across user, repository, and plugin sources.
-       */
-      discover: async (params) => connection.sendRequest("instructions.discover", params),
-      /**
-       * Returns the canonical files and directories where a client may create custom instructions that the runtime will recognize, including ones that do not exist yet. Repository targets become active once created.
-       *
-       * @param params Optional project paths to include when enumerating instruction discovery targets.
-       *
-       * @returns Canonical files and directories where custom instructions can be created so the runtime will recognize them.
-       */
-      getDiscoveryPaths: async (params) => connection.sendRequest("instructions.getDiscoveryPaths", params)
-    },
-    /** @experimental */
     commands: {
       /**
        * Lists the well-known built-in slash commands that work as the first message in a new session (e.g. /plan, /env), without requiring an active session. Commands that depend on session state, authentication, or a synced session are omitted.
@@ -1079,6 +1079,39 @@ function createInternalServerRpc(connection) {
      */
     connect: async (params) => connection.sendRequest("connect", params),
     /** @experimental */
+    account: {
+      /**
+       * Renders the sign-in banner and the one-line account description the runtime uses for an authentication identity. The runtime words these in several places for its own callers, so a host that announces a sign-in or an account switch should render them from here rather than composing its own, which would let the two spellings drift apart.
+       *
+       * @param params The authentication identity whose shared wording should be rendered.
+       *
+       * @returns The wording the runtime uses for an authentication identity.
+       */
+      describeAuthInfo: async (params) => connection.sendRequest("account.describeAuthInfo", params),
+      /**
+       * Reports whether the supplied identity can create gists. Gists are unavailable on GitHub Enterprise Cloud with data residency, and to Enterprise Managed Users on github.com, so a host that offers gist actions should hide or disable them when this reports no support.
+       *
+       * @param params The authentication identity whose gist support should be reported.
+       *
+       * @returns Whether the identity can create gists, and why not when it cannot.
+       */
+      getGistSupport: async (params) => connection.sendRequest("account.getGistSupport", params),
+      /**
+       * Resolves a path on the identity's GitHub host into an absolute URL, so a host can link to settings or documentation on the enterprise instance the user is signed in to rather than to github.com. Falls back to the public host when no identity is supplied.
+       *
+       * @param params A path to resolve against the GitHub host an identity is signed in to.
+       *
+       * @returns An absolute URL on the identity's GitHub host.
+       */
+      getWebUrl: async (params) => connection.sendRequest("account.getWebUrl", params),
+      /**
+       * Names the environment variable supplying a classic personal access token, if one is set. A classic token cannot be upgraded in place, so a host that finds one should tell the user which variable to unset rather than starting an interactive sign-in that the variable would override.
+       *
+       * @returns The environment variable supplying a classic personal access token, when one is set.
+       */
+      getTokenEnvVar: async () => connection.sendRequest("account.getTokenEnvVar", {})
+    },
+    /** @experimental */
     mcp: {
       /** @experimental */
       registry: {
@@ -1105,6 +1138,12 @@ function createInternalServerRpc(connection) {
          */
         cancel: async (params) => connection.sendRequest("mcp.registry.cancel", params)
       },
+      /**
+       * Lists the MCP servers the runtime supplies itself, so a host that disables the built-ins wholesale suppresses exactly the set the runtime would otherwise add. The names are fixed for a build and depend on no configuration, session or account.
+       *
+       * @returns Names of the MCP servers the runtime supplies itself.
+       */
+      listBuiltinServerNames: async () => connection.sendRequest("mcp.listBuiltinServerNames", {}),
       /**
        * Reports whether the gh-replaceable GitHub MCP tools may be clipped for a session, which a host feeds back as the `excludeGhReplaceableTools` build option. The tools are redundant only when the session can reach a shell *and* the host has the `gh` that would replace them, so both halves are decided here. The shell half runs the platform shell tool through the runtime's own tool-filter matcher, so entry forms like `builtin:bash` and `builtin:*` behave exactly as they do when a session builds its tool catalog. The host half probes for `gh`, and is skipped entirely when the filters already rule the shell out. Host presence alone is not enough: a session restricted to, say, `view` would otherwise lose the built-in issue-read fallback while having no shell to replace it with. The answer describes the host the runtime runs on, so it is never forwarded to a remote engine.
        *
@@ -1115,6 +1154,27 @@ function createInternalServerRpc(connection) {
       shouldExcludeGitHubTools: async (params) => connection.sendRequest("mcp.shouldExcludeGitHubTools", params)
     },
     /** @experimental */
+    instructions: {
+      /**
+       * Returns the prompt the `init` command runs to author repository instructions. A host offering its own initialize action sends this text so the instructions it produces match the ones the CLI produces. The text is fixed for a build and depends on no configuration, session or repository.
+       *
+       * @returns The prompt the init command runs.
+       */
+      getInitPrompt: async () => connection.sendRequest("instructions.getInitPrompt", {}),
+      /**
+       * Discovers the instruction sources for one caller-named location and returns them in the order the runtime applies them. `discover` answers for a set of project paths and derives the rest of its scope itself; this one instead takes every argument from the caller — the extra directories to scan and whether to descend into nested instruction files — and honors them as given. It also includes instruction directories from trusted repository settings, matching native repository discovery. Use it when the caller knows its own scope and no session exists to derive that scope from, such as a host reporting how many instruction files a directory contributes before any session starts. Marked internal because it exists to carry a CLI call site off the napi boundary onto the SDK contract; it is migration plumbing, not a surface consumers are meant to depend on.
+       *
+       * @param params Explicit discovery arguments for one location, supplied by the caller rather than derived from a session.
+       *
+       * @returns Instruction sources discovered across user, repository, and plugin sources.
+       */
+      discoverRepoSources: async (params) => connection.sendRequest("instructions.discoverRepoSources", params),
+      /**
+       * Drops the runtime's in-memory cache of discovered custom instructions so the next discovery reads them from disk again. A host calls this after it changes instruction files, or after it trusts a folder whose instructions an earlier discovery skipped, so that a session started afterwards sees the current files instead of a cached earlier answer. The call performs no I/O of its own and removes nothing from disk; it only invalidates, so the cost lands on the next discovery.         Returns once the cache is clear, which is what lets a caller order a session start after it. Marked internal because it exists to carry a CLI call site off the napi boundary onto the SDK contract; it is migration plumbing, not a surface consumers are meant to depend on.
+       */
+      clearCache: async () => connection.sendRequest("instructions.clearCache", {})
+    },
+    /** @experimental */
     agents: {
       /**
        * Lists the agents this runtime ships, by name. A consumer separating shipped agents from ones the user or a plugin authored should compare against these names rather than against `AgentInfo.source`: an authored agent may carry the `builtin` source while not being one of these, and the runtime treats the two as separate questions. `disableableNames` is the subset a user may turn off, which a client needs to decide whether to offer a toggle. `yamlBasedNames` is the subset backed by a shipped YAML definition, which a client needs before asking the runtime to load one.
@@ -1179,6 +1239,129 @@ function createInternalServerRpc(connection) {
       writeKey: async (params) => connection.sendRequest("globalState.writeKey", params)
     },
     /** @experimental */
+    user: {
+      /** @experimental */
+      settings: {
+        /**
+         * Resolves the on-disk locations of the settings files this runtime reads, so a consumer can show or open them. The user path is the same file `user.settings.get`, `user.settings.load`, and `user.settings.set` operate on. Supply `repoRoot` to also resolve that repository's checked-in and local settings paths. A path is reported whether or not the file exists.
+         *
+         * @param params Selects which settings file paths to resolve.
+         *
+         * @returns On-disk locations of the settings files this runtime reads. A path is reported whether or not the file exists.
+         */
+        getPaths: async (params) => connection.sendRequest("user.settings.getPaths", params),
+        /**
+         * Lists the top-level user-setting keys by who is allowed to govern them: `repo` keys a repository may override through `.github/copilot/settings.json`, `claudeRepo` keys a repository may override through a Claude-compatible config, and `managed` keys an enterprise policy may fix. The lists are static for a given runtime build and fail closed: a key absent from a list cannot be governed that way.
+         *
+         * @returns Top-level user-setting keys grouped by who may govern them.
+         */
+        listGovernanceKeys: async () => connection.sendRequest("user.settings.listGovernanceKeys", {}),
+        /**
+         * Atomically edits one canonical user setting inside its settings-file lock. Reads, canonicalizes touched aliases, applies the edit, validates the resulting top-level setting and writes before releasing the lock. An explicit autoUpdatesChannel set completes the staff migration in the same transaction. Only a malformed existing file returns `invalid`; refused keys, invalid values and I/O errors reject the call.
+         *
+         * @param params One atomic edit of a canonical setting in settings.json.
+         *
+         * @returns Outcome of an atomic user or repository settings edit.
+         */
+        edit: async (params) => connection.sendRequest("user.settings.edit", params),
+        /**
+         * Rewrites legacy and snake_case setting names in a settings object to their canonical spelling. A caller editing settings.json must normalize before writing: a legacy key left in place survives the write, is re-normalized on the next load, and silently shadows the canonical value the write just stored.
+         *
+         * @param params Settings object whose key names should be canonicalized.
+         *
+         * @returns Settings object with canonical key names.
+         */
+        normalize: async (params) => connection.sendRequest("user.settings.normalize", params),
+        /**
+         * Diagnoses a set of already-loaded settings layers, reporting each key that will not take effect and why. Settings load tolerantly so that one bad key does not stop a session from starting; this method surfaces what was dropped so a caller can report it instead of silently ignoring the user's intent. Takes the layers as given rather than reading them, so a caller can diagnose exactly the content it is showing, including unsaved edits. Never echoes a setting's value, because a value may be a token or another secret. Marked internal because it exists to carry a CLI call site off the native addon, not to serve a consumer-facing need; it becomes public once an SDK consumer needs to inspect settings health itself.
+         *
+         * @param params The settings layers to diagnose.
+         *
+         * @returns The settings that will not take effect across the given layers.
+         */
+        diagnoseProblems: async (params) => connection.sendRequest("user.settings.diagnoseProblems", params),
+        /**
+         * Validates one top-level setting subtree and writes just that key to settings.json as a single step. Doing both here closes the race a caller cannot close itself: between a separate preflight read and the write, the file may change. Rewriting only the touched key keeps legacy siblings out of settings.json. Answers a status rather than failing, so a validation problem and a write problem stay distinguishable.
+         *
+         * @param params A single top-level setting subtree to validate and write.
+         *
+         * @returns Outcome of validating and writing one top-level setting subtree.
+         */
+        applyTopKey: async (params) => connection.sendRequest("user.settings.applyTopKey", params),
+        /**
+         * Replaces the user settings file's entire content in one write. A key absent from `settings` is removed, which is what distinguishes this from `user.settings.set`: that one merges, so it can never clear a key the caller has dropped. For a caller saving the result of a raw edit, a merge would silently resurrect every key the user deleted. Records the same one-time mutation marks a per-key write records, so a setting the user has now chosen explicitly stops being migrated for them.
+         *
+         * @param params The whole content to store in the user settings file.
+         */
+        writeAll: async (params) => connection.sendRequest("user.settings.writeAll", params),
+        /**
+         * Merges a partial object into one top-level user setting, re-reading the stored value inside this runtime process's settings.json write lock so that concurrent writers in this process to different sub-fields of the same key do not clobber each other. Unlike `user.settings.set`, which replaces a key's whole value with what the caller last read, this keeps sub-fields the caller did not name when both the stored value and supplied value are objects; otherwise the supplied value replaces the stored value. Use it whenever two independent surfaces own different sub-fields of one setting. Returns the key's stored value after the write, in `value`.
+         *
+         * @param params Names the user setting to merge into, and the partial object to merge.
+         *
+         * @returns The stored value of the user setting after the merge.
+         */
+        update: async (params) => connection.sendRequest("user.settings.update", params),
+        /**
+         * Reads settings.json as stored for a caller that is about to edit it. Unlike `user.settings.get`, this returns file values rather than per-key metadata and defaults. Reports `missing` for an absent file and `invalid` when the existing file will not parse. Retired config.json and extensionless files are not read.
+         *
+         * @returns Contents of settings.json as stored, for a caller about to rewrite it.
+         */
+        loadForEdit: async () => connection.sendRequest("user.settings.loadForEdit", {}),
+        /**
+         * Validates one top-level setting subtree without writing it, reporting each problem with the path it applies to. Scoped to a single top-level key on purpose: validating the whole file would reject an edit whenever an unrelated pre-existing field is malformed, locking the user out of the very tool that could fix it.
+         *
+         * @param params A single top-level setting subtree to validate.
+         *
+         * @returns Outcome of validating one top-level setting subtree.
+         */
+        validate: async (params) => connection.sendRequest("user.settings.validate", params)
+      }
+    },
+    /** @experimental */
+    featureFlags: {
+      /**
+       * Lists every feature flag this runtime declares, with the population each one is declared for, its experimental description, and the online-experiment flag it maps to. This is the static catalog: it describes how each flag is defined, not whether it is on for anyone. Use `featureFlags.resolve` for static values with caller overrides, not active runtime values or experiment assignments.
+       *
+       * @returns Every feature flag this runtime declares, with the shape each one was declared with.
+       */
+      listMetadata: async () => connection.sendRequest("featureFlags.listMetadata", {}),
+      /**
+       * Computes static feature flags from the supplied population and overrides without changing runtime state or verifying audience membership. Starts from declared availability, then applies direct feature-flag environment values, user settings, and explicit `flagOverrides`. It does not apply `COPILOT_EXP_*` experiment assignments, authenticated startup gates, or active runtime state. Settings include `enabledFeatureFlags`, the legacy `feature_flags.enabled` list, and supported convenience settings. Supply `baseFlags` to use an existing flag set instead of declared availability. Omit `isStaffGitHub` or `isStaffMicrosoft` when membership was never recorded: a legacy staff account then counts as both populations.
+       *
+       * @param params Caller population and overrides for static feature-flag resolution, independent of experiment assignments and active runtime state.
+       *
+       * @returns The resolved feature flags, keyed by flag name.
+       */
+      resolve: async (params) => connection.sendRequest("featureFlags.resolve", params)
+    },
+    /** @experimental */
+    repo: {
+      /** @experimental */
+      settings: {
+        /**
+         * Reads one repository settings file without settings normalization or layering. The existing JSONC parser accepts comments and trailing commas and applies its prototype-safety rules. Missing or blank files return an empty valid config. Invalid files return an empty config with invalid=true; other read failures reject.
+         *
+         * @param params Which repository settings file to read.
+         *
+         * @returns Parsed repository settings without normalization or layering.
+         */
+        readRaw: async (params) => connection.sendRequest("repo.settings.readRaw", params),
+        /**
+         * Writes or removes one allowed top-level repository setting through the existing validator and file lock. Preserves unrelated stored keys. Invalid keys, values, existing documents, and I/O errors reject without replacing the file. Deletion requires delete=true; otherwise value must be present.
+         *
+         * @param params One key to write or remove in a repository settings file.
+         */
+        writeKey: async (params) => connection.sendRequest("repo.settings.writeKey", params),
+        /**
+         * Replaces the repository-overridable settings in one locked write. Allowed keys present in settings are validated and written; allowed keys absent from settings are removed. Other input keys are ignored, and unknown keys already stored in the file remain unchanged. Invalid values or an invalid existing file reject without a partial write.
+         *
+         * @param params The complete set of repository-overridable settings to store.
+         */
+        writeAll: async (params) => connection.sendRequest("repo.settings.writeAll", params)
+      }
+    },
+    /** @experimental */
     gitHubRepository: {
       /**
        * Resolves the GitHub repository that owns a working-tree path by reading the selected git remote configured for it, preferring `origin`. Returns a null `repository` when the path is inside a git working tree but that selected remote does not resolve to a GitHub host. Fails when the path is not inside a git working tree at all, so a caller can tell 'not a repository' apart from 'a repository with no GitHub remote'.
@@ -1723,6 +1906,14 @@ function createSessionRpc(connection, sessionId) {
        * @returns Update the session's reasoning effort without changing the selected model. Use `switchTo` instead when you also need to change the model. The runtime stores the effort on the session and applies it to subsequent turns.
        */
       setReasoningEffort: async (params) => connection.sendRequest("session.model.setReasoningEffort", { ...params, sessionId }),
+      /**
+       * Computes whether the session's current model shows reasoning summaries and how a host should present them: the default Ctrl+T visibility, reasoning headers, the hidden-summaries hint, and whether a persisted `showReasoning` setting is redundant. The runtime folds in the session's model catalog, selection and reasoning-summaries experiment assignment; the host supplies only its own persisted setting and current visibility. This method reads the session's resolved model catalog rather than resolving it, so call `session.model.list` first on a session that has not listed models or run a turn; until then the result is `ready: false`. A session that resolves models without a Copilot catalog, that is a BYOK registry or an alternate provider, never caches one and stays `ready: false`.
+       *
+       * @param params Host presentation state the reasoning-summaries policy depends on.
+       *
+       * @returns Reasoning-summaries presentation policy for the session's current model.
+       */
+      getReasoningSummaries: async (params) => connection.sendRequest("session.model.getReasoningSummaries", { ...params, sessionId }),
       /**
        * Lists models available to this session using its own auth and integration context. Connected hosts (CLI TUI, GitHub App) should call this through the session client so remote sessions return the remote CLI's available models rather than the caller's.
        *

package/dist/cliVersion.d.ts

@@ -1,2 +1,2 @@
-export declare const COPILOT_CLI_VERSION = "1.0.96";
+export declare const COPILOT_CLI_VERSION = "1.0.97-0";
 export declare const COPILOT_CLI_USE_NPM_PACKAGE = false;

package/dist/cliVersion.js

@@ -1,4 +1,4 @@
-const COPILOT_CLI_VERSION = "1.0.96";
+const COPILOT_CLI_VERSION = "1.0.97-0";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 export {
   COPILOT_CLI_USE_NPM_PACKAGE,

package/dist/client.js

@@ -1279,6 +1279,7 @@ class CopilotClient {
         model: config.model,
         allowedModels: config.allowedModels,
         sessionId: localSessionId,
+        name: config.name,
         clientName: config.clientName,
         reasoningEffort: config.reasoningEffort,
         reasoningSummary: config.reasoningSummary,
@@ -1357,6 +1358,8 @@ class CopilotClient {
         enableSkills: config.enableSkills,
         skillDirectories: config.skillDirectories,
         ...config.skillProvider ? { hasSkillProvider: true } : {},
+        agentDirectories: config.agentDirectories,
+        hookDirectories: config.hookDirectories,
         pluginDirectories: config.pluginDirectories,
         instructionDirectories: config.instructionDirectories,
         disabledSkills: config.disabledSkills,
@@ -1625,6 +1628,8 @@ class CopilotClient {
         agent: config.agent,
         skillDirectories: config.skillDirectories,
         ...config.skillProvider ? { hasSkillProvider: true } : {},
+        agentDirectories: config.agentDirectories,
+        hookDirectories: config.hookDirectories,
         pluginDirectories: config.pluginDirectories,
         instructionDirectories: config.instructionDirectories,
         disabledSkills: config.disabledSkills,