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

package/dist/generated/rpc.d.ts

@@ -5276,6 +5276,38 @@ export type SkillInstallationResult = {
  */
 /** @experimental */
 export type SlashCommandInvocationResult = SlashCommandTextResult | SlashCommandAgentPromptResult | SlashCommandCompletedResult | SlashCommandSelectSubcommandResult | SlashCommandAddTimelineEntryResult | SlashCommandShowDialogResult | SlashCommandSetModelResult | SlashCommandSetPlanModelResult;
+/**
+ * What the one-time staff log-level migration did.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "StaffLogLevelMigrationStatus".
+ */
+/** @experimental */
+export type StaffLogLevelMigrationStatus = 
+/** The account is not a staff account, so the migration does not apply and nothing was recorded. */
+"ineligible"
+/** The migration already ran; the stored completion timestamp is returned unchanged. */
+ | "current"
+/** The migration ran now. The persisted settings may have changed, so the host should adopt the returned settings when they are present. */
+ | "refreshed";
+/**
+ * What the one-time staff update-channel migration did.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "StaffUpdateChannelMigrationStatus".
+ */
+/** @experimental */
+export type StaffUpdateChannelMigrationStatus = 
+/** The account is not a staff account, so the migration does not apply and nothing was recorded. */
+"ineligible"
+/** The migration already ran within the cutoff window; the stored completion timestamp is returned unchanged. */
+ | "current"
+/** The persisted update channel was changed to stable. Only this outcome requires the host to reload its configuration. */
+ | "migrated"
+/** The persisted channel was already stable, so nothing changed, but the migration is now recorded as done. */
+ | "completed"
+/** The account is on the experimental channel, which the migration deliberately leaves alone, and the migration is recorded as done. */
+ | "excluded-experimental";
 /**
  * Subagent settings to apply, or null to clear the live session override
  *
@@ -5891,6 +5923,62 @@ export type WorkspacesWorkspaceDetailsHostType =
 "github"
 /** Workspace repository is hosted on Azure DevOps. */
  | "ado";
+/**
+ * True when this process can offer installing the sandbox credential-proxy certificate authority into OS trust.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxProxyCaCheckInstallationSupportResult".
+ */
+/** @experimental */
+export type SandboxProxyCaCheckInstallationSupportResult = boolean;
+/**
+ * True when the sandbox configuration uses the credential proxy and can need certificate-authority setup.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxProxyCaCheckRelevanceResult".
+ */
+/** @experimental */
+export type SandboxProxyCaCheckRelevanceResult = boolean;
+/**
+ * True when an OS-level sandbox can run on this host.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxCheckPlatformSupportResult".
+ */
+/** @experimental */
+export type SandboxCheckPlatformSupportResult = boolean;
+/**
+ * True when the sandbox on this host can reach host loopback directly.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxCheckWindowsHostLoopbackSupportResult".
+ */
+/** @experimental */
+export type SandboxCheckWindowsHostLoopbackSupportResult = boolean;
+/**
+ * The user-facing refusal, including the platform remedy and the documentation link.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxGetUnsupportedMessageResult".
+ */
+/** @experimental */
+export type SandboxGetUnsupportedMessageResult = string;
+/**
+ * The user-facing notice that a saved sandbox setting is inert for this session.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxGetUnsupportedSettingDisabledNoticeResult".
+ */
+/** @experimental */
+export type SandboxGetUnsupportedSettingDisabledNoticeResult = string;
+/**
+ * True when the command stays available while enforcement is blocked.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxCheckEnforcementCommandResult".
+ */
+/** @experimental */
+export type SandboxCheckEnforcementCommandResult = boolean;
 /**
  * List of all authenticated users
  *
@@ -19425,6 +19513,27 @@ export interface PermissionsConfigureResult {
      */
     success: boolean;
 }
+/**
+ * The policy questions a host asks before granting elevated permissions.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "PermissionsEvaluateManagedPolicyResult".
+ */
+/** @experimental */
+export interface PermissionsEvaluateManagedPolicyResult {
+    /**
+     * True when managed policy forbids bypass-permissions mode, so allow-all style flags must not take effect.
+     */
+    bypassPermissionsDisabled: boolean;
+    /**
+     * True when a managed policy exists but this build could not determine its meaning. Hosts fail closed on it rather than assuming permission was granted.
+     */
+    policyUndetermined: boolean;
+    /**
+     * True when the managed layer supplies permission rules that the session must enforce.
+     */
+    permissionRulesActive: boolean;
+}
 /**
  * Indicates whether the operation succeeded.
  *
@@ -19696,6 +19805,44 @@ export interface PermissionUrlsSetUnrestrictedModeParams {
      */
     enabled: boolean;
 }
+/**
+ * A complete JSON snapshot to write under the runtime's per-path file lock.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "PersistenceWriteRawJsonLockedRequest".
+ */
+/** @experimental */
+export interface PersistenceWriteRawJsonLockedRequest {
+    /**
+     * Absolute path of the file to replace. Parent directories are created when missing.
+     */
+    path: string;
+    /**
+     * The serialized JSON document to write. It replaces the file's contents entirely; nothing is merged.
+     */
+    dataJson: string;
+    /**
+     * Comment lines to emit above the document, for a format that tolerates them. Omit for strict JSON.
+     */
+    fileHeader?: string | null;
+}
+/**
+ * The outcome of a locked snapshot write.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "PersistenceWriteRawJsonLockedResult".
+ */
+/** @experimental */
+export interface PersistenceWriteRawJsonLockedResult {
+    /**
+     * Whether the file now holds the requested contents.
+     */
+    success: boolean;
+    /**
+     * Why the write failed. Absent when `success` is true. A lock the runtime could not acquire in time reports here rather than raising.
+     */
+    error?: string | null;
+}
 /**
  * Optional message to echo back to the caller.
  *
@@ -21801,6 +21948,19 @@ export interface RemoteSessionRepository {
      */
     branch?: string;
 }
