@skrr-ai/cli 0.1.123 → 0.1.125

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/index.js

@@ -19,7 +19,9 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 __export(index_exports, {
+  ALLOW_LIVE_STATE_ENV: () => import_liveState.ALLOW_LIVE_STATE_ENV,
   ALL_DAEMON_SCOPES: () => import_daemonScopes.ALL_DAEMON_SCOPES,
+  AUTH_SERVER_METADATA_PATH: () => import_deviceKeyServerSupport.AUTH_SERVER_METADATA_PATH,
   AuthHelperUnavailableError: () => import_credentialResolver.AuthHelperUnavailableError,
   AuthHelperUntrustedError: () => import_credentialResolver.AuthHelperUntrustedError,
   CI_TOKEN_PREFIX: () => import_credentialResolver.CI_TOKEN_PREFIX,
@@ -28,12 +30,16 @@ __export(index_exports, {
   CRED_ENVELOPE_MAGIC: () => import_credentialEnvelope.ENVELOPE_MAGIC,
   CRED_KEY_LEN: () => import_credentialEnvelope.KEY_LEN,
   CredentialResolver: () => import_credentialResolver.CredentialResolver,
+  DAEMON_BYOK_KEYCHAIN_SERVICE_BASE: () => import_liveState.DAEMON_BYOK_KEYCHAIN_SERVICE_BASE,
   DAEMON_CHILD_ENV: () => import_spawnEnv.DAEMON_CHILD_ENV,
+  DAEMON_KEYCHAIN_SERVICE_BASE: () => import_liveState.DAEMON_KEYCHAIN_SERVICE_BASE,
   DEFAULT_BINARY_NAME: () => import_localIdentity.DEFAULT_BINARY_NAME,
   DEFAULT_DAEMON_SCOPES: () => import_daemonScopes.DEFAULT_DAEMON_SCOPES,
   DEFAULT_FIRST_PARTY_HARNESS_CHANNEL: () => import_firstPartyHarnessChannels.DEFAULT_FIRST_PARTY_HARNESS_CHANNEL,
   DEFAULT_LOGIN_TIMEOUT_MS: () => import_loginLocalhost.DEFAULT_LOGIN_TIMEOUT_MS,
   DEFAULT_UNREADABLE_CREDENTIAL_HINT: () => import_credentialEnvelopeBridge.DEFAULT_UNREADABLE_CREDENTIAL_HINT,
+  DEVICE_KEY_ALGS: () => import_deviceKey.DEVICE_KEY_ALGS,
+  DEVICE_KEY_UNREADABLE_CREDENTIAL_HINT: () => import_deviceIdentityBridge.DEVICE_KEY_UNREADABLE_CREDENTIAL_HINT,
   DPOP_HEADER: () => import_dpop.DPOP_HEADER,
   DPOP_MAX_AGE_SECONDS: () => import_dpop.DPOP_MAX_AGE_SECONDS,
   DPOP_PROOF_INVALID: () => import_dpop.DPOP_PROOF_INVALID,
@@ -44,18 +50,25 @@ __export(index_exports, {
   FIRST_PARTY_HARNESS_CHANNELS: () => import_firstPartyHarnessChannels.FIRST_PARTY_HARNESS_CHANNELS,
   FIRST_PARTY_HARNESS_PREVIOUS_SUFFIX: () => import_firstPartyHarnessHome.FIRST_PARTY_HARNESS_PREVIOUS_SUFFIX,
   FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX: () => import_firstPartyHarnessHome.FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX,
+  HARDWARE_KEY_HELPER_NAME: () => import_deviceKeyHardware.HARDWARE_KEY_HELPER_NAME,
   HARNESSES_LOADING_CLAUDE_SKILLS_LAYOUT: () => import_harnessSkillLayout.HARNESSES_LOADING_CLAUDE_SKILLS_LAYOUT,
   HARNESS_TIERS: () => import_harnessTrust.HARNESS_TIERS,
+  HERMETIC_HOME_ENV: () => import_liveState.HERMETIC_HOME_ENV,
   HOSTED_RUNTIME_MACHINE_SOURCES: () => import_machineUuid.HOSTED_RUNTIME_MACHINE_SOURCES,
+  HardwareDeviceKeyError: () => import_deviceKeyHardware.HardwareDeviceKeyError,
   INDEPENDENT_MACHINE_PROFILE_RE: () => import_independentMachineReservation.INDEPENDENT_MACHINE_PROFILE_RE,
   INDEPENDENT_MACHINE_RESERVATION_FILE: () => import_independentMachineReservation.INDEPENDENT_MACHINE_RESERVATION_FILE,
   InMemoryKek: () => import_kek.InMemoryKek,
   KekUnavailableError: () => import_kek.KekUnavailableError,
   LEGACY_CONFIG_DIR_NAMES: () => import_localIdentity.LEGACY_CONFIG_DIR_NAMES,
+  LEGACY_DAEMON_KEYCHAIN_SERVICE: () => import_liveState.LEGACY_DAEMON_KEYCHAIN_SERVICE,
   LEGACY_NATIVE_ID_PREFIXES: () => import_localIdentity.LEGACY_NATIVE_ID_PREFIXES,
+  LIVE_DEFAULT_PROFILE: () => import_liveState.LIVE_DEFAULT_PROFILE,
+  LIVE_STATE_REFUSED_CODE: () => import_liveState.LIVE_STATE_REFUSED_CODE,
   LOOPBACK_DEFAULT_MAX_BODY_BYTES: () => import_loopbackHttp.LOOPBACK_DEFAULT_MAX_BODY_BYTES,
   LOOPBACK_NO_PROXY_HOSTS: () => import_spawnEnv.LOOPBACK_NO_PROXY_HOSTS,
   LinuxKek: () => import_kek.LinuxKek,
+  LiveStateRefusedError: () => import_liveState.LiveStateRefusedError,
   LocalCallbackBindError: () => import_loginLocalhost.LocalCallbackBindError,
   LocalCallbackDeniedError: () => import_loginLocalhost.LocalCallbackDeniedError,
   LocalCallbackError: () => import_loginLocalhost.LocalCallbackError,
@@ -81,6 +94,7 @@ __export(index_exports, {
   PAIR_NONCE_LEN: () => import_daemonPair.PAIR_NONCE_LEN,
   PAIR_PUBKEY_LEN: () => import_daemonPair.PAIR_PUBKEY_LEN,
   PAIR_SECRET_LEN: () => import_daemonPair.PAIR_SECRET_LEN,
+  PENDING_HARDWARE_KEY_MAX_AGE_MS: () => import_deviceIdentityBridge.PENDING_HARDWARE_KEY_MAX_AGE_MS,
   PERSONAL_ACCESS_TOKEN_PREFIX: () => import_credentialResolver.PERSONAL_ACCESS_TOKEN_PREFIX,
   PROFILES_SEGMENT: () => import_profileStateDir.PROFILES_SEGMENT,
   PairBundleError: () => import_daemonPair.PairBundleError,
@@ -92,6 +106,7 @@ __export(index_exports, {
   SENSITIVE_ENV_SUFFIXES: () => import_spawnEnv.SENSITIVE_ENV_SUFFIXES,
   SENSITIVE_ENV_VARS: () => import_spawnEnv.SENSITIVE_ENV_VARS,
   SENTINEL_TRIGGERING_FAILURES: () => import_authHelper.SENTINEL_TRIGGERING_FAILURES,
+  SERVER_DEVICE_KEY_ALGS_FIELD: () => import_deviceKeyServerSupport.SERVER_DEVICE_KEY_ALGS_FIELD,
   SUPERSEDED_COPY_SUFFIX: () => import_profileStateDir.SUPERSEDED_COPY_SUFFIX,
   SUPERSEDED_MARKER_SUFFIX: () => import_profileStateDir.SUPERSEDED_MARKER_SUFFIX,
   TRUSTED_FEED_ORIGINS: () => import_releaseManifest.TRUSTED_FEED_ORIGINS,
@@ -113,6 +128,7 @@ __export(index_exports, {
   __resetMachineUuidCacheForTest: () => import_machineUuid.__resetMachineUuidCacheForTest,
   __resetShutdownGuardForTest: () => import_credentialEnvelopeBridge.__resetShutdownGuardForTest,
   __resetUnknown401StreaksForTest: () => import_refresh.__resetUnknown401StreaksForTest,
+  __setAccountHomeForTest: () => import_liveState.__setAccountHomeForTest,
   __setCredEnvelopeStateForTest: () => import_credentialEnvelopeBridge.__setStateForTest,
   __setDeviceIdentityStateForTest: () => import_deviceIdentityBridge.__setStateForTest,
   __setFdReaderForTest: () => import_fdToken.__setFdReaderForTest,
@@ -120,8 +136,12 @@ __export(index_exports, {
   __setUnreadableReloadIntervalForTest: () => import_deviceIdentityBridge.__setUnreadableReloadIntervalForTest,
   __wrappedDekFilePathForTest: () => import_credentialEnvelopeBridge.__wrappedDekFilePathForTest,
   accessTokenHash: () => import_dpop.accessTokenHash,
+  accountHomeDir: () => import_liveState.accountHomeDir,
+  algForJwk: () => import_deviceKey.algForJwk,
   assemblePairBundleBase64: () => import_daemonPair.assemblePairBundleBase64,
   assertLoopbackHttpUrl: () => import_loopbackHttp.assertLoopbackHttpUrl,
+  assertMayMutateLiveKeychain: () => import_liveState.assertMayMutateLiveKeychain,
+  assertMayMutateLiveState: () => import_liveState.assertMayMutateLiveState,
   buildArtifactMessage: () => import_releaseManifest.buildArtifactMessage,
   buildCredentialAad: () => import_credentialEnvelope.buildCredentialAad,
   buildDeviceProof: () => import_deviceKey.buildProof,
@@ -129,14 +149,18 @@ __export(index_exports, {
   buildPairAad: () => import_daemonPair.buildPairAad,
   buildPairUrl: () => import_daemonPair.buildPairUrl,
   challenge: () => import_pkce.challenge,
+  classifyDaemonKeychainService: () => import_kek.classifyDaemonKeychainService,
   classifyRefreshResponse: () => import_refreshClassification.classifyRefreshResponse,
   classifyTokenKind: () => import_credentialResolver.classifyTokenKind,
   claudeSkillsLayoutEvidence: () => import_harnessSkillLayout.claudeSkillsLayoutEvidence,
   clearEnrollmentMarker: () => import_deviceIdentityBridge.clearEnrollmentMarker,
   clearReauthState: () => import_refresh.clearReauthState,
+  commitDeviceKeyCandidate: () => import_deviceIdentityBridge.commitDeviceKeyCandidate,
+  commitPendingHardwareKey: () => import_deviceIdentityBridge.commitPendingHardwareKey,
   compareReleaseVersions: () => import_releaseVersions.compareReleaseVersions,
   configRootPath: () => import_configRoot.configRootPath,
   configureAuthCore: () => import_runtime.configureAuthCore,
+  configureHardwareDeviceKeyHelper: () => import_deviceKeyHardware.configureHardwareDeviceKeyHelper,
   consolidateProfileState: () => import_profileStateDir.consolidateProfileState,
   createDpopKey: () => import_dpop.createDpopKey,
   createRefreshScheduler: () => import_refreshScheduler.createRefreshScheduler,
@@ -156,6 +180,8 @@ __export(index_exports, {
   describeDeviceKeySplit: () => import_deviceIdentityBridge.describeDeviceKeySplit,
   describeLegacyState: () => import_legacyStatePreflight.describeLegacyState,
   describeMachineIdentity: () => import_machineUuid.describeMachineIdentity,
+  describeStoredDeviceKey: () => import_deviceIdentityBridge.describeStoredDeviceKey,
+  discardPendingHardwareKey: () => import_deviceIdentityBridge.discardPendingHardwareKey,
   emitAuthTelemetry: () => import_runtime.emitAuthTelemetry,
   enrollWithServer: () => import_deviceIdentityBridge.enrollWithServer,
   ensureMachineDaemonId: () => import_machineId.ensureMachineDaemonId,
@@ -208,18 +234,27 @@ __export(index_exports, {
   isDaemonChildEnv: () => import_spawnEnv.isDaemonChildEnv,
   isDaemonScope: () => import_daemonScopes.isDaemonScope,
   isDeviceIdentityActive: () => import_deviceIdentityBridge.isDeviceIdentityActive,
+  isDevicePublicJwk: () => import_deviceKey.isDevicePublicJwk,
   isFirstPartyHarnessChannel: () => import_firstPartyHarnessChannels.isFirstPartyHarnessChannel,
   isJwkThumbprint: () => import_dpop.isJwkThumbprint,
+  isLiveKeychainService: () => import_liveState.isLiveKeychainService,
+  isLiveStateRefusal: () => import_liveState.isLiveStateRefusal,
   isLoopbackAddress: () => import_loopbackHttp.isLoopbackAddress,
   isLoopbackHostname: () => import_loopbackHttp.isLoopbackHostname,
   isMasterKekKeychainService: () => import_kek.isMasterKekKeychainService,
+  isSessionKeychainService: () => import_kek.isSessionKeychainService,
   isStaticTokenKind: () => import_credentialResolver.isStaticTokenKind,
+  isTestProcess: () => import_liveState.isTestProcess,
   isTrustedArtifactOrigin: () => import_releaseManifest.isTrustedArtifactOrigin,
+  isUserOwnedSecretKeychainService: () => import_kek.isUserOwnedSecretKeychainService,
   isValidRecoveryCode: () => import_recoveryCode.isValidRecoveryCode,
   jwkThumbprint: () => import_deviceKey.jwkThumbprint,
+  keychainSuffixForDir: () => import_liveState.keychainSuffixForDir,
   legacyDaemonUuids: () => import_machineId.legacyDaemonUuids,
   legacyProfileStateDir: () => import_profileStateDir.legacyProfileStateDir,
   linkFirstPartyHarnessAliases: () => import_firstPartyHarnessHome.linkFirstPartyHarnessAliases,
+  liveKeychainServices: () => import_liveState.liveKeychainServices,
+  liveStateRoot: () => import_liveState.liveStateRoot,
   loginWithLocalhost: () => import_loginWithLocalhost.loginWithLocalhost,
   loopbackFetch: () => import_loopbackHttp.loopbackFetch,
   maybeDecryptOnRead: () => import_credentialEnvelopeBridge.maybeDecryptOnRead,
@@ -230,6 +265,7 @@ __export(index_exports, {
   normalizeHtu: () => import_deviceKey.normalizeHtu,
   normalizeRecoveryCode: () => import_recoveryCode.normalizeRecoveryCode,
   openPairBundleBase64: () => import_daemonPair.openPairBundleBase64,
+  p256PublicJwkFromRaw: () => import_deviceKey.p256PublicJwkFromRaw,
   pairBase64ToUint8Array: () => import_daemonPair.base64ToUint8Array,
   pairBase64UrlToUint8Array: () => import_daemonPair.base64UrlToUint8Array,
   pairUint8ArrayToBase64: () => import_daemonPair.uint8ArrayToBase64,
@@ -239,16 +275,23 @@ __export(index_exports, {
   parsePairUrl: () => import_daemonPair.parsePairUrl,
   parseRecoveryCode: () => import_recoveryCode.parseRecoveryCode,
   parseTtlDays: () => import_ttlParser.parseTtlDays,
+  persistPendingHardwareKey: () => import_deviceIdentityBridge.persistPendingHardwareKey,
   persistReauthState: () => import_refresh.persistReauthState,
+  prepareHardwareKeyCandidate: () => import_deviceIdentityBridge.prepareHardwareKeyCandidate,
+  probeHardwareDeviceKey: () => import_deviceKeyHardware.probeHardwareDeviceKey,
   profileStateDir: () => import_profileStateDir.profileStateDir,
   profileStateFileLocations: () => import_profileStateDir.profileStateFileLocations,
   profileStateFilePathsToClear: () => import_profileStateDir.profileStateFilePathsToClear,
+  proofSigningInput: () => import_deviceKey.proofSigningInput,
   publicJwkFromX: () => import_deviceKey.publicJwkFromX,
   qualifyMachineUuid: () => import_machineUuid.qualifyMachineUuid,
   readAuthFromFd: () => import_fdToken.readAuthFromFd,
   readIndependentMachineReservation: () => import_independentMachineReservation.readIndependentMachineReservation,
+  readServerDeviceKeyAlgs: () => import_deviceKeyServerSupport.readServerDeviceKeyAlgs,
   reauthCommand: () => import_messages.reauthCommand,
   refreshDaemonToken: () => import_refresh.refreshDaemonToken,
+  refusesLiveKeychainMutation: () => import_liveState.refusesLiveKeychainMutation,
+  refusesLiveStateInTest: () => import_liveState.refusesLiveStateInTest,
   registerZeroizeHook: () => import_kek.registerZeroizeHook,
   reserveIndependentMachineProfile: () => import_independentMachineReservation.reserveIndependentMachineProfile,
   resetCredEnvelope: () => import_credentialEnvelopeBridge.resetCredEnvelope,
@@ -256,17 +299,23 @@ __export(index_exports, {
   resolveChannelManifestUrl: () => import_firstPartyHarnessChannels.resolveChannelManifestUrl,
   resolveConfigRoot: () => import_configRoot.resolveConfigRoot,
   resolveFirstPartyHarnessChannel: () => import_firstPartyHarnessChannels.resolveFirstPartyHarnessChannel,
+  resolveHardwareDeviceKeyHelper: () => import_deviceKeyHardware.resolveHardwareDeviceKeyHelper,
   resolveProfileStateDir: () => import_profileStateDir.resolveProfileStateDir,
   resolveProfileStateFile: () => import_profileStateDir.resolveProfileStateFile,
+  rethrowIfLiveStateRefusal: () => import_liveState.rethrowIfLiveStateRefusal,
   revokeDaemonRefreshSession: () => import_refresh.revokeDaemonRefreshSession,
   runHeadersHelper: () => import_headers_helper.runHeadersHelper,
   safeEqual: () => import_pkce.safeEqual,
   sanitizeSpawnEnv: () => import_spawnEnv.sanitizeSpawnEnv,
   setMachineUuidProfile: () => import_machineUuid.setMachineUuidProfile,
   shutdownCredEnvelope: () => import_credentialEnvelopeBridge.shutdownCredEnvelope,
+  signProofWith: () => import_deviceKey.signProofWith,
   signServerRequest: () => import_deviceIdentityBridge.signServerRequest,
+  signWithCandidate: () => import_deviceIdentityBridge.signWithCandidate,
+  softwareEd25519Handle: () => import_deviceKeyHandle.softwareEd25519Handle,
   splitKeyConvergencePolicy: () => import_credentialEnvelopeBridge.splitKeyConvergencePolicy,
   startLocalCallback: () => import_loginLocalhost.startLocalCallback,
+  testProcessSignal: () => import_liveState.testProcessSignal,
   tierPermitsConfiguredAutoMode: () => import_harnessTrust.tierPermitsConfiguredAutoMode,
   tokenHash: () => import_deviceKey.tokenHash,
   verifyArtifact: () => import_releaseManifest.verifyArtifact,
@@ -300,7 +349,11 @@ var import_ttlParser = require("./ttlParser.js");
 var import_recoveryCode = require("./recoveryCode.js");
 var import_credentialEnvelope = require("./credentialEnvelope.js");
 var import_kek = require("./kek/index.js");
+var import_liveState = require("./liveState.js");
 var import_deviceKey = require("./deviceKey.js");
+var import_deviceKeyHandle = require("./deviceKeyHandle.js");
+var import_deviceKeyServerSupport = require("./deviceKeyServerSupport.js");
+var import_deviceKeyHardware = require("./deviceKeyHardware.js");
 var import_dpop = require("./dpop.js");
 var import_credentialEnvelopeBridge = require("./credentialEnvelopeBridge.js");
 var import_deviceIdentityBridge = require("./deviceIdentityBridge.js");
@@ -327,7 +380,9 @@ __reExport(index_exports, require("./desktopWire.js"), module.exports);
 var import_independentMachineReservation = require("./independentMachineReservation.js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ALLOW_LIVE_STATE_ENV,
   ALL_DAEMON_SCOPES,
+  AUTH_SERVER_METADATA_PATH,
   AuthHelperUnavailableError,
   AuthHelperUntrustedError,
   CI_TOKEN_PREFIX,
@@ -336,12 +391,16 @@ var import_independentMachineReservation = require("./independentMachineReservat
   CRED_ENVELOPE_MAGIC,
   CRED_KEY_LEN,
   CredentialResolver,
+  DAEMON_BYOK_KEYCHAIN_SERVICE_BASE,
   DAEMON_CHILD_ENV,
+  DAEMON_KEYCHAIN_SERVICE_BASE,
   DEFAULT_BINARY_NAME,
   DEFAULT_DAEMON_SCOPES,
   DEFAULT_FIRST_PARTY_HARNESS_CHANNEL,
   DEFAULT_LOGIN_TIMEOUT_MS,
   DEFAULT_UNREADABLE_CREDENTIAL_HINT,
+  DEVICE_KEY_ALGS,
+  DEVICE_KEY_UNREADABLE_CREDENTIAL_HINT,
   DPOP_HEADER,
   DPOP_MAX_AGE_SECONDS,
   DPOP_PROOF_INVALID,
@@ -352,18 +411,25 @@ var import_independentMachineReservation = require("./independentMachineReservat
   FIRST_PARTY_HARNESS_CHANNELS,
   FIRST_PARTY_HARNESS_PREVIOUS_SUFFIX,
   FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX,
+  HARDWARE_KEY_HELPER_NAME,
   HARNESSES_LOADING_CLAUDE_SKILLS_LAYOUT,
   HARNESS_TIERS,
+  HERMETIC_HOME_ENV,
   HOSTED_RUNTIME_MACHINE_SOURCES,
+  HardwareDeviceKeyError,
   INDEPENDENT_MACHINE_PROFILE_RE,
   INDEPENDENT_MACHINE_RESERVATION_FILE,
   InMemoryKek,
   KekUnavailableError,
   LEGACY_CONFIG_DIR_NAMES,
+  LEGACY_DAEMON_KEYCHAIN_SERVICE,
   LEGACY_NATIVE_ID_PREFIXES,
+  LIVE_DEFAULT_PROFILE,
+  LIVE_STATE_REFUSED_CODE,
   LOOPBACK_DEFAULT_MAX_BODY_BYTES,
   LOOPBACK_NO_PROXY_HOSTS,
   LinuxKek,
+  LiveStateRefusedError,
   LocalCallbackBindError,
   LocalCallbackDeniedError,
   LocalCallbackError,
@@ -389,6 +455,7 @@ var import_independentMachineReservation = require("./independentMachineReservat
   PAIR_NONCE_LEN,
   PAIR_PUBKEY_LEN,
   PAIR_SECRET_LEN,
+  PENDING_HARDWARE_KEY_MAX_AGE_MS,
   PERSONAL_ACCESS_TOKEN_PREFIX,
   PROFILES_SEGMENT,
   PairBundleError,
@@ -400,6 +467,7 @@ var import_independentMachineReservation = require("./independentMachineReservat
   SENSITIVE_ENV_SUFFIXES,
   SENSITIVE_ENV_VARS,
   SENTINEL_TRIGGERING_FAILURES,
+  SERVER_DEVICE_KEY_ALGS_FIELD,
   SUPERSEDED_COPY_SUFFIX,
   SUPERSEDED_MARKER_SUFFIX,
   TRUSTED_FEED_ORIGINS,
@@ -421,6 +489,7 @@ var import_independentMachineReservation = require("./independentMachineReservat
   __resetMachineUuidCacheForTest,
   __resetShutdownGuardForTest,
   __resetUnknown401StreaksForTest,
+  __setAccountHomeForTest,
   __setCredEnvelopeStateForTest,
   __setDeviceIdentityStateForTest,
   __setFdReaderForTest,
@@ -428,8 +497,12 @@ var import_independentMachineReservation = require("./independentMachineReservat
   __setUnreadableReloadIntervalForTest,
   __wrappedDekFilePathForTest,
   accessTokenHash,
+  accountHomeDir,
+  algForJwk,
   assemblePairBundleBase64,
   assertLoopbackHttpUrl,
+  assertMayMutateLiveKeychain,
+  assertMayMutateLiveState,
   buildArtifactMessage,
   buildCredentialAad,
   buildDeviceProof,
@@ -437,14 +510,18 @@ var import_independentMachineReservation = require("./independentMachineReservat
   buildPairAad,
   buildPairUrl,
   challenge,
+  classifyDaemonKeychainService,
   classifyRefreshResponse,
   classifyTokenKind,
   claudeSkillsLayoutEvidence,
   clearEnrollmentMarker,
   clearReauthState,
+  commitDeviceKeyCandidate,
+  commitPendingHardwareKey,
   compareReleaseVersions,
   configRootPath,
   configureAuthCore,
+  configureHardwareDeviceKeyHelper,
   consolidateProfileState,
   createDpopKey,
   createRefreshScheduler,
@@ -464,6 +541,8 @@ var import_independentMachineReservation = require("./independentMachineReservat
   describeDeviceKeySplit,
   describeLegacyState,
   describeMachineIdentity,
+  describeStoredDeviceKey,
+  discardPendingHardwareKey,
   emitAuthTelemetry,
   enrollWithServer,
   ensureMachineDaemonId,
@@ -516,18 +595,27 @@ var import_independentMachineReservation = require("./independentMachineReservat
   isDaemonChildEnv,
   isDaemonScope,
   isDeviceIdentityActive,
+  isDevicePublicJwk,
   isFirstPartyHarnessChannel,
   isJwkThumbprint,
+  isLiveKeychainService,
+  isLiveStateRefusal,
   isLoopbackAddress,
   isLoopbackHostname,
   isMasterKekKeychainService,
+  isSessionKeychainService,
   isStaticTokenKind,
+  isTestProcess,
   isTrustedArtifactOrigin,
+  isUserOwnedSecretKeychainService,
   isValidRecoveryCode,
   jwkThumbprint,
+  keychainSuffixForDir,
   legacyDaemonUuids,
   legacyProfileStateDir,
   linkFirstPartyHarnessAliases,
+  liveKeychainServices,
+  liveStateRoot,
   loginWithLocalhost,
   loopbackFetch,
   maybeDecryptOnRead,
@@ -538,6 +626,7 @@ var import_independentMachineReservation = require("./independentMachineReservat
   normalizeHtu,
   normalizeRecoveryCode,
   openPairBundleBase64,
+  p256PublicJwkFromRaw,
   pairBase64ToUint8Array,
   pairBase64UrlToUint8Array,
   pairUint8ArrayToBase64,
@@ -547,16 +636,23 @@ var import_independentMachineReservation = require("./independentMachineReservat
   parsePairUrl,
   parseRecoveryCode,
   parseTtlDays,
+  persistPendingHardwareKey,
   persistReauthState,
+  prepareHardwareKeyCandidate,
+  probeHardwareDeviceKey,
   profileStateDir,
   profileStateFileLocations,
   profileStateFilePathsToClear,
+  proofSigningInput,
   publicJwkFromX,
   qualifyMachineUuid,
   readAuthFromFd,
   readIndependentMachineReservation,
+  readServerDeviceKeyAlgs,
   reauthCommand,
   refreshDaemonToken,
+  refusesLiveKeychainMutation,
+  refusesLiveStateInTest,
   registerZeroizeHook,
   reserveIndependentMachineProfile,
   resetCredEnvelope,
@@ -564,17 +660,23 @@ var import_independentMachineReservation = require("./independentMachineReservat
   resolveChannelManifestUrl,
   resolveConfigRoot,
   resolveFirstPartyHarnessChannel,
+  resolveHardwareDeviceKeyHelper,
   resolveProfileStateDir,
   resolveProfileStateFile,
+  rethrowIfLiveStateRefusal,
   revokeDaemonRefreshSession,
   runHeadersHelper,
   safeEqual,
   sanitizeSpawnEnv,
   setMachineUuidProfile,
   shutdownCredEnvelope,
+  signProofWith,
   signServerRequest,
+  signWithCandidate,
+  softwareEd25519Handle,
   splitKeyConvergencePolicy,
   startLocalCallback,
+  testProcessSignal,
   tierPermitsConfiguredAutoMode,
   tokenHash,
   verifyArtifact,

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/kek/index.d.ts

@@ -19,7 +19,7 @@ export { MacosKek } from './macos.js';
 export { LinuxKek } from './linux.js';
 export { WindowsKek } from './windows.js';
 export { zeroizeKekCaches, registerZeroizeHook } from './zeroize-registry.js';
-export { isMasterKekKeychainService, MASTER_KEK_KEYCHAIN_ACCOUNT, MASTER_KEK_KEYCHAIN_SERVICE, } from './masterKekService.js';
+export { classifyDaemonKeychainService, isMasterKekKeychainService, isSessionKeychainService, isUserOwnedSecretKeychainService, MASTER_KEK_KEYCHAIN_ACCOUNT, MASTER_KEK_KEYCHAIN_SERVICE, type DaemonKeychainServiceClass, } from './masterKekService.js';
 /**
  * @internal Test-only seam — inject a synthetic KEK strategy that wraps
  * with a fixed in-memory key. Resets to platform default when called

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/kek/index.js

@@ -37,8 +37,11 @@ __export(index_exports, {
   UnavailableKek: () => UnavailableKek,
   WindowsKek: () => import_windows2.WindowsKek,
   __setKekStrategyForTest: () => __setKekStrategyForTest,
+  classifyDaemonKeychainService: () => import_masterKekService.classifyDaemonKeychainService,
   getKekStrategy: () => getKekStrategy,
   isMasterKekKeychainService: () => import_masterKekService.isMasterKekKeychainService,
+  isSessionKeychainService: () => import_masterKekService.isSessionKeychainService,
+  isUserOwnedSecretKeychainService: () => import_masterKekService.isUserOwnedSecretKeychainService,
   registerZeroizeHook: () => import_zeroize_registry.registerZeroizeHook,
   zeroizeKekCaches: () => import_zeroize_registry.zeroizeKekCaches
 });
@@ -158,8 +161,11 @@ class UnavailableKek {
   UnavailableKek,
   WindowsKek,
   __setKekStrategyForTest,
+  classifyDaemonKeychainService,
   getKekStrategy,
   isMasterKekKeychainService,
+  isSessionKeychainService,
+  isUserOwnedSecretKeychainService,
   registerZeroizeHook,
   zeroizeKekCaches
 });

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/kek/linux.d.ts

@@ -27,6 +27,24 @@ type ReadFileSyncLike = (path: string, encoding: BufferEncoding) => string;
  * also clear the tier selection + KEK cache so the next call re-probes.
  */
 export declare function __setFsForTest(fn: ReadFileSyncLike | null): void;
+/**
+ * Write the master KEK to the Secret Service. Uses stdin (base64-encoded)
+ * as required by `secret-tool store`. Idempotent — `secret-tool store`
+ * overwrites an existing item silently.
+ *
+ * `service` and `account` are passed in (rather than read from the
+ * module-level constants) so a `LinuxKek` instance constructed with an
+ * override stores under a unique Secret Service entry.
+ *
+ * Race note: see module-level comment above.
+ */
+declare function writeKekToSecretService(kek: Buffer, service: string, account: string): Promise<void>;
+/**
+ * @internal Test seam — the Secret Service write on its own, so a spec can reach the live-state
+ * guard without the tier probe getting in the way. A spec using it empties `PATH`, so that a
+ * guard which stopped firing reaches no `secret-tool` binary.
+ */
+export declare const __writeKekToSecretServiceForTest: typeof writeKekToSecretService;
 /**
  * Zero out and drop every in-process master-KEK cache buffer (both the
  * Tier-2 by-service map and the Tier-3 single buffer).

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/kek/linux.js

@@ -32,6 +32,7 @@ __export(linux_exports, {
   __resetKekCacheForTest: () => __resetKekCacheForTest,
   __setExecFileForTest: () => __setExecFileForTest,
   __setFsForTest: () => __setFsForTest,
+  __writeKekToSecretServiceForTest: () => __writeKekToSecretServiceForTest,
   zeroizeLinuxKekCache: () => zeroizeLinuxKekCache
 });
 module.exports = __toCommonJS(linux_exports);
@@ -43,6 +44,7 @@ var import_credentialEnvelope = require("../credentialEnvelope.js");
 var import_types = require("./types.js");
 var import_zeroize_registry = require("./zeroize-registry.js");
 var import_masterKekService = require("./masterKekService.js");
+var import_liveState = require("../liveState.js");
 const KIND_LIBSECRET = "linux-libsecret-shellout";
 const KIND_HKDF = "linux-machineid-hkdf";
 const SS_SERVICE = import_masterKekService.MASTER_KEK_KEYCHAIN_SERVICE;
@@ -199,6 +201,9 @@ async function writeKekToSecretService(kek, service, account) {
   if (kek.length !== import_credentialEnvelope.KEY_LEN) {
     throw new import_types.KekUnavailableError(KIND_LIBSECRET, `writeKekToSecretService: expected ${import_credentialEnvelope.KEY_LEN}-byte buffer, got ${kek.length}`);
   }
+  if (_execFileForTest === null) {
+    (0, import_liveState.assertMayMutateLiveKeychain)(service, `store the Secret Service item ${account} (a master KEK)`);
+  }
   const b64 = kek.toString("base64");
   try {
     await exec("secret-tool", ["store", "--label=skrr daemon master KEK", "service", service, "account", account], { input: b64 });
@@ -206,6 +211,7 @@ async function writeKekToSecretService(kek, service, account) {
     throw new import_types.KekUnavailableError(KIND_LIBSECRET, "secret-tool store failed", { cause: err });
   }
 }
+const __writeKekToSecretServiceForTest = writeKekToSecretService;
 const _tier2KekCacheBySvc = /* @__PURE__ */ new Map();
 let _tier3KekCache = null;
 let _tierSelection = null;
@@ -368,6 +374,7 @@ class LinuxKek {
     } catch (err) {
       if (err instanceof import_types.KekUnavailableError)
         throw err;
+      (0, import_liveState.rethrowIfLiveStateRefusal)(err);
       throw new import_types.KekUnavailableError(this.id, err?.message ?? "shellout wrap failed", {
         cause: err
       });
@@ -421,5 +428,6 @@ class LinuxKek {
   __resetKekCacheForTest,
   __setExecFileForTest,
   __setFsForTest,
+  __writeKekToSecretServiceForTest,
   zeroizeLinuxKekCache
 });

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/kek/macos.d.ts

@@ -21,6 +21,28 @@ export declare function __setExecFileForTest(fn: ExecFileLike | null): void;
 export declare function __resetSecurityProbeCacheForTest(): void;
 /** @internal Test seam — clear the resolved-keychain cache. */
 export declare function __resetResolvedKeychainCacheForTest(): void;
+/**
+ * Create a master KEK without replacing an existing item. This key is shared
+ * by profiles, so even a first-use race in a different process must not
+ * overwrite the key protecting already wrapped credentials.
+ *
+ * The `service` / `account` parameters are threaded from the calling
+ * `MacosKek` instance so each instance keeps its own keychain entry.
+ *
+ * Explicit-keychain target: the resolved login-keychain path is passed
+ * as the trailing positional argument to `add-generic-password` so
+ * `security(1)` cannot fall back to a "default keychain" lookup that
+ * triggers a system-modal `Keychain Not Found` dialog. If no keychain
+ * resolves, throw `KekUnavailableError` immediately rather than
+ * shelling out at all.
+ */
+declare function writeKekToKeychain(kek: Buffer, service: string, account: string): Promise<void>;
+/**
+ * @internal Test seam — the Keychain write on its own, so a spec can reach the live-state
+ * guard without `wrap()`'s `security` probe getting in the way. A spec using it empties `PATH`,
+ * so that a guard which stopped firing reaches no `security` binary.
+ */
+export declare const __writeKekToKeychainForTest: typeof writeKekToKeychain;
 /**
  * Zero out and drop every cached master-KEK buffer.
  *

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/kek/macos.js

@@ -34,6 +34,7 @@ __export(macos_exports, {
   __resetResolvedKeychainCacheForTest: () => __resetResolvedKeychainCacheForTest,
   __resetSecurityProbeCacheForTest: () => __resetSecurityProbeCacheForTest,
   __setExecFileForTest: () => __setExecFileForTest,
+  __writeKekToKeychainForTest: () => __writeKekToKeychainForTest,
   zeroizeMacosKekCache: () => zeroizeMacosKekCache
 });
 module.exports = __toCommonJS(macos_exports);
@@ -47,6 +48,7 @@ var import_credentialEnvelope = require("../credentialEnvelope.js");
 var import_types = require("./types.js");
 var import_zeroize_registry = require("./zeroize-registry.js");
 var import_masterKekService = require("./masterKekService.js");
+var import_liveState = require("../liveState.js");
 const KIND_SHELLOUT = "macos-keychain-shellout";
 const KEYCHAIN_SERVICE = import_masterKekService.MASTER_KEK_KEYCHAIN_SERVICE;
 const KEYCHAIN_ACCOUNT = import_masterKekService.MASTER_KEK_KEYCHAIN_ACCOUNT;
@@ -169,6 +171,11 @@ async function writeKekToKeychain(kek, service, account) {
   if (keychainPath === null) {
     throw new import_types.KekUnavailableError(KIND_SHELLOUT, "no user login keychain resolvable; cannot write master KEK");
   }
+  if (_execFileForTest === null) {
+    (0, import_liveState.assertMayMutateLiveKeychain)(service, `add the Keychain item ${account} (a master KEK)`, {
+      keychainFile: keychainPath
+    });
+  }
   const b64 = kek.toString("base64");
   try {
     await exec("security", [
@@ -194,6 +201,7 @@ async function writeKekToKeychain(kek, service, account) {
     });
   }
 }
+const __writeKekToKeychainForTest = writeKekToKeychain;
 const _kekCacheBySvc = /* @__PURE__ */ new Map();
 (0, import_zeroize_registry.registerZeroizeHook)(() => zeroizeMacosKekCache());
 function zeroizeMacosKekCache() {
@@ -223,6 +231,7 @@ async function resolveOrCreateKek(service, account) {
     try {
       await writeKekToKeychain(fresh, service, account);
     } catch (error) {
+      (0, import_liveState.rethrowIfLiveStateRefusal)(error);
       const winner = await readKekFromKeychain(service, account).catch(() => null);
       if (!winner)
         throw error;
@@ -342,6 +351,7 @@ class MacosKek {
     } catch (err) {
       if (err instanceof import_types.KekUnavailableError)
         throw err;
+      (0, import_liveState.rethrowIfLiveStateRefusal)(err);
       throw new import_types.KekUnavailableError(this.id, err?.message ?? "shellout wrap failed", {
         cause: err
       });
@@ -398,5 +408,6 @@ class MacosKek {
   __resetResolvedKeychainCacheForTest,
   __resetSecurityProbeCacheForTest,
   __setExecFileForTest,
+  __writeKekToKeychainForTest,
   zeroizeMacosKekCache
 });

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/kek/masterKekService.d.ts

@@ -17,9 +17,18 @@
  * and the device private key sealed under the old DEK was gone for good — which
  * the server then saw as `DEVICE_PROOF_MISSING` on every CLI hand-off.
  *
- * So anything that deletes keychain items by PREFIX or PATTERN asks
- * `isMasterKekKeychainService` first. Deleting the KEK is a decision a caller
- * makes by name, never a side effect of a sweep.
+ * The fix first written for it was a denylist on a wildcard: the sweep kept
+ * matching everything under `ai.(skrr|oversky).daemon*` and skipped the services
+ * it knew to be precious. That fails open. The default for a service added under
+ * that prefix tomorrow was "deleted", which is how the KEK went, and how the
+ * person's own BYOK keys were being swept as well.
+ *
+ * So this module names what a sweep may delete, not what it may not. Every
+ * service in the daemon's Keychain namespace is in exactly one class
+ * (`classifyDaemonKeychainService`), and a sign-out selects with
+ * `isSessionKeychainService`: a service nobody has classified is LEFT IN PLACE.
+ * Deleting the KEK is a decision a caller makes by name, never a side effect of
+ * a sweep.
  */
 /** Keychain `service` of the master KEK. */
 export declare const MASTER_KEK_KEYCHAIN_SERVICE = "ai.skrr.daemon.kek";
@@ -27,3 +36,34 @@ export declare const MASTER_KEK_KEYCHAIN_SERVICE = "ai.skrr.daemon.kek";
 export declare const MASTER_KEK_KEYCHAIN_ACCOUNT = "master-kek-v1";
 /** Whether a keychain service name holds master-KEK material. */
 export declare function isMasterKekKeychainService(service: string): boolean;
+/** Whether a keychain service name holds a secret the person supplied, not a session. */
+export declare function isUserOwnedSecretKeychainService(service: string): boolean;
+/**
+ * Which kind of thing a service in the daemon's Keychain namespace holds. Exactly
+ * one, and the order of the checks in `classifyDaemonKeychainService` is what makes
+ * that true.
+ *
+ *   `master_kek`    key material every profile's envelope is sealed under. No sweep
+ *                   deletes it; a caller that must does so by name.
+ *   `user_secret`   what the person typed in (BYOK provider keys). A sign-out keeps
+ *                   it; a full uninstall removes it.
+ *   `session`       a profile's sign-in. A sign-out removes it.
+ *   `unclassified`  none of the above. Left in place, and reported, so that the next
+ *                   engineer who adds a service has to decide what it is.
+ */
+export type DaemonKeychainServiceClass = 'master_kek' | 'user_secret' | 'session' | 'unclassified';
+/**
+ * Classify one Keychain `service` name. The named non-members are asked FIRST: a
+ * profile may legally be called `byok.work` or `kek.x`, and its service then has
+ * the session shape AND the shape of the namespace it collides with. Reading it as
+ * the protected class is the safe direction (a sign-out leaves that profile's slots
+ * in place), so the protected classes win.
+ */
+export declare function classifyDaemonKeychainService(service: string): DaemonKeychainServiceClass;
+/**
+ * Whether a sign-out owns this service. This is the ONE predicate a sign-out sweep
+ * selects with (`services.filter(isSessionKeychainService)`): it names what is
+ * deleted, not what is spared. An uninstall adds `isUserOwnedSecretKeychainService`
+ * to it; no sweep adds the KEK.
+ */
+export declare function isSessionKeychainService(service: string): boolean;