fix(security): close rotateEncryptionKey crash window with in-process key rollback (DC-107) [glm-grade=A]

If the atomicWriteJSON of rotated credentials failed after rotateKey() had
already persisted+cached the new key, the on-disk key could no longer decrypt
the on-disk credentials.json (permanent loss on restart). Catch-path now
restores the old key via new cryptoUtils.restoreKey() (canonical atomic-write,
0600, hex-validated) while still holding the proper-lockfile. Double-failure
(rollback throws) is contained and the lock is still released. Hard-crash
mid-rollback is covered by the existing .bak startup fallback.

Judge: GLM-4.6 stand-in, round-1 grade A, 0 blocking, 1 LOW polish (folded).
URN urn:ump:z2sz3x6abtcffpqyde2l2ssq34vy47t5h2gbmkr3wtmfxwkerinq
Tests: 121 suites / 2785 green (6 consecutive runs pre-fold; suite re-run post-fold).

dashcaddy-api/__tests__/credential-manager.test.js

@@ -15,6 +15,8 @@ jest.mock('../src/security/crypto-utils', () => ({
   isEncrypted: jest.fn(data => typeof data === 'string' && data.startsWith('enc:')),
   loadOrCreateKey: jest.fn(() => Buffer.alloc(32, 'k')),
   rotateKey: jest.fn(() => ({ oldKey: Buffer.alloc(32, 'k'), newKey: Buffer.alloc(32, 'n') })),
+  // DC-107 rollback support – restore old key in-process after a failed write
+  restoreKey: jest.fn(() => true),
 }));
 
 jest.mock('proper-lockfile', () => ({
@@ -357,6 +359,44 @@ describe('CredentialManager', () => {
       lockfile.lock.mockRejectedValue(new Error('nope'));
       const result = await credentialManager.rotateEncryptionKey();
       expect(result).toBe(false);
+      // DC-107: failure before rotateKey() must NOT trigger a rollback
+      expect(cryptoUtils.restoreKey).not.toHaveBeenCalled();
+    });
+
+    it('rolls back the encryption key when the rotated write fails (DC-107)', async () => {
+      const releaseFn = jest.fn().mockResolvedValue();
+      lockfile.lock.mockResolvedValue(releaseFn);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        'key1': { value: 'enc:tag:' + Buffer.from('secret1').toString('base64'), metadata: {} }
+      }));
+      // atomicWriteJSON fails at the rename step, AFTER rotateKey() already
+      // swapped the on-disk key and in-memory cache
+      fs.renameSync.mockImplementationOnce(() => { throw new Error('EIO: rename'); });
+
+      const result = await credentialManager.rotateEncryptionKey();
+
+      expect(result).toBe(false);
+      expect(cryptoUtils.rotateKey).toHaveBeenCalled();
+      const expectedOldHex = Buffer.alloc(32, 'k').toString('hex');
+      expect(cryptoUtils.restoreKey).toHaveBeenCalledTimes(1);
+      expect(cryptoUtils.restoreKey).toHaveBeenCalledWith(expectedOldHex);
+      expect(releaseFn).toHaveBeenCalled(); // lock still released
+    });
+
+    it('returns false without crashing when the rollback itself fails (DC-107)', async () => {
+      const releaseFn = jest.fn().mockResolvedValue();
+      lockfile.lock.mockResolvedValue(releaseFn);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        'key1': { value: 'enc:tag:' + Buffer.from('secret1').toString('base64'), metadata: {} }
+      }));
+      fs.renameSync.mockImplementationOnce(() => { throw new Error('EIO: rename'); });
+      cryptoUtils.restoreKey.mockImplementationOnce(() => { throw new Error('rollback ENOSPC'); });
+
+      const result = await credentialManager.rotateEncryptionKey();
+
+      expect(result).toBe(false);
+      expect(cryptoUtils.restoreKey).toHaveBeenCalledTimes(1);
+      expect(releaseFn).toHaveBeenCalled(); // lock released even on double failure
     });
   });