+/**
+ * The stored sandbox settings to resolve against the defaults.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxApplyDefaultsRequest".
+ */
+/** @experimental */
+export interface SandboxApplyDefaultsRequest {
+    /**
+     * The sandbox settings as stored in the settings file. An empty object resolves to the defaults alone.
+     */
+    stored: JsonValue;
+}
 /**
  * Resolved sandbox configuration.
  *
@@ -22064,6 +22224,19 @@ export interface SandboxDisableForSessionResult {
      */
     enabled: boolean;
 }
+/**
+ * The documentation URL a host cites when it declines or downgrades a sandbox setting.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxDocsUrlResult".
+ */
+/** @experimental */
+export interface SandboxDocsUrlResult {
+    /**
+     * Documentation URL describing the sandbox and the settings that control it.
+     */
+    url: string;
+}
 /**
  * Managed sandbox enforcement state for a session.
  *
@@ -22192,6 +22365,75 @@ export interface SandboxProxyCaStatus {
      */
     canInstall: boolean;
 }
+/**
+ * The stored sandbox proxy password, if one is present.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxProxySecretGetResult".
+ */
+/** @experimental */
+export interface SandboxProxySecretGetResult {
+    /**
+     * The stored password. Absent when no entry exists in either the keychain or the on-disk fallback store.
+     */
+    value?: string;
+}
+/**
+ * Where this runtime keeps the sandbox proxy password.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxProxySecretLocation".
+ */
+/** @experimental */
+export interface SandboxProxySecretLocation {
+    /**
+     * Absolute path of the credential store holding the sandbox proxy password. The proxy password belongs to no MCP server, so it is kept in its own directory rather than in the MCP secret store.
+     */
+    configDir: string;
+    /**
+     * Identifier of the proxy password entry within that store. Derived from the configuration directory, so two Copilot homes on one machine never share an entry. Use it to recognize a `${secret:…}` reference in stored settings as this runtime's own proxy password.
+     */
+    secretId: string;
+}
+/**
+ * The sandbox proxy password to store.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxProxySecretSaveRequest".
+ */
+/** @experimental */
+export interface SandboxProxySecretSaveRequest {
+    /**
+     * The password to store for the sandbox proxy.
+     */
+    value: string;
+}
+/**
+ * Where the sandbox proxy password was stored.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxProxySecretSaveResult".
+ */
+/** @experimental */
+export interface SandboxProxySecretSaveResult {
+    /**
+     * Whether the OS keychain accepted the value. False means it was written to the on-disk fallback store instead, which is still readable by `sandbox.proxySecret.get`.
+     */
+    storedInKeychain: boolean;
+}
+/**
+ * The user's sandbox settings raised to the managed floor.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SandboxResolveFlooredConfigResult".
+ */
+/** @experimental */
+export interface SandboxResolveFlooredConfigResult {
+    /**
+     * The floored sandbox config, normalized through the declared sandbox shape so only declared fields in a fixed order are present.
+     */
+    sandboxJson: JsonValue;
+}
 /**
  * Register an absolute-time scheduled prompt.
  *
@@ -28612,6 +28854,27 @@ export interface UserSettingsGovernanceKeysResult {
      */
     managed: string[];
 }
+/**
+ * The filesystem and environment facts a user-settings file is resolved from. Passed explicitly rather than read from the runtime's own process, so a host whose configuration directory differs from its process environment resolves the file it means.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UserSettingsHostContext".
+ */
+/** @experimental */
+export interface UserSettingsHostContext {
+    /**
+     * The Copilot configuration directory, when the host set one. Takes precedence over `COPILOT_HOME` and the home directory.
+     */
+    configDir?: string;
+    /**
+     * The user's home directory, used when neither a configuration directory nor `COPILOT_HOME` is set.
+     */
+    homeDirectory: string;
+    /**
+     * The host's environment variables. `COPILOT_HOME` is read from here, as are the variables a settings hook may expand.
+     */
+    environment: {};
+}
 /**
  * Contents of settings.json as stored, for a caller about to rewrite it.
  *
@@ -28629,6 +28892,83 @@ export interface UserSettingsLoadForEditResult {
      */
     settings?: JsonValue;
 }
