@modelprofile.com/authswitch 7.0.0 → 8.1.0

package/ts/classes.authoritybackup.ts

@@ -1,780 +0,0 @@
-import * as plugins from './plugins.js';
-import {
-  assertStoredAuthorityBinding, assertStoredAuthorityClaudeHandoff,
-  assertStoredAuthorityClaudeHome, assertStoredAuthorityCodexHome, assertStoredAuthorityEnrollment,
-  assertStoredAuthorityGrant, assertStoredAuthorityHandoff,
-  assertStoredAuthorityMeta, assertStoredAuthorityMigrationLedger, assertStoredAuthorityOperation,
-  restoreStoredAuthorityOperation,
-  type IStoredAuthorityBinding, type IStoredAuthorityCodexHome,
-  type IStoredAuthorityEnrollment, type IStoredAuthorityGrant, type IStoredAuthorityMeta,
-} from './classes.authoritymodels.js';
-import { assertAuthorityStoredRecord, type IAuthorityStoredRecord } from './classes.authorityregistry.js';
-import type { IAuthSwitchSecretCodec } from './classes.authoritysecrets.js';
-import type { IRemoteControlEnrollment } from './interfaces.js';
-
-const maxPlainChunkBytes = 8 * 1024 * 1024;
-const maxEncryptedObjectBytes = 12 * 1024 * 1024;
-// The manifest is still one object. A paged authenticated index is required for unlimited inventory.
-const maxRecordBytes = 1024 * 1024;
-const maxSourceBytes = 4 * 1024 * 1024;
-const hash = (bytes: Uint8Array | string): string => plugins.crypto.createHash('sha256').update(bytes).digest('hex');
-const uuid = (): string => plugins.crypto.randomUUID();
-const isHash = (value: unknown): value is string => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
-const isName = (value: unknown): value is string => typeof value === 'string' && /^[a-zA-Z0-9_.:-]{1,256}$/.test(value);
-const isDigestField = (value: unknown): value is IAuthorityBackupSourceCapsule['linkedDigestField'] =>
-  value === 'sourceDigest' || value === 'before.credentialDigest' || value === 'before.configDigest';
-function fail(message: string): never { throw new Error(message); }
-const recordKey = (model: string, id: string): string => `${model}\u0000${id}`;
-const context = (...parts: Array<string | number>): Uint8Array => Buffer.from(JSON.stringify(['authswitch-backup-v1', ...parts]));
-const object = (value: unknown): value is Record<string, unknown> => value !== null
-  && typeof value === 'object' && !Array.isArray(value)
-  && [Object.prototype, null].includes(Object.getPrototypeOf(value));
-const exactKeys = (value: Record<string, unknown>, keys: readonly string[]): boolean =>
-  Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key));
-
-const assertSnapshotRecord = assertAuthorityStoredRecord;
-
-/** This ID preserves Codex's complete three-column enrollment key, without email matching. */
-export const authorityEnrollmentId = (row: IRemoteControlEnrollment): string =>
-  hash(JSON.stringify(['authswitch-enrollment-v1', row.websocketUrl, row.accountId, row.appServerClientName]));
-
-const parseEnrollment = (bytes: Uint8Array, id: string): IRemoteControlEnrollment => {
-  const value: unknown = JSON.parse(Buffer.from(bytes).toString('utf8'));
-  if (!object(value) || !exactKeys(value, ['websocketUrl', 'accountId', 'appServerClientName',
-    'serverId', 'environmentId', 'serverName', 'updatedAt', 'remoteControlEnabled'])
-    || !['websocketUrl', 'accountId', 'appServerClientName', 'serverId', 'environmentId', 'serverName']
-      .every(key => typeof value[key] === 'string')
-    || !Number.isSafeInteger(value.updatedAt) || Number(value.updatedAt) < 0
-    || ![null, 0, 1].includes(value.remoteControlEnabled as null | number)) {
-    throw new Error('Backup enrollment has an invalid or incomplete Codex row.');
-  }
-  const row = value as unknown as IRemoteControlEnrollment;
-  if (!row.websocketUrl || !row.accountId
-    || authorityEnrollmentId(row) !== id) throw new Error('Backup enrollment composite identity changed.');
-  return row;
-};
-
-const assertJson = (value: unknown, depth = 0): void => {
-  if (depth > 24) fail('Backup record exceeds the JSON depth limit.');
-  if (value === null || typeof value === 'string' || typeof value === 'boolean') return;
-  if (typeof value === 'number' && Number.isFinite(value)) return;
-  if (Array.isArray(value)) { for (const item of value) assertJson(item, depth + 1); return; }
-  if (object(value)) { for (const item of Object.values(value)) assertJson(item, depth + 1); return; }
-  fail('Backup record contains a non-JSON value.');
-};
-
-/** SmartData readback may reorder object fields; arrays and native source bytes remain exact. */
-const canonicalJson = (value: unknown): string => {
-  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;
-  if (object(value)) return `{${Object.keys(value).sort().map(key =>
-    `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(',')}}`;
-  assertJson(value);
-  return JSON.stringify(value);
-};
-
-export type IAuthorityBackupRecord = IAuthorityStoredRecord;
-export interface IAuthorityBackupSourceCapsule {
-  kind: string;
-  id: string;
-  linkedModel: string;
-  linkedId: string;
-  linkedDigestField: 'sourceDigest' | 'before.credentialDigest' | 'before.configDigest';
-  /** Exact bytes re-read under the native owner's exclusion; the caller retains and wipes its buffer. */
-  bytes: Uint8Array;
-}
-export interface IAuthorityBackupSnapshotAttempt {
-  epoch: string;
-  revision: number;
-  records: AsyncIterable<IAuthorityBackupRecord>;
-  sources: AsyncIterable<IAuthorityBackupSourceCapsule>;
-}
-/** Implement with one SmartData session.withTransaction; each retry invokes visit anew. */
-export interface IAuthorityBackupSnapshotSource {
-  capture(visit: (attempt: IAuthorityBackupSnapshotAttempt) => Promise<void>): Promise<void>;
-}
-export interface IAuthorityBackupObjectStore {
-  prepare(signal?: AbortSignal): Promise<void>;
-  putExact(path: string, bytes: Uint8Array, signal?: AbortSignal): Promise<void>;
-  get(path: string, maxBytes: number, signal?: AbortSignal): Promise<Uint8Array>;
-}
-
-/** Thin adapter over SmartBucket's provider-probed, create-only exact upload API. */
-export class AuthoritySmartBucketStore implements IAuthorityBackupObjectStore {
-  private capability?: plugins.smartbucket.IExactUploadCapability;
-  constructor(private readonly bucket: plugins.smartbucket.Bucket) {}
-
-  public async prepare(signal?: AbortSignal): Promise<void> {
-    const result = await this.bucket.probeExactUploadCapability({ signal });
-    if (!result.supported) throw new Error(`Exact backup uploads unavailable: ${result.reason}`);
-    this.capability = result.capability;
-  }
-
-  public async putExact(path: string, bytes: Uint8Array, signal?: AbortSignal): Promise<void> {
-    if (!this.capability) throw new Error('Exact upload capability has not been probed.');
-    const source = plugins.stream.Readable.from((function* () {
-      for (let offset = 0; offset < bytes.byteLength; offset += 1024 * 1024) {
-        yield Buffer.from(bytes.subarray(offset, offset + 1024 * 1024));
-      }
-    })());
-    try {
-      await this.bucket.fastPutStreamExact({ capability: this.capability, path, readableStream: source,
-        contentLength: bytes.byteLength, nativeObjectProperties: { contentType: 'application/json' }, signal });
-    } finally { source.destroy(); }
-  }
-
-  public async get(path: string, maxBytes: number, signal?: AbortSignal): Promise<Uint8Array> {
-    const source = await this.bucket.fastGetStream({ path, signal });
-    const chunks: Buffer[] = [];
-    let length = 0;
-    try {
-      for await (const chunk of source) {
-        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk as Uint8Array);
-        length += bytes.byteLength;
-        if (length > maxBytes) throw new Error('Backup object exceeds its bounded read limit.');
-        chunks.push(bytes);
-      }
-      return Buffer.concat(chunks, length);
-    } finally { source.destroy(); }
-  }
-}
-
-export interface IAuthorityRestoredRecord extends IAuthorityBackupRecord {}
-export interface IAuthorityRestoredSource {
-  kind: 'source'; sourceKind: string; sourceId: string; sourceDigest: string;
-  linkedModel: string; linkedId: string;
-  linkedDigestField: IAuthorityBackupSourceCapsule['linkedDigestField']; bytes: Uint8Array;
-}
-export type TAuthorityRestoredEntry = IAuthorityRestoredRecord | IAuthorityRestoredSource;
-export interface IAuthorityBackupRehearsalReadback {
-  records: AsyncIterable<IAuthorityRestoredRecord>;
-  sources: AsyncIterable<IAuthorityRestoredSource>;
-  /** Stops the isolated database and child, then removes every disposable artifact. */
-  close(): Promise<void>;
-}
-/** Must restore into an isolated, runtime-closed target and read its stored postimage back. */
-export interface IAuthorityBackupRehearsal {
-  restoreClosed(entries: AsyncIterable<TAuthorityRestoredEntry>): Promise<IAuthorityBackupRehearsalReadback>;
-}
-
-interface IChunk { sequence: number; path: string; encryptedDigest: string; plaintextDigest: string; length: number; entries: number }
-export interface IAuthorityBackupSourceProof {
-  kind: string; id: string; linkedModel: string; linkedId: string;
-  linkedDigestField: IAuthorityBackupSourceCapsule['linkedDigestField']; digest: string;
-}
-interface IManifest {
-  schemaVersion: 1; backupId: string; epoch: string; revision: number; recipientKeyId: string;
-  chunks: IChunk[]; recordCount: number; sources: IAuthorityBackupSourceProof[]; snapshotDigest: string;
-}
-function assertManifest(value: unknown, backupId: string, prefix: string): asserts value is IManifest {
-  if (!object(value) || !exactKeys(value, ['schemaVersion', 'backupId', 'epoch', 'revision',
-    'recipientKeyId', 'chunks', 'recordCount', 'sources', 'snapshotDigest'])
-    || value.schemaVersion !== 1 || value.backupId !== backupId
-    || typeof value.epoch !== 'string' || !/^[a-f0-9-]{36}$/.test(value.epoch)
-    || !Number.isSafeInteger(value.revision) || Number(value.revision) < 0
-    || !isName(value.recipientKeyId) || !Number.isSafeInteger(value.recordCount)
-    || Number(value.recordCount) < 1 || !isHash(value.snapshotDigest)
-    || !Array.isArray(value.chunks) || !Array.isArray(value.sources)) {
-    fail('Invalid authenticated backup manifest.');
-  }
-  for (let index = 0; index < value.chunks.length; index++) {
-    const item: unknown = value.chunks[index];
-    if (!object(item) || !exactKeys(item, ['sequence', 'path', 'encryptedDigest',
-      'plaintextDigest', 'length', 'entries']) || item.sequence !== index
-      || item.path !== `${prefix}/${backupId}/chunk-${String(index).padStart(5, '0')}.json`
-      || !isHash(item.encryptedDigest) || !isHash(item.plaintextDigest)
-      || !Number.isSafeInteger(item.length) || Number(item.length) < 1
-      || Number(item.length) > maxEncryptedObjectBytes
-      || !Number.isSafeInteger(item.entries) || Number(item.entries) < 1) {
-      fail('Invalid authenticated backup chunk index.');
-    }
-  }
-  const sourceIds = new Set<string>();
-  for (const item of value.sources) {
-    if (!object(item) || !exactKeys(item, ['kind', 'id', 'linkedModel', 'linkedId', 'linkedDigestField', 'digest'])
-      || !isName(item.kind) || !isName(item.id) || !isName(item.linkedModel)
-      || !isName(item.linkedId) || !isDigestField(item.linkedDigestField) || !isHash(item.digest)) {
-      fail('Invalid authenticated backup source index.');
-    }
-    const sourceKey = recordKey(item.kind, item.id);
-    if (sourceIds.has(sourceKey)) fail('Duplicate authenticated backup source proof.');
-    sourceIds.add(sourceKey);
-  }
-}
-interface IRecordLine { kind: 'record'; model: string; id: string; value: unknown; secret: string | null }
-interface ISourceLine { kind: 'source'; sourceKind: string; sourceId: string; linkedModel: string;
-  linkedId: string; linkedDigestField: IAuthorityBackupSourceCapsule['linkedDigestField'];
-  sourceDigest: string; payload: string }
-type TLine = IRecordLine | ISourceLine;
-interface IStagedAttempt { dir: string; manifest: IManifest }
-
-/** Factual portable proof only. Production admission must additionally bind configured bucket and key custody. */
-export interface IAuthorityBackupVerification {
-  backupId: string; manifestPath: string; manifestDigest: string; snapshotDigest: string; sourceEpoch: string;
-  sourceRevision: number; restoredEpoch: string; recordCount: number; sources: IAuthorityBackupSourceProof[];
-  rehearsalDigest: string; verifiedAt: string;
-  /** Portable recovery proves data integrity, never that a surviving native writer has stopped. */
-  restoreAdmission: 'closed_pending_codex_and_native_reconciliation';
-}
-
-/** An object locator and digest only; this carries no recoverability or deletion authority. */
-export interface IAuthorityBackupPublication {
-  backupId: string;
-  manifestPath: string;
-  manifestDigest: string;
-  sourceEpoch: string;
-  sourceRevision: number;
-  snapshotDigest: string;
-}
-
-export class AuthorityBackupPublicationUnknownError extends Error {
-  constructor(public readonly path: string, cause: unknown) {
-    super('Backup exact upload outcome could not be reconciled by readback.', { cause });
-  }
-}
-
-interface IAuthorityBackupCommonOptions {
-  store: IAuthorityBackupObjectStore;
-  secrets: IAuthSwitchSecretCodec;
-  prefix: string;
-  recipientKeyId: string;
-  signal?: AbortSignal;
-}
-export interface IAuthorityBackupPublisherOptions extends IAuthorityBackupCommonOptions {
-  source: IAuthorityBackupSnapshotSource;
-  recipientPublicKey: Uint8Array;
-}
-export interface IAuthorityBackupVerifierOptions extends IAuthorityBackupCommonOptions {
-  rehearsal: IAuthorityBackupRehearsal;
-  recipientPrivateKey: Uint8Array;
-}
-export type TAuthorityBackupOptions = IAuthorityBackupPublisherOptions | IAuthorityBackupVerifierOptions;
-
-/** Portable backup codec; the daemon's SmartData repository supplies the snapshot and persists the verified receipt. */
-export class AuthSwitchAuthorityBackup {
-  constructor(private readonly options: TAuthorityBackupOptions) {}
-
-  private publisher(): IAuthorityBackupPublisherOptions {
-    if (!('source' in this.options)) fail('Backup publisher requires a committed snapshot source.');
-    return this.options;
-  }
-
-  private verifier(): IAuthorityBackupVerifierOptions {
-    if (!('rehearsal' in this.options)) fail('Backup verifier requires an isolated restore target.');
-    return this.options;
-  }
-
-  private async secretFor(record: IAuthorityBackupRecord): Promise<string | null> {
-    const value = record.value;
-    let id: string | null = null;
-    let sealed: string | null = null;
-    if (record.model === 'authswitch_authority_grants') {
-      assertStoredAuthorityGrant(value);
-      id = value.id; sealed = value.ciphertext;
-    } else if (record.model === 'authswitch_authority_enrollments') {
-      assertStoredAuthorityEnrollment(value);
-      id = value.id; sealed = value.ciphertext;
-    } else if (record.model === 'authswitch_authority_claude_handoffs' && object(value)
-      && typeof value.outgoingGrantId === 'string' && typeof value.sealedOutgoing === 'string') {
-      id = value.outgoingGrantId; sealed = value.sealedOutgoing;
-    }
-    if (!id || !sealed) return null;
-    const bytes = await this.options.secrets.unseal(id, sealed);
-    try {
-      if (record.model === 'authswitch_authority_enrollments') parseEnrollment(bytes, record.id);
-      return Buffer.from(bytes).toString('base64url');
-    } finally { bytes.fill(0); }
-  }
-
-  private sourceDigestInRecord(record: IAuthorityBackupRecord,
-    field: IAuthorityBackupSourceCapsule['linkedDigestField']): string | null {
-    if (!object(record.value)) return null;
-    if (field === 'sourceDigest') return isHash(record.value.sourceDigest) ? record.value.sourceDigest : null;
-    if (object(record.value.before)) {
-      const digest = field === 'before.credentialDigest'
-        ? record.value.before.credentialDigest : record.value.before.configDigest;
-      return isHash(digest) ? digest : null;
-    }
-    return null;
-  }
-
-  private assertPreparedClaudeSourceCoverage(record: IAuthorityBackupRecord,
-    sources: readonly IAuthorityBackupSourceProof[]): void {
-    if (record.model !== 'authswitch_authority_claude_handoffs') return;
-    assertStoredAuthorityClaudeHandoff(record.value);
-    if (record.value.phase !== 'prepared') return;
-    for (const field of ['before.credentialDigest', 'before.configDigest'] as const) {
-      const digest = this.sourceDigestInRecord(record, field);
-      if (digest !== null && !sources.some(source =>
-        source.linkedDigestField === field && source.digest === digest)) {
-        fail('Prepared Claude native source bytes are missing from the backup.');
-      }
-    }
-  }
-
-  private async stage(backupId: string, attempt: IAuthorityBackupSnapshotAttempt): Promise<IStagedAttempt> {
-    const publisher = this.publisher();
-    if (typeof attempt.epoch !== 'string' || !/^[a-f0-9-]{36}$/.test(attempt.epoch)
-      || !Number.isSafeInteger(attempt.revision) || attempt.revision < 0) fail('Invalid backup snapshot identity.');
-    const dir = await plugins.fs.promises.mkdtemp(plugins.path.join(plugins.os.tmpdir(), 'authswitch-backup-'));
-    await plugins.fs.promises.chmod(dir, 0o700);
-    const sources: Array<IAuthorityBackupSourceProof & { seen: boolean }> = [];
-    const sourceIds = new Set<string>();
-    const sourceLinks = new Map<string, Array<IAuthorityBackupSourceProof & { seen: boolean }>>();
-    const lines: string[] = [];
-    const chunks: IChunk[] = [];
-    const snapshotHash = plugins.crypto.createHash('sha256');
-    let chunkBytes = 0;
-    let recordCount = 0;
-    let metaCount = 0;
-    let lastRecordKey = '';
-    const append = async (line: TLine): Promise<void> => {
-      const encoded = `${JSON.stringify(line)}\n`;
-      const length = Buffer.byteLength(encoded);
-      if (length > maxPlainChunkBytes) fail('Backup entry exceeds the encrypted chunk limit.');
-      if (chunkBytes + length > maxPlainChunkBytes) await flush();
-      lines.push(encoded); chunkBytes += length; snapshotHash.update(encoded);
-    };
-    const flush = async (): Promise<void> => {
-      if (lines.length === 0) return;
-      const sequence = chunks.length;
-      const plaintext = Buffer.from(lines.join(''));
-      const plaintextDigest = hash(plaintext);
-      try {
-        const envelope = await plugins.smartcrypto.sealX25519Envelope({ plaintext,
-          recipientPublicKey: publisher.recipientPublicKey, recipientKeyId: this.options.recipientKeyId,
-          context: context('chunk', backupId, attempt.epoch, attempt.revision, sequence, plaintextDigest) });
-        const encrypted = Buffer.from(JSON.stringify(envelope));
-        if (encrypted.byteLength > maxEncryptedObjectBytes) fail('Encrypted backup chunk exceeds its object bound.');
-        const path = `${this.options.prefix}/${backupId}/chunk-${String(sequence).padStart(5, '0')}.json`;
-        await plugins.fs.promises.writeFile(plugins.path.join(dir, `${sequence}.enc`), encrypted, { flag: 'wx', mode: 0o600 });
-        chunks.push({ sequence, path, encryptedDigest: hash(encrypted), plaintextDigest,
-          length: encrypted.byteLength, entries: lines.length });
-        lines.length = 0; chunkBytes = 0;
-      } finally { plaintext.fill(0); }
-    };
-    try {
-      for await (const source of attempt.sources) {
-        this.options.signal?.throwIfAborted();
-        if (!isName(source.kind) || !isName(source.id)
-          || !isName(source.linkedModel) || !isName(source.linkedId)
-          || !isDigestField(source.linkedDigestField)
-          || !(source.bytes instanceof Uint8Array) || source.bytes.byteLength === 0
-          || source.bytes.byteLength > maxSourceBytes) fail('Invalid or oversized exact-source capsule.');
-        const sourceKey = recordKey(source.kind, source.id);
-        if (sourceIds.has(sourceKey)) fail('Duplicate exact-source capsule.');
-        const bytes = Uint8Array.from(source.bytes);
-        try {
-          const proof = { kind: source.kind, id: source.id, linkedModel: source.linkedModel,
-            linkedId: source.linkedId, linkedDigestField: source.linkedDigestField,
-            digest: hash(bytes), seen: false };
-          await append({ kind: 'source', sourceKind: proof.kind, sourceId: proof.id,
-            linkedModel: proof.linkedModel, linkedId: proof.linkedId,
-            linkedDigestField: proof.linkedDigestField,
-            sourceDigest: proof.digest, payload: Buffer.from(bytes).toString('base64url') });
-          sources.push(proof);
-          sourceIds.add(sourceKey);
-          const linkKey = recordKey(proof.linkedModel, proof.linkedId);
-          const linked = sourceLinks.get(linkKey) ?? [];
-          linked.push(proof);
-          sourceLinks.set(linkKey, linked);
-        } finally { bytes.fill(0); }
-      }
-      for await (const record of attempt.records) {
-        this.options.signal?.throwIfAborted();
-        if (!isName(record.model) || !isName(record.id) || !object(record.value)
-          || record.value.id !== record.id) fail('Invalid backup record identity.');
-        const key = recordKey(record.model, record.id);
-        if (key <= lastRecordKey) fail('Backup records must be sorted by model and stable ID.');
-        lastRecordKey = key;
-        assertJson(record.value);
-        if (Buffer.byteLength(JSON.stringify(record.value)) > maxRecordBytes) fail('Backup record exceeds its size bound.');
-        assertSnapshotRecord(record);
-        if (record.model === 'authswitch_authority_meta') {
-          assertStoredAuthorityMeta(record.value);
-          if (record.value.epoch !== attempt.epoch || record.value.revision !== attempt.revision) {
-            fail('Backup metadata does not match the pinned snapshot.');
-          }
-          metaCount++;
-        }
-        for (const source of sourceLinks.get(key) ?? []) {
-          if (this.sourceDigestInRecord(record, source.linkedDigestField) !== source.digest) {
-            fail('Exact-source bytes differ from their linked persisted record.');
-          }
-          source.seen = true;
-        }
-        this.assertPreparedClaudeSourceCoverage(record, sourceLinks.get(key) ?? []);
-        await append({ kind: 'record', model: record.model, id: record.id,
-          value: record.value, secret: await this.secretFor(record) });
-        recordCount++;
-      }
-      if (metaCount !== 1 || sources.some(source => !source.seen)) {
-        fail('Backup is missing metadata or an exact-source linkage.');
-      }
-      await flush();
-      return { dir, manifest: { schemaVersion: 1, backupId, epoch: attempt.epoch,
-        revision: attempt.revision, recipientKeyId: this.options.recipientKeyId, chunks,
-        recordCount, sources: sources.map(source => ({ kind: source.kind, id: source.id,
-          linkedModel: source.linkedModel, linkedId: source.linkedId,
-          linkedDigestField: source.linkedDigestField, digest: source.digest })),
-        snapshotDigest: snapshotHash.digest('hex') } };
-    } catch (error) {
-      await plugins.fs.promises.rm(dir, { recursive: true, force: true });
-      throw error;
-    }
-  }
-
-  private async publish(path: string, bytes: Uint8Array): Promise<void> {
-    try { await this.options.store.putExact(path, bytes, this.options.signal); }
-    catch (error) {
-      if (!(error instanceof plugins.smartbucket.ExactUploadError)
-        || error.state.destinationPublication !== 'ambiguous') throw error;
-      let found: Uint8Array;
-      try { found = await this.options.store.get(path, bytes.byteLength, AbortSignal.timeout(30_000)); }
-      catch (readError) { throw new AuthorityBackupPublicationUnknownError(path, readError); }
-      if (hash(found) !== hash(bytes) || found.byteLength !== bytes.byteLength) {
-        throw new AuthorityBackupPublicationUnknownError(path, error);
-      }
-    }
-    const readback = await this.options.store.get(path, bytes.byteLength, this.options.signal);
-    if (readback.byteLength !== bytes.byteLength || hash(readback) !== hash(bytes)) {
-      fail('Exact backup object readback differs from the published bytes.');
-    }
-  }
-
-  public async publishSnapshot(): Promise<IAuthorityBackupPublication> {
-    const { source, recipientPublicKey } = this.publisher();
-    const { store, prefix, recipientKeyId } = this.options;
-    if (!/^[a-zA-Z0-9/_-]{1,256}$/.test(prefix) || prefix.startsWith('/') || prefix.endsWith('/')
-      || prefix.includes('//') || !isName(recipientKeyId)
-      || recipientPublicKey.byteLength !== 32) {
-      fail('Invalid backup destination or recovery-key reference.');
-    }
-    const backupId = uuid();
-    const stageHolder: { current: IStagedAttempt | null } = { current: null };
-    try {
-      await source.capture(async attempt => {
-        if (stageHolder.current) await plugins.fs.promises.rm(stageHolder.current.dir, { recursive: true, force: true });
-        stageHolder.current = null;
-        stageHolder.current = await this.stage(backupId, attempt);
-      });
-      const completed = stageHolder.current;
-      if (!completed) fail('Snapshot source committed without a backup attempt.');
-      const manifestBytes = Buffer.from(JSON.stringify(completed.manifest));
-      if (manifestBytes.byteLength > maxRecordBytes) fail('Backup manifest exceeds its size bound.');
-      const manifestEnvelope = await plugins.smartcrypto.sealX25519Envelope({
-        plaintext: manifestBytes, recipientPublicKey, recipientKeyId, context: context('manifest', backupId),
-      });
-      manifestBytes.fill(0);
-      const encryptedManifest = Buffer.from(JSON.stringify(manifestEnvelope));
-      const manifestPath = `${prefix}/${backupId}/manifest.json`;
-      await store.prepare(this.options.signal);
-      for (const chunk of completed.manifest.chunks) {
-        this.options.signal?.throwIfAborted();
-        const bytes = await plugins.fs.promises.readFile(plugins.path.join(completed.dir, `${chunk.sequence}.enc`));
-        if (bytes.byteLength !== chunk.length || hash(bytes) !== chunk.encryptedDigest) {
-          fail('Disposable encrypted backup staging changed before publication.');
-        }
-        await this.publish(chunk.path, bytes);
-      }
-      await this.publish(manifestPath, encryptedManifest);
-      return { backupId, manifestPath, manifestDigest: hash(encryptedManifest),
-        sourceEpoch: completed.manifest.epoch, sourceRevision: completed.manifest.revision,
-        snapshotDigest: completed.manifest.snapshotDigest };
-    } finally {
-      if (stageHolder.current) await plugins.fs.promises.rm(stageHolder.current.dir, { recursive: true, force: true });
-    }
-  }
-
-  /** Rehearse a previously published object set; no caller-supplied success flag is accepted. */
-  public async rehearsePublished(input: IAuthorityBackupPublication): Promise<IAuthorityBackupVerification> {
-    if (!/^[a-f0-9-]{36}$/.test(input.backupId) || !isHash(input.manifestDigest)
-      || !/^[a-f0-9-]{36}$/.test(input.sourceEpoch)
-      || !Number.isSafeInteger(input.sourceRevision) || input.sourceRevision < 0
-      || !isHash(input.snapshotDigest)
-      || input.manifestPath !== `${this.options.prefix}/${input.backupId}/manifest.json`) {
-      fail('Invalid published backup reference.');
-    }
-    return this.verifyPublished(input);
-  }
-
-  private async verifyPublished(input: IAuthorityBackupPublication): Promise<IAuthorityBackupVerification> {
-    const verifier = this.verifier();
-    const encrypted = await this.options.store.get(input.manifestPath, maxEncryptedObjectBytes, this.options.signal);
-    if (hash(encrypted) !== input.manifestDigest) fail('Backup manifest readback digest changed.');
-    const opened = await plugins.smartcrypto.openX25519Envelope({
-      envelope: JSON.parse(Buffer.from(encrypted).toString('utf8')),
-      recipientPrivateKey: verifier.recipientPrivateKey,
-      expectedRecipientKeyId: this.options.recipientKeyId,
-      context: context('manifest', input.backupId),
-    });
-    let manifestValue: unknown;
-    try {
-      if (opened.byteLength > maxRecordBytes) fail('Authenticated backup manifest exceeds its size bound.');
-      manifestValue = JSON.parse(Buffer.from(opened).toString('utf8'));
-    }
-    finally { opened.fill(0); }
-    assertManifest(manifestValue, input.backupId, this.options.prefix);
-    const manifest = manifestValue;
-    if (manifest.recipientKeyId !== this.options.recipientKeyId
-      || manifest.epoch !== input.sourceEpoch || manifest.revision !== input.sourceRevision
-      || manifest.snapshotDigest !== input.snapshotDigest) {
-      fail('Authenticated backup manifest does not match the committed snapshot.');
-    }
-    const sourceLinks = new Map<string, Array<{ proof: IAuthorityBackupSourceProof; index: number }>>();
-    manifest.sources.forEach((proof, index) => {
-      const key = recordKey(proof.linkedModel, proof.linkedId);
-      const linked = sourceLinks.get(key) ?? [];
-      linked.push({ proof, index });
-      sourceLinks.set(key, linked);
-    });
-    const linkedSourceIndexes = new Set<number>();
-    const restoredEpoch = uuid();
-    const snapshotHash = plugins.crypto.createHash('sha256');
-    const expectedRecordHash = plugins.crypto.createHash('sha256');
-    const expectedSourceHash = plugins.crypto.createHash('sha256');
-    let recordCount = 0;
-    let sourceCount = 0;
-    let expectedCount = 0;
-    let expectedSourceCount = 0;
-    let lastKey = '';
-    let recordsStarted = false;
-    let fullyConsumed = false;
-    const self = this;
-    const entries = async function* (): AsyncGenerator<TAuthorityRestoredEntry> {
-      for (const chunk of manifest.chunks) {
-        self.options.signal?.throwIfAborted();
-        const encryptedChunk = await self.options.store.get(chunk.path, maxEncryptedObjectBytes, self.options.signal);
-        if (encryptedChunk.byteLength !== chunk.length || hash(encryptedChunk) !== chunk.encryptedDigest) {
-          fail('Published backup chunk differs from its authenticated manifest.');
-        }
-        const plaintext = await plugins.smartcrypto.openX25519Envelope({
-          envelope: JSON.parse(Buffer.from(encryptedChunk).toString('utf8')),
-          recipientPrivateKey: verifier.recipientPrivateKey,
-          expectedRecipientKeyId: manifest.recipientKeyId,
-          context: context('chunk', manifest.backupId, manifest.epoch, manifest.revision,
-            chunk.sequence, chunk.plaintextDigest),
-        });
-        try {
-          if (plaintext.byteLength > maxPlainChunkBytes || hash(plaintext) !== chunk.plaintextDigest) {
-            fail('Published backup chunk plaintext digest changed.');
-          }
-          const serialized = Buffer.from(plaintext).toString('utf8');
-          if (!serialized.endsWith('\n')) fail('Backup chunk ended with a truncated entry.');
-          const lines = serialized.slice(0, -1).split('\n');
-          if (lines.length !== chunk.entries) fail('Backup chunk entry count changed.');
-          snapshotHash.update(serialized);
-          for (const line of lines) {
-            const entry: unknown = JSON.parse(line);
-            if (!object(entry)) fail('Invalid backup entry.');
-            if (entry.kind === 'source') {
-              if (recordsStarted) fail('Exact-source capsules must precede backup records.');
-              if (!isName(entry.sourceKind) || !isName(entry.sourceId)
-                || !isName(entry.linkedModel) || !isName(entry.linkedId)
-                || !isDigestField(entry.linkedDigestField)
-                || !isHash(entry.sourceDigest) || typeof entry.payload !== 'string') {
-                fail('Invalid exact-source backup capsule.');
-              }
-              const bytes = Buffer.from(entry.payload, 'base64url');
-              if (bytes.byteLength > maxSourceBytes || hash(bytes) !== entry.sourceDigest) {
-                fail('Exact-source capsule digest changed.');
-              }
-              const proof = manifest.sources[sourceCount];
-              if (!proof || proof.kind !== entry.sourceKind || proof.id !== entry.sourceId
-                || proof.linkedModel !== entry.linkedModel || proof.linkedId !== entry.linkedId
-                || proof.linkedDigestField !== entry.linkedDigestField
-                || proof.digest !== entry.sourceDigest) fail('Exact-source capsule order or coverage changed.');
-              sourceCount++;
-              const restored: IAuthorityRestoredSource = { kind: 'source', sourceKind: entry.sourceKind,
-                sourceId: entry.sourceId, linkedModel: entry.linkedModel, linkedId: entry.linkedId,
-                linkedDigestField: entry.linkedDigestField, sourceDigest: entry.sourceDigest, bytes };
-              expectedSourceHash.update(canonicalJson({ ...restored,
-                bytes: Buffer.from(bytes).toString('base64url') }) + '\n');
-              expectedSourceCount++;
-              yield restored;
-            } else if (entry.kind === 'record') {
-              recordsStarted = true;
-              if (!isName(entry.model) || !isName(entry.id) || !object(entry.value)
-                || entry.value.id !== entry.id || (entry.secret !== null && typeof entry.secret !== 'string')) {
-                fail('Invalid backup record entry.');
-              }
-              const key = recordKey(entry.model, entry.id);
-              if (key <= lastKey) fail('Backup record order changed.');
-              lastKey = key; recordCount++;
-              const originalRecord = { model: entry.model, id: entry.id, value: entry.value };
-              assertSnapshotRecord(originalRecord);
-              const linked = sourceLinks.get(key) ?? [];
-              for (const { proof, index } of linked) {
-                if (self.sourceDigestInRecord(originalRecord, proof.linkedDigestField) !== proof.digest) {
-                  fail('Authenticated source proof is not linked to its exact record digest.');
-                }
-                linkedSourceIndexes.add(index);
-              }
-              self.assertPreparedClaudeSourceCoverage(originalRecord, linked.map(item => item.proof));
-              const restored = await self.restoreRecord({ model: entry.model, id: entry.id,
-                value: entry.value }, entry.secret, restoredEpoch);
-              if (restored) {
-                expectedRecordHash.update(canonicalJson(restored) + '\n'); expectedCount++;
-                yield restored;
-              }
-            } else fail('Unknown backup entry kind.');
-          }
-        } finally { plaintext.fill(0); }
-      }
-      if (linkedSourceIndexes.size !== manifest.sources.length) {
-        fail('Authenticated source proof lacks a linked persisted record.');
-      }
-      if (recordCount !== manifest.recordCount || sourceCount !== manifest.sources.length
-        || snapshotHash.digest('hex') !== manifest.snapshotDigest) {
-        fail('Published backup snapshot is incomplete.');
-      }
-      fullyConsumed = true;
-    };
-    const readback = await verifier.rehearsal.restoreClosed(entries());
-    let rehearsalDigest: string | undefined;
-    let verificationFailure: unknown;
-    try {
-      if (!fullyConsumed) fail('Restore rehearsal did not consume the complete backup.');
-      const actualRecordHash = plugins.crypto.createHash('sha256');
-      const actualSourceHash = plugins.crypto.createHash('sha256');
-      let actualCount = 0;
-      let actualSourceCount = 0;
-      let actualLastKey = '';
-      for await (const record of readback.records) {
-        if (!isName(record.model) || !isName(record.id) || !object(record.value)
-          || record.value.id !== record.id) fail('Rehearsal readback returned an invalid record.');
-        const key = recordKey(record.model, record.id);
-        if (key <= actualLastKey) fail('Rehearsal readback order changed.');
-        actualLastKey = key;
-        actualRecordHash.update(canonicalJson(record) + '\n'); actualCount++;
-      }
-      for await (const source of readback.sources) {
-        if (source.kind !== 'source' || !isHash(source.sourceDigest)
-          || hash(source.bytes) !== source.sourceDigest) fail('Rehearsal source readback changed.');
-        actualSourceHash.update(canonicalJson({ ...source,
-          bytes: Buffer.from(source.bytes).toString('base64url') }) + '\n');
-        actualSourceCount++;
-      }
-      const expectedRecordDigest = expectedRecordHash.digest('hex');
-      const expectedSourceDigest = expectedSourceHash.digest('hex');
-      if (actualCount !== expectedCount || actualSourceCount !== expectedSourceCount
-        || actualRecordHash.digest('hex') !== expectedRecordDigest
-        || actualSourceHash.digest('hex') !== expectedSourceDigest) {
-        fail('Isolated restore readback differs from expected safe state.');
-      }
-      rehearsalDigest = hash(JSON.stringify([expectedRecordDigest, expectedSourceDigest]));
-    } catch (error) {
-      verificationFailure = error;
-    }
-    let closeFailure: unknown;
-    // A matching postimage is not a receipt while the isolated owner still has a live database or child.
-    try { await readback.close(); } catch (error) { closeFailure = error; }
-    if (verificationFailure && closeFailure) {
-      throw new AggregateError([verificationFailure, closeFailure],
-        'Restore rehearsal verification and cleanup both failed.');
-    }
-    if (verificationFailure) throw verificationFailure;
-    if (closeFailure) throw closeFailure;
-    if (!rehearsalDigest) fail('Restore rehearsal did not produce an exact postimage digest.');
-    return { backupId: manifest.backupId, manifestPath: input.manifestPath,
-      manifestDigest: input.manifestDigest, snapshotDigest: manifest.snapshotDigest, sourceEpoch: manifest.epoch,
-      sourceRevision: manifest.revision, restoredEpoch, recordCount: manifest.recordCount,
-      sources: manifest.sources, rehearsalDigest, verifiedAt: new Date().toISOString(),
-      restoreAdmission: 'closed_pending_codex_and_native_reconciliation' };
-  }
-
-  private async restoreRecord(record: IAuthorityBackupRecord, secret: string | null,
-    restoredEpoch: string): Promise<IAuthorityRestoredRecord | null> {
-    const value = record.value;
-    if (!object(value)) fail('Invalid stored backup record.');
-    assertSnapshotRecord(record);
-    if (record.model === 'authswitch_authority_events') return null;
-    if (record.model === 'authswitch_authority_usage') return null;
-    if (record.model === 'authswitch_authority_meta') {
-      assertStoredAuthorityMeta(value);
-      const restored: IStoredAuthorityMeta = { ...value, admission: 'closed_restored',
-        epoch: restoredEpoch, revision: 0, updateId: uuid() };
-      return { ...record, value: restored };
-    }
-    if (record.model === 'authswitch_authority_grants') {
-      assertStoredAuthorityGrant(value);
-      if ((value.ciphertext !== null) !== (secret !== null)) fail('Grant recovery payload is incomplete.');
-      if (value.state === 'removed') return record;
-      const native = ['claude_host_native', 'opencode_native'].includes(value.purpose);
-      const restored: IStoredAuthorityGrant = { ...value,
-        state: native ? 'legacy_native_pending' : 'needs_reauth',
-        owner: native ? 'legacy_native' : 'daemon', ciphertext: null, accessExpiresAt: null,
-        attemptId: null, retryAt: null, retryCount: 0,
-        problem: native ? 'native_owner' : 'exchange_uncertain',
-        grantGeneration: value.grantGeneration + 1,
-        authorizationGeneration: value.authorizationGeneration + 1,
-        revision: value.revision + 1, statusObservedAt: new Date().toISOString(), updateId: uuid() };
-      assertStoredAuthorityGrant(restored);
-      return { ...record, value: restored };
-    }
-    if (record.model === 'authswitch_authority_bindings') {
-      assertStoredAuthorityBinding(value);
-      const restored: IStoredAuthorityBinding = { ...value,
-        capabilityHash: hash(plugins.crypto.randomBytes(32)), revision: value.revision + 1,
-        updateId: uuid() };
-      return { ...record, value: restored };
-    }
-    if (record.model === 'authswitch_authority_enrollments') {
-      assertStoredAuthorityEnrollment(value);
-      if (secret === null) fail('Enrollment recovery payload is missing.');
-      const plaintext = Buffer.from(secret, 'base64url');
-      try {
-        const row = parseEnrollment(plaintext, value.id);
-        const sealed = await this.options.secrets.seal(value.id, plaintext);
-        const opened = await this.options.secrets.unseal(value.id, sealed);
-        try {
-          if (Buffer.compare(Buffer.from(opened), plaintext) !== 0) fail('Destination enrollment reseal did not verify.');
-        } finally { opened.fill(0); }
-        const restored: IStoredAuthorityEnrollment = { ...value, ciphertext: sealed,
-          revision: value.revision + 1, updateId: uuid() };
-        assertStoredAuthorityEnrollment(restored);
-        if (authorityEnrollmentId(row) !== restored.id) fail('Enrollment changed during destination reseal.');
-        return { ...record, value: restored };
-      } finally { plaintext.fill(0); }
-    }
-    if (record.model === 'authswitch_authority_codex_homes') {
-      assertStoredAuthorityCodexHome(value);
-      const restored: IStoredAuthorityCodexHome = { ...value, activeRun: null, updateId: uuid() };
-      return { ...record, value: restored };
-    }
-    if (record.model === 'authswitch_authority_claude_homes') {
-      const restored = { ...value, status: 'quarantined', pendingOperationId: uuid(),
-        revision: Number(value.revision) + 1, updateId: uuid() };
-      assertStoredAuthorityClaudeHome(restored);
-      return { ...record, value: restored };
-    }
-    if (record.model === 'authswitch_authority_claude_handoffs') {
-      const restored = { ...value, phase: 'quarantined',
-        problem: 'native_uncertain', sealedOutgoing: null,
-        revision: Number(value.revision) + 1, updateId: uuid() };
-      assertStoredAuthorityClaudeHandoff(restored);
-      return { ...record, value: restored };
-    }
-    if (record.model === 'authswitch_authority_handoffs') {
-      const restored = { ...value, phase: 'needs_reauth',
-        backupDigest: null, verifiedSourceDigest: null,
-        revision: Number(value.revision) + 1, updateId: uuid() };
-      assertStoredAuthorityHandoff(restored);
-      return { ...record, value: restored };
-    }
-    if (record.model === 'authswitch_authority_migration_ledger') {
-      const restored = { ...value, status: 'prepared', backupDigest: null,
-        revision: Number(value.revision) + 1, updateId: uuid() };
-      assertStoredAuthorityMigrationLedger(restored);
-      return { ...record, value: restored };
-    }
-    if (record.model === 'authswitch_authority_operations') {
-      if (secret !== null) fail('Unexpected executable secret in backup operation.');
-      assertStoredAuthorityOperation(value);
-      const restored = restoreStoredAuthorityOperation(value,
-        { restoredAt: new Date().toISOString(), updateId: uuid() });
-      return restored === value ? record : { ...record, value: restored };
-    }
-    if (secret !== null) fail('Unexpected executable secret in backup record.');
-    return record;
-  }
-}