+/**
+ * Selects the repository whose checked-in settings to read.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UserSettingsLoadRepoRequest".
+ */
+/** @experimental */
+export interface UserSettingsLoadRepoRequest {
+    /**
+     * Absolute path of the repository root whose settings to read. When this is the user's home directory, the Claude-compatible configuration is skipped, so a home-directory session does not inherit a personal config as if it were repository policy.
+     */
+    repoRoot: string;
+}
+/**
+ * A repository's settings as stored, together with any diagnostic raised while reading them.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UserSettingsLoadRepoResult".
+ */
+/** @experimental */
+export interface UserSettingsLoadRepoResult {
+    /**
+     * The repository's settings document, keyed by setting name, with each value carried verbatim. Null when the repository declares no settings.
+     */
+    settings?: {
+        [k: string]: JsonValue | undefined;
+    } | null;
+    /**
+     * Why part of the document was ignored, as a single human-readable string joining every diagnostic with `; `. Null when the document loaded cleanly. The settings that did load are still reported, so a consumer should surface this and continue rather than treat it as a failure.
+     */
+    warning?: string | null;
+}
+/**
+ * The user's stored settings, together with any diagnostic raised while reading them.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UserSettingsLoadWithWarningResult".
+ */
+/** @experimental */
+export interface UserSettingsLoadWithWarningResult {
+    /**
+     * The stored user settings document, keyed by setting name, with each value carried verbatim. Empty when the file could not be read at all.
+     */
+    settings: {
+        [k: string]: JsonValue | undefined;
+    };
+    /**
+     * Why part of the document was ignored, phrased for display to the user. Null when the document loaded cleanly. The settings that did load are still reported, so a consumer may surface this and continue rather than treat it as a failure.
+     */
+    warning?: string | null;
+}
+/**
+ * The user layer folded over the managed layer.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UserSettingsMergeManagedAndUserResult".
+ */
+/** @experimental */
+export interface UserSettingsMergeManagedAndUserResult {
+    /**
+     * The merged settings. An empty object when neither layer was supplied, so an unmanaged host with no user settings governs nothing.
+     */
+    settingsJson: JsonValue;
+}
+/**
+ * The repository layer folded into the user layer.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UserSettingsMergeRepoValueResult".
+ */
+/** @experimental */
+export interface UserSettingsMergeRepoValueResult {
+    /**
+     * The merged settings, with the per-entry managed control maps re-stamped from the runtime's ambient managed policy.
+     */
+    settingsJson: JsonValue;
+}
 /**
  * Settings object whose key names should be canonicalized.
  *
@@ -28655,6 +28995,19 @@ export interface UserSettingsNormalizeResult {
      */
     settings: JsonValue;
 }
+/**
+ * The on-disk location of the user's settings document.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UserSettingsPathResult".
+ */
+/** @experimental */
+export interface UserSettingsPathResult {
+    /**
+     * Absolute path to the settings file this runtime reads and writes. Normally `settings.json` under the Copilot configuration directory; an extensionless legacy `settings` file is reported instead when it exists and `settings.json` does not.
+     */
+    path: string;
+}
 /**
  * One setting that will not take effect, and why.
  *
@@ -30401,173 +30754,225 @@ export interface WorkspacesWriteAutopilotObjectiveResult {
     operation: string;
 }
 /**
- * The resident session the application has materialized on its own connection.
+ * The effective sandbox settings, with every unset value resolved to its default.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
- * via the `definition` "HostCreateSessionResult".
+ * via the `definition` "SandboxSettingsApplyDefaultsResult".
  */
 /** @experimental */
-export interface HostCreateSessionResult {
+export interface SandboxSettingsApplyDefaultsResult {
     /**
-     * Runtime session UUID materialized on the application's SDK connection.
+     * One resolved sandbox setting's value, carried verbatim.
      */
-    sessionId: string;
+    [k: string]: JsonValue | undefined;
 }
 /**
- * One application-owned session handoff, requested by the supervised hosting participant.
+ * The stored user settings document, keyed by setting name.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
- * via the `definition` "HostCreateSessionRequest".
+ * via the `definition` "UserSettingsLoadForConfigDirResult".
  */
 /** @experimental */
-export interface HostCreateSessionRequest {
-    /**
-     * Unique identity for this participation, independent of the session lifetime.
-     */
-    handoffId: string;
-    /**
-     * Resume an app-owned durable session instead of creating a new session.
-     */
-    resume?: boolean;
-    /**
-     * For an explicit publication, borrow an existing owning-connection resident
-     * instead of invoking the resume factory. Cold sessions still use the factory.
-     */
-    preferResident?: boolean;
+export interface UserSettingsLoadForConfigDirResult {
     /**
-     * Host-selected SDK creation or resume settings, without executable callbacks or tools.
+     * One setting's stored value, carried verbatim.
      */
-    config: {
-        [k: string]: unknown | undefined;
-    };
+    [k: string]: JsonValue | undefined;
 }
 /**
- * Empty acknowledgement for a completed host lifecycle operation.
+ * The effective runtime settings, keyed by setting name. Keys this runtime does not recognize are preserved rather than dropped, so a caller reading a document written by a newer runtime keeps every value.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
- * via the `definition` "HostReleaseSessionResult".
+ * via the `definition` "UserSettingsBuildRuntimeResult".
  */
 /** @experimental */
-export interface HostReleaseSessionResult {
+export interface UserSettingsBuildRuntimeResult {
+    /**
+     * One resolved setting's effective value, carried verbatim.
+     */
+    [k: string]: JsonValue | undefined;
 }
 /**
- * Ends one participation, not the application's session lifetime.
+ * The resolved gates, keyed by flag name.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
- * via the `definition` "HostReleaseSessionRequest".
+ * via the `definition` "FeatureFlagsResolveStartupGatesResult".
  */
 /** @experimental */
-export interface HostReleaseSessionRequest {
+export interface FeatureFlagsResolveStartupGatesResult {
     /**
-     * Identity of the participation to release without destroying the session.
+     * Whether the gate is on for this installation.
      */
-    handoffId: string;
+    [k: string]: boolean | undefined;
 }
 /**
- * Empty acknowledgement for a completed host lifecycle operation.
+ * The resolved feature flags, keyed by flag name.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
- * via the `definition` "HostDisposeResult".
+ * via the `definition` "FeatureFlagsResolveResult".
  */
 /** @experimental */
-export interface HostDisposeResult {
+export interface FeatureFlagsResolveResult {
+    /**
+     * Whether the flag is enabled for this population.
+     */
+    [k: string]: boolean | undefined;
 }
 /**
- * Private credentials delivered only to a runtime-owned Mission Control hosting participant.
+ * Ordered managed permission verdicts and the supplied policy's fail-closed posture.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
- * via the `definition` "HostGetEnvironmentCredentialsResult".
+ * via the `definition` "ManagedSettingsPermissionsEvaluateResult".
  */
 /** @experimental */
-export interface HostGetEnvironmentCredentialsResult {
+export interface ManagedSettingsPermissionsEvaluateResult {
     /**
-     * Current bearer token for the authenticated GitHub identity.
+     * One verdict per input operation, in the same order, including duplicates.
      */
-    token: string;
+    results: ManagedPermissionEvaluation[];
     /**
-     * Hostname of the authenticated GitHub service.
+     * Managed permission policy could not be determined; every operation is denied.
      */
-    githubHost: string;
+    failClosed: boolean;
+}
+/**
+ * Managed policy context and ordered operations for pure, sessionless evaluation.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsPermissionsEvaluateRequest".
+ */
+/** @experimental */
+export interface ManagedSettingsPermissionsEvaluateRequest {
+    context: ManagedPermissionsContext;
     /**
-     * GitHub API base URL for the authenticated service.
+     * Operations to evaluate, preserving input order and duplicates. An empty batch is valid.
      */
-    githubApiUrl: string;
+    operations: ManagedPermissionOperation[];
+}
+/**
+ * The resident session the application has materialized on its own connection.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "HostCreateSessionResult".
+ */
+/** @experimental */
+export interface HostCreateSessionResult {
     /**
-     * Mission Control API origin for environment registration and management.
+     * Runtime session UUID materialized on the application's SDK connection.
      */
-    missionControlUrl: string;
+    sessionId: string;
 }
 /**
- * Normalized listener settings delivered only to the supervised hosting participant.
+ * One application-owned session handoff, requested by the supervised hosting participant.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
- * via the `definition` "HostGetConfigurationResult".
+ * via the `definition` "HostCreateSessionRequest".
  */
 /** @experimental */
-export interface HostGetConfigurationResult {
-    localServer?: HostLocalServerConfiguration;
-    githubEnvironment?: HostGitHubEnvironmentOptions;
+export interface HostCreateSessionRequest {
     /**
-     * Whether session materialization is delegated to the owning application.
+     * Unique identity for this participation, independent of the session lifetime.
      */
-    sessionFactory: boolean;
+    handoffId: string;
     /**
-     * Whether app-owned durable sessions are resumed by the owning application.
+     * Resume an app-owned durable session instead of creating a new session.
      */
-    resumeFactory: boolean;
+    resume?: boolean;
+    /**
+     * For an explicit publication, borrow an existing owning-connection resident
+     * instead of invoking the resume factory. Cold sessions still use the factory.
+     */
+    preferResident?: boolean;
+    /**
+     * Host-selected SDK creation or resume settings, without executable callbacks or tools.
+     */
+    config: {
+        [k: string]: unknown | undefined;
+    };
 }
 /**
  * Empty acknowledgement for a completed host lifecycle operation.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
- * via the `definition` "HostReadyResult".
+ * via the `definition` "HostReleaseSessionResult".
  */
 /** @experimental */
-export interface HostReadyResult {
+export interface HostReleaseSessionResult {
 }
 /**
- * The resolved feature flags, keyed by flag name.
+ * Ends one participation, not the application's session lifetime.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
- * via the `definition` "FeatureFlagsResolveResult".
+ * via the `definition` "HostReleaseSessionRequest".
  */
 /** @experimental */
-export interface FeatureFlagsResolveResult {
+export interface HostReleaseSessionRequest {
     /**
-     * Whether the flag is enabled for this population.
+     * Identity of the participation to release without destroying the session.
      */
-    [k: string]: boolean | undefined;
+    handoffId: string;
 }
 /**
- * Ordered managed permission verdicts and the supplied policy's fail-closed posture.
+ * Empty acknowledgement for a completed host lifecycle operation.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
- * via the `definition` "ManagedSettingsPermissionsEvaluateResult".
+ * via the `definition` "HostDisposeResult".
  */
 /** @experimental */
-export interface ManagedSettingsPermissionsEvaluateResult {
+export interface HostDisposeResult {
+}
+/**
+ * Private credentials delivered only to a runtime-owned Mission Control hosting participant.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "HostGetEnvironmentCredentialsResult".
+ */
+/** @experimental */
+export interface HostGetEnvironmentCredentialsResult {
     /**
-     * One verdict per input operation, in the same order, including duplicates.
+     * Current bearer token for the authenticated GitHub identity.
      */
-    results: ManagedPermissionEvaluation[];
+    token: string;
     /**
-     * Managed permission policy could not be determined; every operation is denied.
+     * Hostname of the authenticated GitHub service.
      */
-    failClosed: boolean;
+    githubHost: string;
+    /**
+     * GitHub API base URL for the authenticated service.
+     */
+    githubApiUrl: string;
+    /**
+     * Mission Control API origin for environment registration and management.
+     */
+    missionControlUrl: string;
 }
 /**
- * Managed policy context and ordered operations for pure, sessionless evaluation.
+ * Normalized listener settings delivered only to the supervised hosting participant.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
- * via the `definition` "ManagedSettingsPermissionsEvaluateRequest".
+ * via the `definition` "HostGetConfigurationResult".
  */
 /** @experimental */
-export interface ManagedSettingsPermissionsEvaluateRequest {
-    context: ManagedPermissionsContext;
+export interface HostGetConfigurationResult {
+    localServer?: HostLocalServerConfiguration;
+    githubEnvironment?: HostGitHubEnvironmentOptions;
     /**
-     * Operations to evaluate, preserving input order and duplicates. An empty batch is valid.
+     * Whether session materialization is delegated to the owning application.
      */
-    operations: ManagedPermissionOperation[];
+    sessionFactory: boolean;
+    /**
+     * Whether app-owned durable sessions are resumed by the owning application.
+     */
+    resumeFactory: boolean;
+}
+/**
+ * Empty acknowledgement for a completed host lifecycle operation.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "HostReadyResult".
+ */
+/** @experimental */
+export interface HostReadyResult {
 }
 /** @experimental */
 export interface SessionWorkflowPauseAtCheckpointResult {
@@ -31083,6 +31488,142 @@ export interface InstallationsConfirmRequest {
 }
 /** Create typed server-scoped RPC methods (no session required). */
 export declare function createServerRpc(connection: MessageConnection): {
+    /** @experimental */
+    sandbox: {
+        /** @experimental */
+        proxyCa: {
+            /**
+             * Reports whether this runtime process can offer installing the sandbox credential-proxy certificate authority into OS trust.
+             *
+             * @returns True when this process can offer installing the sandbox credential-proxy certificate authority into OS trust.
+             */
+            checkInstallationSupport: () => Promise<SandboxProxyCaCheckInstallationSupportResult>;
+            /**
+             * Reports whether this sandbox configuration uses the credential proxy and can need certificate-authority setup.
+             *
+             * @param params Identifies the credential hosts that the persistent certificate authority of the sandbox credential proxy must cover. The runtime always adds the hosts from the saved user settings.
+             *
+             * @returns True when the sandbox configuration uses the credential proxy and can need certificate-authority setup.
+             */
+            checkRelevance: (params: SandboxProxyCaRequest) => Promise<SandboxProxyCaCheckRelevanceResult>;
+            /**
+             * Reports whether the persistent certificate authority of the sandbox credential proxy exists, whether OS trust includes it, and whether it must be rotated. Changes nothing.
+             *
+             * @param params Identifies the credential hosts that the persistent certificate authority of the sandbox credential proxy must cover. The runtime always adds the hosts from the saved user settings.
+             *
+             * @returns Status of the persistent certificate authority of the sandbox credential proxy.
+             */
+            getStatus: (params: SandboxProxyCaRequest) => Promise<SandboxProxyCaStatus>;
+            /**
+             * Creates the persistent certificate authority of the sandbox credential proxy if none is stored, without changing OS trust, and returns the path of its public certificate. Keeps an existing certificate authority, even one that must be rotated. Fails where OS trust is unsupported. Trust it with sandbox.proxyCa.trust: the CLI trusts only the hosts in the saved user settings, so it refuses a certificate authority that also covers hosts from sandboxConfig.
+             *
+             * @param params Identifies the credential hosts that the persistent certificate authority of the sandbox credential proxy must cover. The runtime always adds the hosts from the saved user settings.
+             *
+             * @returns Result of creating the persistent certificate authority of the sandbox credential proxy.
+             */
+            create: (params: SandboxProxyCaRequest) => Promise<SandboxProxyCaCreateResult>;
+            /**
+             * Replaces the persistent certificate authority of the sandbox credential proxy with a new one for the current credential hosts. If OS trust included the old one, removes it and trusts the new one, which can show an OS authentication prompt. Running sandboxed tools keep the old certificate authority until they restart.
+             *
+             * @param params Identifies the credential hosts that the persistent certificate authority of the sandbox credential proxy must cover. The runtime always adds the hosts from the saved user settings.
+             *
+             * @returns Status of the persistent certificate authority of the sandbox credential proxy.
+             */
+            rotate: (params: SandboxProxyCaRequest) => Promise<SandboxProxyCaStatus>;
+            /**
+             * Adds the persistent certificate authority of the sandbox credential proxy to OS trust, so sandboxed clients that read only OS trust accept the proxy. Call create first. Refuses a certificate authority that is not constrained to the current credential hosts. Can show an OS authentication prompt.
+             *
+             * @param params Identifies the credential hosts that the persistent certificate authority of the sandbox credential proxy must cover. The runtime always adds the hosts from the saved user settings.
+             *
+             * @returns Status of the persistent certificate authority of the sandbox credential proxy.
+             */
+            trust: (params: SandboxProxyCaRequest) => Promise<SandboxProxyCaStatus>;
+            /**
+             * Removes the persistent certificate authority of the sandbox credential proxy from OS trust. Keeps the stored certificate authority. Can show an OS authentication prompt. Sandboxed clients that read only OS trust then reject the proxy; clients that read the per-process certificate bundle continue to work.
+             *
+             * @returns Status of the persistent certificate authority of the sandbox credential proxy.
+             */
+            remove: () => Promise<SandboxProxyCaStatus>;
+        };
+        /**
+         * Reports whether the host running this runtime can run the command sandbox, without starting a session or spawning a sandboxed command.
+         *
+         * @returns Whether the host running this runtime can run the command sandbox. The runtime checks `supported` once per process. A capability answer can change while the process runs, for example after the user installs a missing package.
+         */
+        getHostSupport: () => Promise<SandboxHostSupport>;
+    };
+    /** @experimental */
+    user: {
+        /** @experimental */
+        settings: {
+            /**
+             * Lists every known user setting from settings.json, each with its effective value, its default, and whether it is at the default — so settings the user has never set still appear with their default value. Does not include repository- or enterprise-managed overrides that the runtime layers on top at session time.
+             *
+             * @returns Per-key metadata for every known user setting in settings.json, including settings left at their default. Excludes repository- and enterprise-managed overrides.
+             */
+            get: () => Promise<UserSettingsGetResult>;
+            /**
+             * Writes one or more user settings to settings.json, replacing each provided top-level key. A key whose value is null is removed.
+             *
+             * @param params Partial user settings to write to settings.json. Each top-level key is written individually, replacing the existing value; a key whose value is null is removed.
+             */
+            set: (params: UserSettingsSetRequest) => Promise<void>;
+        };
+    };
+    /** @experimental */
+    managedSettings: {
+        /**
+         * Discovers device-managed settings from production MDM and managed-file sources, validates them against the runtime-owned managed-settings schema, and returns the canonical JSON without requiring a session. `managedSettings.resolve` returns the same device settings together with the account's server policy.
+         *
+         * @returns Validated device-managed settings discovered before a session exists.
+         */
+        read: () => Promise<ManagedSettingsReadResult>;
+        /**
+         * Force-refreshes enterprise managed settings for every account: wipes the persistent server-policy cache (the whole `<cacheHome>/managed-settings` directory) and drops this runtime process's in-memory retained server policy. It does not itself fetch policy — the effect is that the next time a session resolves managed settings for an account, that resolution re-fetches the account's org policy from the network instead of serving a cached response. Note that `managedSettings.read` returns only device/MDM settings and never triggers the account server-policy fetch, so a host implementing "sync account policy" should call `managedSettings.resolve` or start a fresh session resolution rather than treat a subsequent `managedSettings.read` as the refreshed org policy. Mirrors the invalidation a sign-out performs, broadened from the one signing-out account to all of them; device/MDM layers describe the machine, not the account, and are left untouched. Rejects if the on-disk cache cannot be removed.
+         */
+        clearCache: () => Promise<void>;
+        /**
+         * Resolves the effective enterprise managed settings without a session, from the device channel and, when an account is available, the account's server policy through the same per-account cache sessions use. A cached server policy less than an hour old is used without a fetch; otherwise the policy is fetched, and when the fetch fails a cached policy up to 24 hours old is used instead, unless `forceRemoteSettingsRefresh` requires a live fetch. With no account requested or signed in, it reports device policy only; signing out removes the account's cached policy. It can fetch server policy over the network when the cache is stale, so call it off latency-critical paths such as startup rather than before listing models. The policy helper is not run. `layers` lists each channel's document before merging, and `values` and `meta` carry typed effective values and their lock state for the keys typed so far.
+         *
+         * @param params Optional opaque account selection or GitHub token whose managed settings are resolved.
+         *
+         * @returns Effective enterprise managed settings for an account, resolved without a session.
+         */
+        resolve: (params: ManagedSettingsResolveRequest) => Promise<ManagedSettingsResolveResult>;
+        /** @experimental */
+        permissions: {
+            /**
+             * Pure, sessionless evaluation of operations against a supplied permissionsContext. Performs no policy discovery, I/O, prompting, navigation, permission grants, or sandbox changes. Obtain the context from managedSettings.resolve or session.managedSettings.get, or reuse an in-memory context. Results preserve input order and duplicates. Consumers must block deny, obtain approval for ask, and use their normal permission flow for unmanaged. Unknown policy returns failClosed with every operation denied. This is not a substitute for user permissions or other security controls.
+             *
+             * @param params Managed policy context and ordered operations for pure, sessionless evaluation.
+             *
+             * @returns Ordered managed permission verdicts and the supplied policy's fail-closed posture.
+             */
+            evaluate: (params: ManagedSettingsPermissionsEvaluateRequest) => Promise<ManagedSettingsPermissionsEvaluateResult>;
+        };
+        /**
+         * Returns the managed-settings authoring JSON schema with descriptive `x-composition` annotations aligned with the shared settings-engine vocabulary. These annotations are not a complete runtime composition contract: model, effortLevel, and contextTier remain coupled. Use `managedSettings.compose` for the runtime's effective result. Performs no I/O.
+         *
+         * @returns The authoring JSON schema for managed settings recognized by this runtime.
+         */
+        schema: () => Promise<ManagedSettingsSchemaResult>;
+        /**
+         * Validates a candidate managed-settings document the way the runtime validates delivered policy, without applying it. Reports errors that would reject the document, warnings for content the runtime ignores, and the canonical document it would apply. Document text nested more than 64 levels deep is rejected. Performs no I/O.
+         *
+         * @param params A candidate managed-settings document to validate without applying it.
+         *
+         * @returns Result of validating a managed-settings document.
+         */
+        validate: (params: ManagedSettingsValidateRequest) => Promise<ManagedSettingsValidateResult>;
+        /**
+         * Merges candidate managed-settings documents for the device, server, and policy-helper channels into the effective settings the runtime would enforce on this host, using the same precedence and composition rules as live resolution, without applying them. Like live resolution, a server's advisory sandbox force-enable is declined on a host that cannot run the sandbox. Does not fetch policy or read policy files, but may perform blocking OS or subprocess probes for sandbox support. Preview documents are limited to 1 MiB and 64 levels of nesting.
+         *
+         * @param params Candidate managed-settings documents to merge without applying them.
+         *
+         * @returns The effective managed settings the runtime would enforce for the given documents, in the same shape `managedSettings.resolve` returns.
+         */
+        compose: (params: ManagedSettingsComposeRequest) => Promise<ManagedSettingsComposeResult>;
+    };
     /** @experimental */
     environments: {
         /**
@@ -31184,56 +31725,6 @@ export declare function createServerRpc(connection: MessageConnection): {
         getBuiltInCatalog: () => Promise<BuiltInModelCatalog>;
     };
     /** @experimental */
-    sandbox: {
-        /**
-         * Reports whether the host running this runtime can run the command sandbox, without starting a session or spawning a sandboxed command.
-         *
-         * @returns Whether the host running this runtime can run the command sandbox. The runtime checks `supported` once per process. A capability answer can change while the process runs, for example after the user installs a missing package.
-         */
-        getHostSupport: () => Promise<SandboxHostSupport>;
-        /** @experimental */
-        proxyCa: {
-            /**
-             * Reports whether the persistent certificate authority of the sandbox credential proxy exists, whether OS trust includes it, and whether it must be rotated. Changes nothing.
-             *
-             * @param params Identifies the credential hosts that the persistent certificate authority of the sandbox credential proxy must cover. The runtime always adds the hosts from the saved user settings.
-             *
-             * @returns Status of the persistent certificate authority of the sandbox credential proxy.
-             */
-            getStatus: (params: SandboxProxyCaRequest) => Promise<SandboxProxyCaStatus>;
-            /**
-             * Creates the persistent certificate authority of the sandbox credential proxy if none is stored, without changing OS trust, and returns the path of its public certificate. Keeps an existing certificate authority, even one that must be rotated. Fails where OS trust is unsupported. Trust it with sandbox.proxyCa.trust: the CLI trusts only the hosts in the saved user settings, so it refuses a certificate authority that also covers hosts from sandboxConfig.
-             *
-             * @param params Identifies the credential hosts that the persistent certificate authority of the sandbox credential proxy must cover. The runtime always adds the hosts from the saved user settings.
-             *
-             * @returns Result of creating the persistent certificate authority of the sandbox credential proxy.
-             */
-            create: (params: SandboxProxyCaRequest) => Promise<SandboxProxyCaCreateResult>;
-            /**
-             * Replaces the persistent certificate authority of the sandbox credential proxy with a new one for the current credential hosts. If OS trust included the old one, removes it and trusts the new one, which can show an OS authentication prompt. Running sandboxed tools keep the old certificate authority until they restart.
-             *
-             * @param params Identifies the credential hosts that the persistent certificate authority of the sandbox credential proxy must cover. The runtime always adds the hosts from the saved user settings.
-             *
-             * @returns Status of the persistent certificate authority of the sandbox credential proxy.
-             */
-            rotate: (params: SandboxProxyCaRequest) => Promise<SandboxProxyCaStatus>;
-            /**
-             * Adds the persistent certificate authority of the sandbox credential proxy to OS trust, so sandboxed clients that read only OS trust accept the proxy. Call create first. Refuses a certificate authority that is not constrained to the current credential hosts. Can show an OS authentication prompt.
-             *
-             * @param params Identifies the credential hosts that the persistent certificate authority of the sandbox credential proxy must cover. The runtime always adds the hosts from the saved user settings.
-             *
-             * @returns Status of the persistent certificate authority of the sandbox credential proxy.
-             */
-            trust: (params: SandboxProxyCaRequest) => Promise<SandboxProxyCaStatus>;
-            /**
-             * Removes the persistent certificate authority of the sandbox credential proxy from OS trust. Keeps the stored certificate authority. Can show an OS authentication prompt. Sandboxed clients that read only OS trust then reject the proxy; clients that read the per-process certificate bundle continue to work.
-             *
-             * @returns Status of the persistent certificate authority of the sandbox credential proxy.
-             */
-            remove: () => Promise<SandboxProxyCaStatus>;
-        };
-    };
-    /** @experimental */
     tools: {
         /**
          * Lists built-in tools available for a model.
@@ -31725,78 +32216,6 @@ export declare function createServerRpc(connection: MessageConnection): {
         list: () => Promise<CommandList>;
     };
     /** @experimental */
-    user: {
-        /** @experimental */
-        settings: {
-            /**
-             * Lists every known user setting from settings.json, each with its effective value, its default, and whether it is at the default — so settings the user has never set still appear with their default value. Does not include repository- or enterprise-managed overrides that the runtime layers on top at session time.
-             *
-             * @returns Per-key metadata for every known user setting in settings.json, including settings left at their default. Excludes repository- and enterprise-managed overrides.
-             */
-            get: () => Promise<UserSettingsGetResult>;
-            /**
-             * Writes one or more user settings to settings.json, replacing each provided top-level key. A key whose value is null is removed.
-             *
-             * @param params Partial user settings to write to settings.json. Each top-level key is written individually, replacing the existing value; a key whose value is null is removed.
-             */
-            set: (params: UserSettingsSetRequest) => Promise<void>;
-        };
-    };
-    /** @experimental */
-    managedSettings: {
-        /**
-         * Discovers device-managed settings from production MDM and managed-file sources, validates them against the runtime-owned managed-settings schema, and returns the canonical JSON without requiring a session. `managedSettings.resolve` returns the same device settings together with the account's server policy.
-         *
-         * @returns Validated device-managed settings discovered before a session exists.
-         */
-        read: () => Promise<ManagedSettingsReadResult>;
-        /**
-         * Force-refreshes enterprise managed settings for every account: wipes the persistent server-policy cache (the whole `<cacheHome>/managed-settings` directory) and drops this runtime process's in-memory retained server policy. It does not itself fetch policy — the effect is that the next time a session resolves managed settings for an account, that resolution re-fetches the account's org policy from the network instead of serving a cached response. Note that `managedSettings.read` returns only device/MDM settings and never triggers the account server-policy fetch, so a host implementing "sync account policy" should call `managedSettings.resolve` or start a fresh session resolution rather than treat a subsequent `managedSettings.read` as the refreshed org policy. Mirrors the invalidation a sign-out performs, broadened from the one signing-out account to all of them; device/MDM layers describe the machine, not the account, and are left untouched. Rejects if the on-disk cache cannot be removed.
-         */
-        clearCache: () => Promise<void>;
-        /**
-         * Resolves the effective enterprise managed settings without a session, from the device channel and, when an account is available, the account's server policy through the same per-account cache sessions use. A cached server policy less than an hour old is used without a fetch; otherwise the policy is fetched, and when the fetch fails a cached policy up to 24 hours old is used instead, unless `forceRemoteSettingsRefresh` requires a live fetch. With no account requested or signed in, it reports device policy only; signing out removes the account's cached policy. It can fetch server policy over the network when the cache is stale, so call it off latency-critical paths such as startup rather than before listing models. The policy helper is not run. `layers` lists each channel's document before merging, and `values` and `meta` carry typed effective values and their lock state for the keys typed so far.
-         *
-         * @param params Optional opaque account selection or GitHub token whose managed settings are resolved.
-         *
-         * @returns Effective enterprise managed settings for an account, resolved without a session.
-         */
-        resolve: (params: ManagedSettingsResolveRequest) => Promise<ManagedSettingsResolveResult>;
-        /** @experimental */
-        permissions: {
-            /**
-             * Pure, sessionless evaluation of operations against a supplied permissionsContext. Performs no policy discovery, I/O, prompting, navigation, permission grants, or sandbox changes. Obtain the context from managedSettings.resolve or session.managedSettings.get, or reuse an in-memory context. Results preserve input order and duplicates. Consumers must block deny, obtain approval for ask, and use their normal permission flow for unmanaged. Unknown policy returns failClosed with every operation denied. This is not a substitute for user permissions or other security controls.
-             *
-             * @param params Managed policy context and ordered operations for pure, sessionless evaluation.
-             *
-             * @returns Ordered managed permission verdicts and the supplied policy's fail-closed posture.
-             */
-            evaluate: (params: ManagedSettingsPermissionsEvaluateRequest) => Promise<ManagedSettingsPermissionsEvaluateResult>;
-        };
-        /**
-         * Returns the managed-settings authoring JSON schema with descriptive `x-composition` annotations aligned with the shared settings-engine vocabulary. These annotations are not a complete runtime composition contract: model, effortLevel, and contextTier remain coupled. Use `managedSettings.compose` for the runtime's effective result. Performs no I/O.
-         *
-         * @returns The authoring JSON schema for managed settings recognized by this runtime.
-         */
-        schema: () => Promise<ManagedSettingsSchemaResult>;
-        /**
-         * Validates a candidate managed-settings document the way the runtime validates delivered policy, without applying it. Reports errors that would reject the document, warnings for content the runtime ignores, and the canonical document it would apply. Document text nested more than 64 levels deep is rejected. Performs no I/O.
-         *
-         * @param params A candidate managed-settings document to validate without applying it.
-         *
-         * @returns Result of validating a managed-settings document.
-         */
-        validate: (params: ManagedSettingsValidateRequest) => Promise<ManagedSettingsValidateResult>;
-        /**
-         * Merges candidate managed-settings documents for the device, server, and policy-helper channels into the effective settings the runtime would enforce on this host, using the same precedence and composition rules as live resolution, without applying them. Like live resolution, a server's advisory sandbox force-enable is declined on a host that cannot run the sandbox. Does not fetch policy or read policy files, but may perform blocking OS or subprocess probes for sandbox support. Preview documents are limited to 1 MiB and 64 levels of nesting.
-         *
-         * @param params Candidate managed-settings documents to merge without applying them.
-         *
-         * @returns The effective managed settings the runtime would enforce for the given documents, in the same shape `managedSettings.resolve` returns.
-         */
-        compose: (params: ManagedSettingsComposeRequest) => Promise<ManagedSettingsComposeResult>;
-    };
-    /** @experimental */
     runtime: {
         /**
          * Gracefully shuts down an SDK-owned runtime. The response is sent only after cleanup completes; callers may then terminate the owned runtime process.