agl 1.0.17 → 21.0.2

package/dist_ts/classes.authstore.js

@@ -0,0 +1,2483 @@
+import * as plugins from './plugins.js';
+import { EmbeddedControllerDatabase } from './classes.embeddeddb.js';
+import { AuthError, } from './interfaces.auth.js';
+import { ControllerAuditEventModel, ControllerAuthModel, ControllerProjectModel, ControllerResourceModel, ControllerSessionGroupsModel, ControllerSessionStateModel, ControllerSettingsModel, ControllerTempPasswordModel, isProjectRelativePathName, WebAuthnCeremonyModel, controllerSessionStateId, } from './classes.authmodels.js';
+import { controllerProjectLimit, controllerResourceLimit, controllerResourcesPerProjectLimit, } from './interfaces.projects.js';
+import { controllerRuntimeIdKey } from '../dist_ts_interfaces/index.js';
+import { PostDatabaseDocumentMigrationRunner, } from '../dist_ts_migration/classes.documentmigrationrunner.js';
+import { filesystemIdentitiesEqual } from './functions.canonicaldirectory.js';
+// The audit log is write-only telemetry with no reader; retention keeps the
+// embedded engine's working set bounded. This is load-bearing on smartdb:
+// the engine resolves indexed lookups and unique checks by scanning, so
+// per-operation cost grows linearly with collection size — a hard count cap
+// keeps every scan trivially small. Deletes run in limit-bounded id batches
+// because broad deleteMany filters can exceed smartdb's per-operation
+// materialization capacity on large collections.
+const auditRetentionMs = 7 * 24 * 60 * 60 * 1000;
+const auditRetentionMaxEvents = 2_000;
+const auditRetentionCountSlack = 500;
+const auditPruneBatchSize = 1000;
+const auditPruneMaxBatchesPerSweep = 50;
+// The count cap must be able to clear a large pre-existing backlog in one
+// sweep; each batch is a bounded id page, so this stays cheap per round trip.
+const auditCountPruneMaxBatchesPerSweep = 250;
+const auditPruneIntervalMs = 30 * 60 * 1000;
+const setupLifetimeMs = 30 * 60 * 1000;
+// CLI-minted temporary passwords: a debugging credential, deliberately capped.
+const tempPasswordTtlMinMs = 60 * 1000;
+const tempPasswordTtlMaxMs = 24 * 60 * 60 * 1000;
+const maxActiveTempPasswords = 8;
+const tempPasswordPattern = /^[A-Za-z0-9_-]{32}$/;
+const sessionModelChoiceClearTransitionMaxAttempts = 16;
+// Operator-provided codes are allowed, so the accepted shape is any printable
+// non-whitespace ASCII within DoS-safe length bounds; only the hash is stored.
+const setupCodePattern = /^[\x21-\x7e]{4,256}$/;
+const ceremonyIdPattern = /^[A-Za-z0-9_-]{43}$/;
+const randomAuthorityValue = () => plugins.crypto.randomBytes(32).toString('base64url');
+const randomResourceId = () => plugins.crypto.randomBytes(16).toString('base64url');
+const randomResourceOperationId = () => plugins.crypto.randomBytes(16).toString('base64url');
+const cloneSessionId = (sessionIdArg) => (sessionIdArg === null ? null : { ...sessionIdArg });
+const isSessionId = (valueArg) => valueArg.harnessId === 'opencode' || valueArg.harnessId === 'flex';
+const cloneResourceDocument = (resourceArg) => ({
+    ...resourceArg,
+    sessionId: cloneSessionId(resourceArg.sessionId),
+    ...(resourceArg.pendingAttachment === undefined ? {} : {
+        pendingAttachment: {
+            ...resourceArg.pendingAttachment,
+            sessionId: cloneSessionId(resourceArg.pendingAttachment.sessionId),
+        },
+    }),
+    ...(resourceArg.terminal === undefined ? {} : { terminal: { ...resourceArg.terminal } }),
+});
+const cloneModelChoice = (modelArg) => (modelArg.harnessId === 'opencode'
+    ? {
+        harnessId: 'opencode',
+        providerID: modelArg.providerID,
+        modelID: modelArg.modelID,
+        ...(modelArg.variant === undefined ? {} : { variant: modelArg.variant }),
+    }
+    : {
+        harnessId: 'flex',
+        providerConnectionId: modelArg.providerConnectionId,
+        providerID: modelArg.providerID,
+        modelID: modelArg.modelID,
+        ...(modelArg.variant === undefined ? {} : { variant: modelArg.variant }),
+    });
+export const assertProvidedSetupCode = (setupCodeArg) => {
+    if (typeof setupCodeArg !== 'string' || !setupCodePattern.test(setupCodeArg)) {
+        throw new Error('A setup code must be 4-256 printable non-whitespace ASCII characters.');
+    }
+    return setupCodeArg;
+};
+const cloneRuntimeConfig = (runtimeConfigArg) => ({
+    controllerPort: runtimeConfigArg.controllerPort,
+    publicOrigin: runtimeConfigArg.publicOrigin,
+    rpId: runtimeConfigArg.rpId,
+    workspaceDirectory: runtimeConfigArg.workspaceDirectory,
+    // The key must be absent, not undefined-valued, for exact persistence.
+    ...(runtimeConfigArg.projectsRoot !== undefined
+        ? { projectsRoot: runtimeConfigArg.projectsRoot }
+        : {}),
+    opencodePort: runtimeConfigArg.opencodePort,
+    tlsMode: runtimeConfigArg.tlsMode,
+});
+const runtimeConfigsEqual = (leftArg, rightArg) => leftArg.controllerPort === rightArg.controllerPort
+    && leftArg.publicOrigin === rightArg.publicOrigin
+    && leftArg.rpId === rightArg.rpId
+    && leftArg.workspaceDirectory === rightArg.workspaceDirectory
+    && leftArg.projectsRoot === rightArg.projectsRoot
+    && leftArg.opencodePort === rightArg.opencodePort
+    && leftArg.tlsMode === rightArg.tlsMode;
+const hashSetupCode = (setupCodeArg) => plugins.crypto.createHash('sha256').update(setupCodeArg, 'utf8').digest('base64url');
+const hashesEqual = (leftArg, rightArg) => {
+    const left = Buffer.from(leftArg, 'base64url');
+    const right = Buffer.from(rightArg, 'base64url');
+    return left.byteLength === right.byteLength && plugins.crypto.timingSafeEqual(left, right);
+};
+const requireSafeCounter = (counterArg, labelArg) => {
+    if (!Number.isSafeInteger(counterArg) || counterArg < 0) {
+        throw new AuthError('counter_conflict', `${labelArg} must be a non-negative safe integer.`);
+    }
+};
+const requireCeremonyKind = (kindArg) => {
+    if (kindArg !== 'setup' && kindArg !== 'authentication') {
+        throw new AuthError('ceremony_invalid', 'The WebAuthn ceremony kind is invalid.');
+    }
+    return kindArg;
+};
+const requireCeremonyId = (ceremonyIdArg) => {
+    if (typeof ceremonyIdArg !== 'string' || !ceremonyIdPattern.test(ceremonyIdArg)) {
+        throw new AuthError('ceremony_invalid', 'The WebAuthn ceremony identifier is invalid.');
+    }
+    return ceremonyIdArg;
+};
+const requirePeerId = (peerIdArg) => {
+    if (typeof peerIdArg !== 'string'
+        || peerIdArg.length === 0
+        || peerIdArg.length > 512
+        || peerIdArg.trim() !== peerIdArg) {
+        throw new AuthError('peer_mismatch', 'The connection identity is malformed.');
+    }
+    return peerIdArg;
+};
+const requireOrigin = (originArg) => {
+    if (typeof originArg !== 'string' || originArg.length === 0 || originArg.length > 2048) {
+        throw new AuthError('origin_mismatch', 'The ceremony origin is malformed.');
+    }
+    try {
+        const origin = new URL(originArg);
+        if (origin.origin !== originArg
+            || (origin.protocol !== 'http:' && origin.protocol !== 'https:')
+            || origin.username.length > 0
+            || origin.password.length > 0
+            || origin.pathname !== '/'
+            || origin.search.length > 0
+            || origin.hash.length > 0) {
+            throw new Error('not an origin');
+        }
+    }
+    catch {
+        throw new AuthError('origin_mismatch', 'The ceremony origin is malformed.');
+    }
+    return originArg;
+};
+const rpIdPattern = /^(?=.{1,253}$)[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+const requireRpId = (rpIdArg) => {
+    if (typeof rpIdArg !== 'string' || !rpIdPattern.test(rpIdArg)) {
+        throw new AuthError('ceremony_invalid', 'The ceremony RP ID is malformed.');
+    }
+    return rpIdArg;
+};
+const requireUserId = (userIdArg) => {
+    if (typeof userIdArg !== 'string' || !ceremonyIdPattern.test(userIdArg)) {
+        throw new AuthError('ceremony_invalid', 'The ceremony user identifier is malformed.');
+    }
+    return userIdArg;
+};
+const requireValidDate = (dateArg, labelArg) => {
+    if (!(dateArg instanceof Date) || !Number.isFinite(dateArg.getTime())) {
+        throw new AuthError('ceremony_invalid', `${labelArg} must be a valid date.`);
+    }
+    return new Date(dateArg);
+};
+const isAmbiguousWrite = (errorArg) => errorArg instanceof plugins.smartdata.SmartdataExactPersistenceError
+    && errorArg.code === 'ambiguous_write';
+const sessionStateRecoveryLimit = 500;
+const sessionStateRetirementPageLimit = 100;
+const maxSessionStateRetirementPages = 100;
+const maxSessionStateExchanges = 8;
+const maxSessionStateExchangeBytes = 256 * 1024;
+const toPublicIntelligenceExchange = (exchangeArg) => ({
+    id: exchangeArg.id,
+    question: exchangeArg.question,
+    status: exchangeArg.status,
+    ...(exchangeArg.answer === undefined ? {} : { answer: exchangeArg.answer }),
+    ...(exchangeArg.error === undefined ? {} : { error: exchangeArg.error }),
+    ...(exchangeArg.model === undefined ? {} : { model: exchangeArg.model }),
+    ...(exchangeArg.scratchpadConflict === undefined
+        ? {}
+        : { scratchpadConflict: exchangeArg.scratchpadConflict }),
+    createdAt: exchangeArg.createdAt.getTime(),
+    ...(exchangeArg.completedAt === undefined
+        ? {}
+        : { completedAt: exchangeArg.completedAt.getTime() }),
+});
+const toPublicSessionState = (documentArg) => ({
+    scratchpad: {
+        id: documentArg.id,
+        text: documentArg.scratchpad.text,
+        revision: documentArg.scratchpad.revision,
+        ...(documentArg.scratchpad.updatedAt === undefined
+            ? {}
+            : { updatedAt: documentArg.scratchpad.updatedAt.getTime() }),
+        ...(documentArg.scratchpad.updatedBy === undefined
+            ? {}
+            : { updatedBy: documentArg.scratchpad.updatedBy }),
+    },
+    intelligenceExchanges: documentArg.intelligenceExchanges.map(toPublicIntelligenceExchange),
+    ...(documentArg.modelChoice === undefined
+        ? {}
+        : { modelChoice: cloneModelChoice(documentArg.modelChoice) }),
+});
+const trimSessionStateExchanges = (exchangesArg, protectedExchangeIdArg) => {
+    const exchanges = exchangesArg.slice(-maxSessionStateExchanges);
+    while (exchanges.length > 1
+        && Buffer.byteLength(JSON.stringify(exchanges), 'utf8') > maxSessionStateExchangeBytes) {
+        const removableIndex = exchanges.findIndex((exchange) => exchange.id !== protectedExchangeIdArg && exchange.status !== 'running');
+        if (removableIndex < 0)
+            break;
+        exchanges.splice(removableIndex, 1);
+    }
+    return exchanges;
+};
+const projectManagementStoreKey = (projectIdArg, sessionIdArg) => JSON.stringify([projectIdArg, sessionIdArg]);
+const cloneProjectManagementRecord = (recordArg) => structuredClone(recordArg);
+const sameProjectManagementGeneration = (leftArg, rightArg) => leftArg.sessionGenerationId === rightArg.sessionGenerationId
+    && leftArg.sessionGenerationSequence === rightArg.sessionGenerationSequence;
+const canInitializeProjectManagementGeneration = (currentArg, nextArg, expectedRevisionArg) => Object.hasOwn(currentArg, 'deletedAt')
+    && expectedRevisionArg === 0
+    && nextArg.sessionGenerationId !== currentArg.sessionGenerationId
+    && nextArg.sessionGenerationSequence > currentArg.sessionGenerationSequence;
+const assertFlexSessionGeneration = (generationArg) => {
+    if (!generationArg
+        || typeof generationArg.sessionGenerationId !== 'string'
+        || generationArg.sessionGenerationId.trim().length === 0
+        || Buffer.byteLength(generationArg.sessionGenerationId, 'utf8')
+            > plugins.flexharness.FLEX_SESSION_GENERATION_ID_MAX_BYTES
+        || !Number.isSafeInteger(generationArg.sessionGenerationSequence)
+        || generationArg.sessionGenerationSequence < 1) {
+        throw new plugins.flexharness.FlexHarnessStoreFormatError('The Flex project-management session generation is invalid.');
+    }
+};
+const assertProjectManagementWriteContext = (writeContextArg) => {
+    if (!writeContextArg
+        || typeof writeContextArg !== 'object'
+        || Array.isArray(writeContextArg)
+        || ![Object.prototype, null].includes(Object.getPrototypeOf(writeContextArg))
+        || Object.keys(writeContextArg).some((key) => !['actor', 'runId', 'agent', 'toolCallId'].includes(key))
+        || (writeContextArg.actor !== 'agent' && writeContextArg.actor !== 'application')
+        || ['runId', 'agent', 'toolCallId'].some((key) => {
+            const value = writeContextArg[key];
+            return value !== undefined && (typeof value !== 'string' || value.trim().length === 0);
+        })) {
+        throw new plugins.flexharness.FlexHarnessStoreFormatError('The Flex project-management write context is invalid.');
+    }
+};
+const assertProjectManagementNextRevision = (recordArg, expectedRevisionArg) => {
+    if (!Number.isSafeInteger(expectedRevisionArg) || expectedRevisionArg < 0) {
+        throw new plugins.flexharness.FlexHarnessStoreFormatError('The expected Flex project-management revision is invalid.');
+    }
+    if (recordArg.revision !== expectedRevisionArg + 1) {
+        throw new plugins.flexharness.FlexHarnessStoreFormatError('The Flex project-management revision must advance by exactly one.');
+    }
+};
+const projectManagementUpdater = (writeContextArg) => writeContextArg.actor;
+export const assertControllerResourceCreationCapacity = (projectResourceCountArg, controllerResourceCountArg) => {
+    if (controllerResourceCountArg >= controllerResourceLimit) {
+        throw new AuthError('invalid_resource', `The controller supports at most ${controllerResourceLimit} resources.`);
+    }
+    if (projectResourceCountArg >= controllerResourcesPerProjectLimit) {
+        throw new AuthError('invalid_resource', `A project supports at most ${controllerResourcesPerProjectLimit} resources.`);
+    }
+};
+export class SmartDataAuthStore {
+    options;
+    database;
+    embeddedDatabase;
+    // smartdata resolves the manager's db lazily per operation, so the
+    // manager can be registered before init() constructs the database.
+    smartDataManager;
+    initialized = false;
+    initPromise;
+    controllerId;
+    resolvedMongoDbUrl;
+    closePromise;
+    closeStarted = false;
+    projectMutationAdmissionOpen = false;
+    projectMutationTail = Promise.resolve();
+    sessionStateMutationTail = Promise.resolve();
+    auditPruneTimer;
+    runSessionStateMutation(operationArg) {
+        if (this.closeStarted) {
+            return Promise.reject(new AuthError('not_initialized', 'The authentication store is shutting down.'));
+        }
+        const result = this.sessionStateMutationTail.then(operationArg);
+        this.sessionStateMutationTail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    constructor(options) {
+        this.options = options;
+        const hasExternalUrl = typeof options.mongoDbUrl === 'string'
+            && options.mongoDbUrl.trim().length > 0;
+        const hasEmbeddedDirectory = typeof options.embeddedDataDirectory === 'string'
+            && plugins.path.isAbsolute(options.embeddedDataDirectory);
+        if (!hasExternalUrl && !hasEmbeddedDirectory) {
+            throw new Error('Either mongoDbUrl or an absolute embeddedDataDirectory must be provided.');
+        }
+        if (!/^[A-Za-z0-9_-]{1,63}$/.test(options.mongoDbName)) {
+            throw new Error('mongoDbName must use 1-63 letters, digits, underscores, or dashes.');
+        }
+        const storeSelf = this;
+        this.smartDataManager = {
+            get db() {
+                return storeSelf.db;
+            },
+        };
+        plugins.smartdata.setDefaultManagerForDoc(this.smartDataManager, ControllerAuthModel);
+        plugins.smartdata.setDefaultManagerForDoc(this.smartDataManager, WebAuthnCeremonyModel);
+        plugins.smartdata.setDefaultManagerForDoc(this.smartDataManager, ControllerAuditEventModel);
+        plugins.smartdata.setDefaultManagerForDoc(this.smartDataManager, ControllerProjectModel);
+        plugins.smartdata.setDefaultManagerForDoc(this.smartDataManager, ControllerResourceModel);
+        plugins.smartdata.setDefaultManagerForDoc(this.smartDataManager, ControllerSettingsModel);
+        plugins.smartdata.setDefaultManagerForDoc(this.smartDataManager, ControllerTempPasswordModel);
+        plugins.smartdata.setDefaultManagerForDoc(this.smartDataManager, ControllerSessionGroupsModel);
+        plugins.smartdata.setDefaultManagerForDoc(this.smartDataManager, ControllerSessionStateModel);
+    }
+    get db() {
+        if (!this.database) {
+            throw new Error('The auth store database has not been initialized.');
+        }
+        return this.database;
+    }
+    async init() {
+        if (this.closeStarted) {
+            throw new Error('SmartDataAuthStore cannot initialize after shutdown has begun.');
+        }
+        if (this.initialized)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        if (this.database || this.embeddedDatabase) {
+            throw new Error('SmartData cleanup must complete before initialization can be retried.');
+        }
+        const initPromise = this.initOnce();
+        this.initPromise = initPromise;
+        try {
+            await initPromise;
+        }
+        finally {
+            if (this.initPromise === initPromise)
+                this.initPromise = undefined;
+        }
+    }
+    async initOnce() {
+        try {
+            let mongoDbUrl = this.options.mongoDbUrl?.trim();
+            if (!mongoDbUrl) {
+                const embedded = new EmbeddedControllerDatabase({
+                    dataDirectory: this.options.embeddedDataDirectory,
+                    legacyDataDirectory: this.options.legacyEmbeddedDataDirectory,
+                });
+                this.embeddedDatabase = embedded;
+                mongoDbUrl = await embedded.start();
+            }
+            this.database = new plugins.smartdata.SmartdataDb({
+                mongoDbUrl,
+                mongoDbName: this.options.mongoDbName,
+            });
+            this.resolvedMongoDbUrl = mongoDbUrl;
+            await this.db.init();
+            await ControllerAuthModel.init();
+            await WebAuthnCeremonyModel.init();
+            await ControllerAuditEventModel.init();
+            await ControllerProjectModel.init();
+            await ControllerResourceModel.init();
+            await ControllerSettingsModel.init();
+            await ControllerTempPasswordModel.init();
+            await ControllerSessionGroupsModel.init();
+            await ControllerSessionStateModel.init();
+            await new PostDatabaseDocumentMigrationRunner(this.database).run();
+            this.initialized = true;
+            if (!this.closeStarted)
+                this.projectMutationAdmissionOpen = true;
+        }
+        catch (errorArg) {
+            const cleanupErrors = [];
+            if (this.database) {
+                try {
+                    await this.database.close();
+                    this.database = undefined;
+                    this.resolvedMongoDbUrl = undefined;
+                }
+                catch (closeErrorArg) {
+                    cleanupErrors.push(closeErrorArg);
+                }
+            }
+            try {
+                await this.stopEmbeddedDatabase();
+            }
+            catch (stopErrorArg) {
+                cleanupErrors.push(stopErrorArg);
+            }
+            if (cleanupErrors.length > 0) {
+                throw new AggregateError([errorArg, ...cleanupErrors], 'SmartData initialization failed and cleanup was incomplete.', { cause: errorArg });
+            }
+            throw errorArg;
+        }
+        // Retention is maintenance and must never gate readiness: clearing a
+        // large pre-existing backlog takes far longer than the controller's
+        // startup budget, so the first sweep runs detached like every later one.
+        void this.pruneAuditHistory();
+        this.auditPruneTimer = setInterval(() => {
+            void this.pruneAuditHistory();
+        }, auditPruneIntervalMs);
+        this.auditPruneTimer.unref?.();
+    }
+    async pruneAuditHistory() {
+        try {
+            const collection = ControllerAuditEventModel.collection.mongoDbCollection;
+            // Count cap first: it bounds the collection regardless of event rate,
+            // which the age rule alone cannot (heavy days produce tens of
+            // thousands of events).
+            const count = await collection.estimatedDocumentCount();
+            if (count > auditRetentionMaxEvents + auditRetentionCountSlack) {
+                // One bounded batch per round trip: a sorted find whose limit is the
+                // full excess exceeds the engine's per-operation materialization
+                // ceiling once the backlog is large (which is exactly when this
+                // runs). Re-reading the oldest page after each delete converges.
+                let remaining = count - auditRetentionMaxEvents;
+                for (let batch = 0; batch < auditCountPruneMaxBatchesPerSweep && remaining > 0; batch++) {
+                    const pageSize = Math.min(auditPruneBatchSize, remaining);
+                    const excess = await collection
+                        .find({}, { projection: { _id: 1 } })
+                        .sort({ timestamp: 1 })
+                        .limit(pageSize)
+                        .toArray();
+                    if (excess.length === 0)
+                        break;
+                    await collection.deleteMany({ _id: { $in: excess.map((doc) => doc._id) } });
+                    remaining -= excess.length;
+                }
+            }
+            const cutoffIso = new Date(Date.now() - auditRetentionMs).toISOString();
+            for (let batch = 0; batch < auditPruneMaxBatchesPerSweep; batch++) {
+                const expired = await collection
+                    .find({ timestamp: { $lt: cutoffIso } }, { projection: { _id: 1 } })
+                    .limit(auditPruneBatchSize)
+                    .toArray();
+                if (expired.length === 0)
+                    return;
+                await collection.deleteMany({ _id: { $in: expired.map((doc) => doc._id) } });
+                if (expired.length < auditPruneBatchSize)
+                    return;
+            }
+        }
+        catch (errorArg) {
+            // Retention is maintenance; it must never take the controller down.
+            console.error('Audit history pruning failed.', errorArg);
+        }
+    }
+    async stopEmbeddedDatabase() {
+        const embedded = this.embeddedDatabase;
+        if (embedded) {
+            await embedded.stop();
+            if (this.embeddedDatabase === embedded)
+                this.embeddedDatabase = undefined;
+        }
+    }
+    async close() {
+        this.closeStarted = true;
+        this.projectMutationAdmissionOpen = false;
+        if (this.closePromise)
+            return this.closePromise;
+        const closePromise = (async () => {
+            if (this.initPromise)
+                await this.initPromise.catch(() => undefined);
+            await this.projectMutationTail;
+            await this.sessionStateMutationTail;
+            if (!this.database && !this.embeddedDatabase)
+                return;
+            if (this.auditPruneTimer) {
+                clearInterval(this.auditPruneTimer);
+                this.auditPruneTimer = undefined;
+            }
+            const cleanupErrors = [];
+            if (this.database) {
+                try {
+                    await this.database.close();
+                    this.database = undefined;
+                    this.resolvedMongoDbUrl = undefined;
+                }
+                catch (errorArg) {
+                    cleanupErrors.push(errorArg);
+                }
+            }
+            try {
+                await this.stopEmbeddedDatabase();
+            }
+            catch (errorArg) {
+                cleanupErrors.push(errorArg);
+            }
+            if (cleanupErrors.length === 1)
+                throw cleanupErrors[0];
+            if (cleanupErrors.length > 1) {
+                throw new AggregateError(cleanupErrors, 'SmartData shutdown was incomplete.');
+            }
+        })();
+        this.closePromise = closePromise;
+        try {
+            await closePromise;
+            this.initialized = false;
+        }
+        finally {
+            if (this.closePromise === closePromise)
+                this.closePromise = undefined;
+        }
+    }
+    async getRuntimeConfig(controllerPortArg) {
+        this.assertInitialized();
+        if (!Number.isSafeInteger(controllerPortArg)
+            || controllerPortArg < 1
+            || controllerPortArg > 65535) {
+            throw new Error('controllerPort must be an integer between 1 and 65535.');
+        }
+        this.controllerId = `controller:${controllerPortArg}`;
+        const stored = await ControllerAuthModel.exact.findStoredOne({ id: this.controllerId });
+        if (!stored)
+            return undefined;
+        return cloneRuntimeConfig(ControllerAuthModel.exact.toPersisted(stored).config);
+    }
+    /** Process-private connection data for the isolated Flex child and projection reader. */
+    getDatabaseDescriptor() {
+        this.assertInitialized();
+        if (!this.resolvedMongoDbUrl) {
+            throw new AuthError('not_initialized', 'The controller database connection is unavailable.');
+        }
+        return {
+            mongoDbUrl: this.resolvedMongoDbUrl,
+            mongoDbName: this.options.mongoDbName,
+        };
+    }
+    async resolveOrCreateRuntimeConfig(runtimeConfigArg) {
+        this.assertInitialized();
+        if (!Number.isSafeInteger(runtimeConfigArg.controllerPort)
+            || runtimeConfigArg.controllerPort < 1
+            || runtimeConfigArg.controllerPort > 65535) {
+            throw new Error('controllerPort must be an integer between 1 and 65535.');
+        }
+        const controllerId = `controller:${runtimeConfigArg.controllerPort}`;
+        this.controllerId = controllerId;
+        const existing = await ControllerAuthModel.exact.findStoredOne({ id: controllerId });
+        if (existing) {
+            const document = ControllerAuthModel.exact.toPersisted(existing);
+            if (document.config.projectsRoot === undefined
+                && runtimeConfigArg.projectsRoot !== undefined) {
+                // One-time v2 upgrade: adopt the resolved projects root into the
+                // stored document; every other field must still match exactly.
+                this.assertRuntimeConfigMatches({ ...document.config, projectsRoot: runtimeConfigArg.projectsRoot }, runtimeConfigArg);
+                const upgraded = cloneRuntimeConfig(runtimeConfigArg);
+                const result = await ControllerAuthModel.exact.transition({
+                    current: existing,
+                    change: (model) => {
+                        model.config = upgraded;
+                    },
+                });
+                if (result.status === 'transitioned') {
+                    return this.finalizeRuntimeConfigDocument(ControllerAuthModel.exact.toPersisted(result.document), runtimeConfigArg);
+                }
+                const reconciled = await ControllerAuthModel.exact.findStoredOne({ id: controllerId });
+                if (!reconciled) {
+                    throw new AuthError('ambiguous_write', 'Controller runtime configuration upgrade has an ambiguous outcome.');
+                }
+                const reconciledDocument = ControllerAuthModel.exact.toPersisted(reconciled);
+                return this.finalizeRuntimeConfigDocument(reconciledDocument, runtimeConfigArg);
+            }
+            return this.finalizeRuntimeConfigDocument(document, runtimeConfigArg);
+        }
+        const candidate = {
+            id: controllerId,
+            config: cloneRuntimeConfig(runtimeConfigArg),
+            authState: 'setupRequired',
+            setup: null,
+            webauthnUserId: randomAuthorityValue(),
+            credentials: [],
+        };
+        try {
+            const insertResult = await ControllerAuthModel.exact.insert(candidate);
+            const document = ControllerAuthModel.exact.toPersisted(insertResult.document);
+            return this.finalizeRuntimeConfigDocument(document, runtimeConfigArg);
+        }
+        catch (errorArg) {
+            if (!isAmbiguousWrite(errorArg))
+                throw errorArg;
+            const reconciled = await ControllerAuthModel.exact.findStoredOne({ id: controllerId });
+            if (!reconciled) {
+                throw new AuthError('ambiguous_write', 'Controller authentication initialization has an ambiguous outcome.', { cause: errorArg });
+            }
+            const document = ControllerAuthModel.exact.toPersisted(reconciled);
+            return this.finalizeRuntimeConfigDocument(document, runtimeConfigArg);
+        }
+    }
+    async finalizeRuntimeConfigDocument(documentArg, runtimeConfigArg) {
+        this.assertRuntimeConfigMatches(documentArg.config, runtimeConfigArg);
+        await new PostDatabaseDocumentMigrationRunner(this.database)
+            .runProjectFilesystemIdentity(documentArg.id);
+        return documentArg;
+    }
+    async rotateSetupAuthority(providedCodeArg) {
+        const current = await this.findStoredState();
+        const currentBody = ControllerAuthModel.exact.toPersisted(current);
+        if (currentBody.credentials.length > 0)
+            return null;
+        const setupCode = providedCodeArg === undefined
+            ? randomAuthorityValue()
+            : assertProvidedSetupCode(providedCodeArg);
+        const setupHash = hashSetupCode(setupCode);
+        const generation = randomAuthorityValue();
+        const expiresAt = new Date(Date.now() + setupLifetimeMs);
+        try {
+            const result = await ControllerAuthModel.exact.transition({
+                current,
+                change: (model) => {
+                    model.authState = 'setupRequired';
+                    model.setup = {
+                        generation,
+                        hash: setupHash,
+                        expiresAt,
+                    };
+                },
+            });
+            if (result.status !== 'transitioned') {
+                throw new AuthError('concurrent_change', 'Setup authority changed concurrently and was not rotated.');
+            }
+            return { setupCode, generation, expiresAt: new Date(expiresAt) };
+        }
+        catch (errorArg) {
+            if (!isAmbiguousWrite(errorArg))
+                throw errorArg;
+            const reconciled = await this.findStoredState();
+            const document = ControllerAuthModel.exact.toPersisted(reconciled);
+            if (document.setup?.generation === generation
+                && document.setup.hash === setupHash
+                && document.setup.expiresAt.getTime() === expiresAt.getTime()) {
+                return { setupCode, generation, expiresAt: new Date(expiresAt) };
+            }
+            throw new AuthError('ambiguous_write', 'Setup authority rotation has an ambiguous outcome.', { cause: errorArg });
+        }
+    }
+    async getState() {
+        const stored = await this.findStoredState();
+        return ControllerAuthModel.exact.toPersisted(stored);
+    }
+    async assertSetupAuthority(setupCodeArg, ceremonyArg, nowArg = new Date()) {
+        if (typeof setupCodeArg !== 'string'
+            || setupCodeArg.length > 256
+            || !setupCodePattern.test(setupCodeArg)) {
+            throw new AuthError('setup_invalid', 'The setup code is invalid or expired.');
+        }
+        if (!(nowArg instanceof Date) || !Number.isFinite(nowArg.getTime())) {
+            throw new AuthError('setup_invalid', 'The setup validation time is malformed.');
+        }
+        const state = await this.getState();
+        if (state.credentials.length > 0 || state.authState !== 'setupRequired' || !state.setup) {
+            throw new AuthError('setup_unavailable', 'Passkey setup is no longer available.');
+        }
+        if (state.setup.expiresAt.getTime() <= nowArg.getTime()) {
+            throw new AuthError('setup_expired', 'The setup code is invalid or expired.');
+        }
+        if (ceremonyArg
+            && (ceremonyArg.setupGeneration !== state.setup.generation
+                || ceremonyArg.setupHash !== state.setup.hash)) {
+            throw new AuthError('setup_invalid', 'The setup code is invalid or expired.');
+        }
+        const candidateHash = hashSetupCode(setupCodeArg);
+        if (!hashesEqual(candidateHash, state.setup.hash)) {
+            throw new AuthError('setup_invalid', 'The setup code is invalid or expired.');
+        }
+        return state;
+    }
+    async countActiveCeremonies(kindArg, nowArg) {
+        this.assertInitialized();
+        const kind = requireCeremonyKind(kindArg);
+        const now = requireValidDate(nowArg, 'Ceremony count time');
+        return WebAuthnCeremonyModel.exact.count({
+            kind,
+            state: 'pending',
+            expiresAt: { $gt: now },
+        });
+    }
+    async createCeremony(ceremonyArg) {
+        this.assertInitialized();
+        if (ceremonyArg.state !== 'pending') {
+            throw new AuthError('ceremony_invalid', 'A new WebAuthn ceremony must be pending.');
+        }
+        const result = await WebAuthnCeremonyModel.exact.insert(ceremonyArg);
+        if (result.status === 'conflict') {
+            throw new AuthError('ceremony_invalid', 'The WebAuthn ceremony identifier already exists.');
+        }
+        return WebAuthnCeremonyModel.exact.toPersisted(result.document);
+    }
+    async consumeCeremony(optionsArg) {
+        const { current, body, now } = await this.findPendingCeremony(optionsArg);
+        const consumedAt = now;
+        const consumedNonce = randomAuthorityValue();
+        try {
+            const result = await WebAuthnCeremonyModel.exact.transition({
+                current,
+                change: (model) => {
+                    model.state = 'consumed';
+                    model.consumedAt = consumedAt;
+                    model.consumedNonce = consumedNonce;
+                },
+            });
+            if (result.status !== 'transitioned') {
+                throw new AuthError('ceremony_replayed', 'The WebAuthn ceremony was already consumed.');
+            }
+            return WebAuthnCeremonyModel.exact.toPersisted(result.document);
+        }
+        catch (errorArg) {
+            if (!isAmbiguousWrite(errorArg))
+                throw errorArg;
+            const reconciled = await WebAuthnCeremonyModel.exact.findStoredOne({
+                id: body.id,
+            });
+            if (reconciled) {
+                const document = WebAuthnCeremonyModel.exact.toPersisted(reconciled);
+                if (document.state === 'consumed' && document.consumedNonce === consumedNonce) {
+                    return document;
+                }
+            }
+            throw new AuthError('ambiguous_write', 'WebAuthn ceremony consumption has an ambiguous outcome.', { cause: errorArg });
+        }
+    }
+    async assertPendingCeremony(optionsArg) {
+        const { body } = await this.findPendingCeremony(optionsArg);
+        return body;
+    }
+    async findPendingCeremony(optionsArg) {
+        this.assertInitialized();
+        const ceremonyId = requireCeremonyId(optionsArg.ceremonyId);
+        const kind = requireCeremonyKind(optionsArg.kind);
+        const peerId = requirePeerId(optionsArg.peerId);
+        const origin = requireOrigin(optionsArg.origin);
+        const rpId = requireRpId(optionsArg.rpId);
+        const userId = requireUserId(optionsArg.userId);
+        const now = requireValidDate(optionsArg.now, 'Ceremony validation time');
+        const current = await WebAuthnCeremonyModel.exact.findStoredOne({ id: ceremonyId });
+        if (optionsArg.ceremonyId !== ceremonyId
+            || optionsArg.kind !== kind
+            || optionsArg.peerId !== peerId
+            || optionsArg.origin !== origin
+            || optionsArg.rpId !== rpId
+            || optionsArg.userId !== userId
+            || !(optionsArg.now instanceof Date)
+            || optionsArg.now.getTime() !== now.getTime()) {
+            throw new AuthError('ceremony_invalid', 'The WebAuthn ceremony validation authority changed during lookup.');
+        }
+        if (!current)
+            throw new AuthError('ceremony_invalid', 'The WebAuthn ceremony is invalid.');
+        const body = WebAuthnCeremonyModel.exact.toPersisted(current);
+        if (body.kind !== kind) {
+            throw new AuthError('ceremony_invalid', 'The WebAuthn ceremony has the wrong kind.');
+        }
+        if (body.peerId !== peerId) {
+            throw new AuthError('peer_mismatch', 'The WebAuthn ceremony belongs to another connection.');
+        }
+        if (body.origin !== origin) {
+            throw new AuthError('origin_mismatch', 'The WebAuthn ceremony origin changed.');
+        }
+        if (body.rpId !== rpId || body.userId !== userId) {
+            throw new AuthError('ceremony_invalid', 'The WebAuthn ceremony authority changed.');
+        }
+        if (body.expiresAt.getTime() <= now.getTime()) {
+            throw new AuthError('ceremony_expired', 'The WebAuthn ceremony expired.');
+        }
+        if (body.state !== 'pending') {
+            throw new AuthError('ceremony_replayed', 'The WebAuthn ceremony was already consumed.');
+        }
+        return { current, body, now };
+    }
+    async commitFirstCredential(ceremonyArg, credentialArg) {
+        if (ceremonyArg.state !== 'consumed') {
+            throw new AuthError('ceremony_invalid', 'The setup ceremony has not been consumed.');
+        }
+        const current = await this.findStoredState();
+        const body = ControllerAuthModel.exact.toPersisted(current);
+        if (body.credentials.length > 0 || body.authState !== 'setupRequired' || !body.setup) {
+            throw new AuthError('concurrent_change', 'Another passkey won first enrollment.');
+        }
+        if (body.webauthnUserId !== ceremonyArg.userId
+            || body.config.publicOrigin !== ceremonyArg.origin
+            || body.config.rpId !== ceremonyArg.rpId
+            || body.setup.generation !== ceremonyArg.setupGeneration
+            || body.setup.hash !== ceremonyArg.setupHash) {
+            throw new AuthError('concurrent_change', 'Setup authority changed before enrollment.');
+        }
+        try {
+            const result = await ControllerAuthModel.exact.transition({
+                current,
+                change: (model) => {
+                    model.authState = 'ready';
+                    model.setup = null;
+                    model.credentials = [structuredClone(credentialArg)];
+                },
+            });
+            if (result.status !== 'transitioned') {
+                throw new AuthError('concurrent_change', 'Another passkey won first enrollment.');
+            }
+            return ControllerAuthModel.exact.toPersisted(result.document);
+        }
+        catch (errorArg) {
+            if (!isAmbiguousWrite(errorArg))
+                throw errorArg;
+            const reconciled = await this.findStoredState();
+            const document = ControllerAuthModel.exact.toPersisted(reconciled);
+            if (document.credentials.length === 1
+                && document.credentials[0].id === credentialArg.id
+                && document.credentials[0].counterUpdateId === credentialArg.counterUpdateId
+                && document.authState === 'ready'
+                && document.setup === null) {
+                return document;
+            }
+            throw new AuthError('ambiguous_write', 'First passkey enrollment has an ambiguous outcome.', { cause: errorArg });
+        }
+    }
+    async updateCounter(credentialIdArg, expectedCounterArg, newCounterArg) {
+        if (typeof credentialIdArg !== 'string' || credentialIdArg.length === 0) {
+            throw new AuthError('credential_not_found', 'The passkey credential is malformed.');
+        }
+        requireSafeCounter(expectedCounterArg, 'expectedCounter');
+        requireSafeCounter(newCounterArg, 'newCounter');
+        const current = await this.findStoredState();
+        const body = ControllerAuthModel.exact.toPersisted(current);
+        const credentialIndex = body.credentials.findIndex((credential) => credential.id === credentialIdArg);
+        if (credentialIndex < 0) {
+            throw new AuthError('credential_not_found', 'The passkey credential is unknown.');
+        }
+        const credential = body.credentials[credentialIndex];
+        if (credential.counter !== expectedCounterArg) {
+            throw new AuthError('counter_conflict', 'The passkey counter changed concurrently.');
+        }
+        if ((expectedCounterArg === 0 && newCounterArg !== 0 && newCounterArg <= expectedCounterArg)
+            || (expectedCounterArg > 0 && newCounterArg <= expectedCounterArg)) {
+            throw new AuthError('counter_conflict', 'The passkey counter did not advance.');
+        }
+        const counterUpdateId = randomAuthorityValue();
+        try {
+            const result = await ControllerAuthModel.exact.transition({
+                current,
+                change: (model) => {
+                    model.credentials = model.credentials.map((entry) => entry.id === credentialIdArg
+                        ? { ...entry, counter: newCounterArg, counterUpdateId }
+                        : entry);
+                },
+            });
+            if (result.status !== 'transitioned') {
+                throw new AuthError('counter_conflict', 'The passkey counter changed concurrently.');
+            }
+            const document = ControllerAuthModel.exact.toPersisted(result.document);
+            return document.credentials.find((entry) => entry.id === credentialIdArg);
+        }
+        catch (errorArg) {
+            if (!isAmbiguousWrite(errorArg))
+                throw errorArg;
+            const reconciled = await this.findStoredState();
+            const document = ControllerAuthModel.exact.toPersisted(reconciled);
+            const credentialAfter = document.credentials.find((entry) => entry.id === credentialIdArg);
+            if (credentialAfter?.counter === newCounterArg
+                && credentialAfter.counterUpdateId === counterUpdateId) {
+                return credentialAfter;
+            }
+            throw new AuthError('ambiguous_write', 'Passkey counter update has an ambiguous outcome.', { cause: errorArg });
+        }
+    }
+    async recordAuditEvent(eventArg) {
+        this.assertInitialized();
+        if (!this.controllerId) {
+            throw new AuthError('not_initialized', 'The controller runtime configuration is unresolved.');
+        }
+        const event = {
+            id: randomAuthorityValue(),
+            controllerId: this.controllerId,
+            timestamp: eventArg.timestamp === undefined
+                ? new Date()
+                : new Date(eventArg.timestamp),
+            type: eventArg.type,
+            outcome: eventArg.outcome,
+            ...(eventArg.operationId === undefined ? {} : { operationId: eventArg.operationId }),
+            ...(eventArg.peerId === undefined ? {} : { peerId: eventArg.peerId }),
+            ...(eventArg.credentialId === undefined ? {} : { credentialId: eventArg.credentialId }),
+            ...(eventArg.sessionId === undefined ? {} : { sessionId: { ...eventArg.sessionId } }),
+            ...(eventArg.requestId === undefined ? {} : { requestId: { ...eventArg.requestId } }),
+        };
+        try {
+            const result = await ControllerAuditEventModel.exact.insert(event);
+            if (result.status === 'conflict') {
+                throw new AuthError('concurrent_change', 'The audit event identifier conflicts.');
+            }
+            return ControllerAuditEventModel.exact.toPersisted(result.document);
+        }
+        catch (errorArg) {
+            if (!isAmbiguousWrite(errorArg))
+                throw errorArg;
+            const reconciled = await ControllerAuditEventModel.exact.findStoredOne({ id: event.id });
+            if (reconciled) {
+                const document = ControllerAuditEventModel.exact.toPersisted(reconciled);
+                if (this.auditEventsEqual(document, event))
+                    return document;
+            }
+            throw new AuthError('ambiguous_write', 'Audit event persistence has an ambiguous outcome.', { cause: errorArg });
+        }
+    }
+    assertInitialized() {
+        if (!this.initialized) {
+            throw new AuthError('not_initialized', 'The authentication store is not initialized.');
+        }
+    }
+    async findStoredState() {
+        this.assertInitialized();
+        if (!this.controllerId) {
+            throw new AuthError('not_initialized', 'The controller runtime configuration is unresolved.');
+        }
+        const stored = await ControllerAuthModel.exact.findStoredOne({ id: this.controllerId });
+        if (!stored) {
+            throw new AuthError('not_initialized', 'The controller authentication document is missing.');
+        }
+        return stored;
+    }
+    requireControllerId() {
+        if (!this.controllerId) {
+            throw new AuthError('not_initialized', 'The controller identity has not been resolved yet.');
+        }
+        return this.controllerId;
+    }
+    async listProjects() {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        const stored = await ControllerProjectModel.exact.findStored({
+            filter: {
+                controllerId,
+                removalStartedAt: { $exists: false },
+                removedAt: { $exists: false },
+            },
+            sort: { createdAt: 1 },
+            limit: controllerProjectLimit + 1,
+        });
+        if (stored.length > controllerProjectLimit) {
+            throw new AuthError('invalid_project', `The controller exceeds the ${controllerProjectLimit}-project limit.`);
+        }
+        return stored.map((entry) => ControllerProjectModel.exact.toPersisted(entry));
+    }
+    async createProject(nameArg, directoryArg, identityArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        if (!isProjectRelativePathName(nameArg)) {
+            throw new AuthError('invalid_project', 'Project names must be directory paths without dot navigation.');
+        }
+        if (typeof directoryArg !== 'string' || !plugins.path.isAbsolute(directoryArg)) {
+            throw new AuthError('invalid_project', 'The project directory must be an absolute path.');
+        }
+        return this.withProjectMutation(async () => {
+            const activeProjects = await this.listProjects();
+            const existing = activeProjects.find((entry) => entry.directory === directoryArg);
+            if (existing) {
+                if (existing.directoryIdentityState !== 'bound'
+                    || existing.directoryIdentity === undefined
+                    || !filesystemIdentitiesEqual(existing.directoryIdentity, identityArg)) {
+                    throw new AuthError('concurrent_change', 'The registered project path has a different filesystem identity.');
+                }
+                return { project: existing, created: false };
+            }
+            const pendingRemovals = await this.listPendingProjectRemovals();
+            if (activeProjects.length + pendingRemovals.length >= controllerProjectLimit) {
+                throw new AuthError('invalid_project', `The controller supports at most ${controllerProjectLimit} active or pending-removal projects.`);
+            }
+            if (pendingRemovals.some((entry) => (entry.directory === directoryArg || entry.name === nameArg))) {
+                throw new AuthError('concurrent_change', 'The project path is still being removed and cannot be registered again.');
+            }
+            if (activeProjects.some((entry) => entry.name === nameArg)) {
+                throw new AuthError('invalid_project', 'A project with this name already exists.');
+            }
+            const candidate = {
+                id: plugins.crypto.randomBytes(16).toString('base64url'),
+                controllerId,
+                name: nameArg,
+                directory: directoryArg,
+                directoryIdentityState: 'bound',
+                directoryIdentity: structuredClone(identityArg),
+                createdAt: new Date(),
+            };
+            const result = await ControllerProjectModel.exact.insert(candidate);
+            if (result.status === 'conflict') {
+                throw new AuthError('concurrent_change', 'The project was created concurrently.');
+            }
+            return { project: ControllerProjectModel.exact.toPersisted(result.document), created: true };
+        });
+    }
+    async removeProject(projectIdArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        if (typeof projectIdArg !== 'string' || projectIdArg.length === 0 || projectIdArg.length > 64) {
+            throw new AuthError('invalid_project', 'The project identifier is malformed.');
+        }
+        return this.withProjectMutation(async () => {
+            const stored = await ControllerProjectModel.exact.findStoredOne({ id: projectIdArg });
+            if (!stored)
+                return false;
+            const document = ControllerProjectModel.exact.toPersisted(stored);
+            if (document.controllerId !== controllerId
+                || document.removedAt !== undefined
+                || document.removalStartedAt === undefined) {
+                return false;
+            }
+            const result = await ControllerProjectModel.exact.transition({
+                current: stored,
+                change: (model) => {
+                    delete model.removalStartedAt;
+                    model.removedAt = new Date();
+                },
+            });
+            if (result.status !== 'transitioned') {
+                throw new AuthError('concurrent_change', 'The project changed concurrently and was not removed.');
+            }
+            return true;
+        });
+    }
+    async beginProjectRemoval(projectIdArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        if (typeof projectIdArg !== 'string' || projectIdArg.length === 0 || projectIdArg.length > 64) {
+            throw new AuthError('invalid_project', 'The project identifier is malformed.');
+        }
+        return this.withProjectMutation(async () => {
+            const stored = await ControllerProjectModel.exact.findStoredOne({ id: projectIdArg });
+            if (!stored)
+                return undefined;
+            const document = ControllerProjectModel.exact.toPersisted(stored);
+            if (document.controllerId !== controllerId || document.removedAt !== undefined)
+                return undefined;
+            if (document.removalStartedAt !== undefined)
+                return document;
+            const result = await ControllerProjectModel.exact.transition({
+                current: stored,
+                change: (model) => {
+                    model.removalStartedAt = new Date();
+                },
+            });
+            if (result.status !== 'transitioned') {
+                throw new AuthError('concurrent_change', 'The project changed concurrently and was not retired.');
+            }
+            return ControllerProjectModel.exact.toPersisted(result.document);
+        });
+    }
+    async listPendingProjectRemovals() {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        const stored = await ControllerProjectModel.exact.findStored({
+            filter: {
+                controllerId,
+                removalStartedAt: { $exists: true },
+                removedAt: { $exists: false },
+            },
+            sort: { removalStartedAt: 1 },
+            limit: controllerProjectLimit + 1,
+        });
+        if (stored.length > controllerProjectLimit) {
+            throw new AuthError('invalid_project', 'The pending project-removal limit was exceeded.');
+        }
+        return stored.map((entry) => ControllerProjectModel.exact.toPersisted(entry));
+    }
+    withProjectMutation(operationArg) {
+        if (!this.projectMutationAdmissionOpen) {
+            return Promise.reject(new AuthError('not_initialized', 'Project mutations are unavailable while the authentication store is closing.'));
+        }
+        const operation = this.projectMutationTail.then(async () => {
+            if (!this.projectMutationAdmissionOpen) {
+                throw new AuthError('not_initialized', 'Project mutations are unavailable while the authentication store is closing.');
+            }
+            return operationArg();
+        });
+        this.projectMutationTail = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async insertResourceDocument(candidateArg) {
+        try {
+            const result = await ControllerResourceModel.exact.insert(candidateArg);
+            if (result.status === 'conflict') {
+                throw new AuthError('concurrent_change', 'The resource identifier conflicted.');
+            }
+            return cloneResourceDocument(ControllerResourceModel.exact.toPersisted(result.document));
+        }
+        catch (errorArg) {
+            if (!isAmbiguousWrite(errorArg))
+                throw errorArg;
+            const reconciled = await ControllerResourceModel.exact.findStoredOne({ id: candidateArg.id });
+            if (reconciled) {
+                const document = ControllerResourceModel.exact.toPersisted(reconciled);
+                if (document.updateId === candidateArg.updateId)
+                    return cloneResourceDocument(document);
+            }
+            throw new AuthError('ambiguous_write', 'The resource insertion has an ambiguous outcome.', { cause: errorArg });
+        }
+    }
+    async transitionResourceDocument(currentArg, changeArg, concurrentMessageArg, ambiguousMessageArg) {
+        const current = ControllerResourceModel.exact.toPersisted(currentArg);
+        const updateId = randomAuthorityValue();
+        try {
+            const result = await ControllerResourceModel.exact.transition({
+                current: currentArg,
+                change: (model) => {
+                    changeArg(model);
+                    model.updateId = updateId;
+                },
+            });
+            if (result.status !== 'transitioned') {
+                throw new AuthError('concurrent_change', concurrentMessageArg);
+            }
+            return cloneResourceDocument(ControllerResourceModel.exact.toPersisted(result.document));
+        }
+        catch (errorArg) {
+            if (!isAmbiguousWrite(errorArg))
+                throw errorArg;
+            const reconciled = await ControllerResourceModel.exact.findStoredOne({ id: current.id });
+            if (reconciled) {
+                const document = ControllerResourceModel.exact.toPersisted(reconciled);
+                if (document.updateId === updateId)
+                    return cloneResourceDocument(document);
+            }
+            throw new AuthError('ambiguous_write', ambiguousMessageArg, { cause: errorArg });
+        }
+    }
+    async getProject(projectIdArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        if (typeof projectIdArg !== 'string' || projectIdArg.length === 0 || projectIdArg.length > 64) {
+            return undefined;
+        }
+        const stored = await ControllerProjectModel.exact.findStoredOne({ id: projectIdArg });
+        if (!stored)
+            return undefined;
+        const document = ControllerProjectModel.exact.toPersisted(stored);
+        if (document.controllerId !== controllerId
+            || document.removalStartedAt !== undefined
+            || document.removedAt !== undefined) {
+            return undefined;
+        }
+        return document;
+    }
+    async getPendingProjectRemoval(projectIdArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        if (typeof projectIdArg !== 'string' || projectIdArg.length === 0 || projectIdArg.length > 64) {
+            return undefined;
+        }
+        const stored = await ControllerProjectModel.exact.findStoredOne({ id: projectIdArg });
+        if (!stored)
+            return undefined;
+        const document = ControllerProjectModel.exact.toPersisted(stored);
+        if (document.controllerId !== controllerId
+            || document.removalStartedAt === undefined
+            || document.removedAt !== undefined)
+            return undefined;
+        return document;
+    }
+    async listResources(projectIdArg, optionsArg = {}) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        const stored = await ControllerResourceModel.exact.findStored({
+            filter: {
+                controllerId,
+                projectId: projectIdArg,
+                ...(optionsArg.includeRetired ? {} : { retiredAt: { $exists: false } }),
+            },
+            sort: { createdAt: 1 },
+            limit: controllerResourcesPerProjectLimit + 1,
+        });
+        if (stored.length > controllerResourcesPerProjectLimit) {
+            throw new AuthError('invalid_resource', `The project exceeds the ${controllerResourcesPerProjectLimit}-resource limit.`);
+        }
+        return stored.map((entry) => cloneResourceDocument(ControllerResourceModel.exact.toPersisted(entry)));
+    }
+    async listRecoverableResources() {
+        this.assertInitialized();
+        const stored = await ControllerResourceModel.exact.findStored({
+            filter: {
+                controllerId: this.requireControllerId(),
+                retiredAt: { $exists: false },
+            },
+            sort: { createdAt: 1 },
+            limit: controllerResourceLimit + 1,
+        });
+        if (stored.length > controllerResourceLimit) {
+            throw new AuthError('invalid_resource', 'The controller resource limit was exceeded.');
+        }
+        return stored.map((entry) => cloneResourceDocument(ControllerResourceModel.exact.toPersisted(entry)));
+    }
+    async getResource(projectIdArg, resourceIdArg, optionsArg = {}) {
+        this.assertInitialized();
+        const stored = await ControllerResourceModel.exact.findStoredOne({ id: resourceIdArg });
+        if (!stored)
+            return undefined;
+        const resource = ControllerResourceModel.exact.toPersisted(stored);
+        if (resource.controllerId !== this.requireControllerId()
+            || resource.projectId !== projectIdArg
+            || (!optionsArg.includeRetired && resource.lifecycle === 'retired'))
+            return undefined;
+        return cloneResourceDocument(resource);
+    }
+    async createResource(inputArg) {
+        this.assertInitialized();
+        return this.withProjectMutation(async () => {
+            const project = await this.getProject(inputArg.projectId);
+            if (!project)
+                throw new AuthError('invalid_project', 'The resource project is unavailable.');
+            const [existing, recoverable] = await Promise.all([
+                this.listResources(inputArg.projectId),
+                this.listRecoverableResources(),
+            ]);
+            assertControllerResourceCreationCapacity(existing.length, recoverable.length);
+            const now = new Date();
+            const candidate = {
+                id: randomResourceId(),
+                controllerId: this.requireControllerId(),
+                projectId: inputArg.projectId,
+                kind: inputArg.kind,
+                title: inputArg.title,
+                attachmentAuthorityId: randomAuthorityValue(),
+                attachmentRevision: 0,
+                sessionId: null,
+                lifecycle: 'active',
+                ...(inputArg.terminal === undefined ? {} : { terminal: { ...inputArg.terminal } }),
+                createdAt: now,
+                updatedAt: now,
+                updateId: randomAuthorityValue(),
+            };
+            return this.insertResourceDocument(candidate);
+        });
+    }
+    async renameResource(projectIdArg, resourceIdArg, titleArg) {
+        const current = await ControllerResourceModel.exact.findStoredOne({ id: resourceIdArg });
+        if (!current)
+            throw new AuthError('invalid_resource', 'The resource does not exist.');
+        const before = ControllerResourceModel.exact.toPersisted(current);
+        if (before.controllerId !== this.requireControllerId()
+            || before.projectId !== projectIdArg
+            || before.lifecycle !== 'active')
+            throw new AuthError('invalid_resource', 'The resource is unavailable.');
+        return this.transitionResourceDocument(current, (model) => {
+            model.title = titleArg;
+            model.updatedAt = new Date();
+        }, 'The resource changed concurrently.', 'The resource rename has an ambiguous outcome.');
+    }
+    async beginResourceAttachmentTransition(projectIdArg, resourceIdArg, sessionIdArg, expectedAttachmentRevisionArg) {
+        if (!Number.isSafeInteger(expectedAttachmentRevisionArg) || expectedAttachmentRevisionArg < 0) {
+            throw new AuthError('invalid_resource', 'The expected attachment revision is malformed.');
+        }
+        const current = await ControllerResourceModel.exact.findStoredOne({ id: resourceIdArg });
+        if (!current)
+            throw new AuthError('invalid_resource', 'The resource does not exist.');
+        const before = ControllerResourceModel.exact.toPersisted(current);
+        if (before.controllerId !== this.requireControllerId()
+            || before.projectId !== projectIdArg
+            || before.lifecycle !== 'active')
+            throw new AuthError('invalid_resource', 'The resource is unavailable.');
+        if (before.pendingAttachment) {
+            throw new AuthError('concurrent_change', 'The resource attachment is already changing.');
+        }
+        if (before.attachmentRevision !== expectedAttachmentRevisionArg) {
+            throw new AuthError('concurrent_change', 'The resource attachment changed concurrently.');
+        }
+        const operationId = randomResourceOperationId();
+        return this.transitionResourceDocument(current, (model) => {
+            model.pendingAttachment = {
+                operationId,
+                attachmentRevision: before.attachmentRevision + 1,
+                sessionId: cloneSessionId(sessionIdArg),
+                requestedAt: new Date(),
+            };
+            model.updatedAt = new Date();
+        }, 'The resource attachment changed concurrently.', 'Preparing the resource attachment has an ambiguous outcome.');
+    }
+    async commitResourceAttachmentTransition(projectIdArg, resourceIdArg, operationIdArg) {
+        const current = await ControllerResourceModel.exact.findStoredOne({ id: resourceIdArg });
+        if (!current)
+            throw new AuthError('invalid_resource', 'The resource does not exist.');
+        const before = ControllerResourceModel.exact.toPersisted(current);
+        if (before.controllerId !== this.requireControllerId()
+            || before.projectId !== projectIdArg
+            || before.lifecycle !== 'active'
+            || before.pendingAttachment?.operationId !== operationIdArg)
+            throw new AuthError('concurrent_change', 'The pending resource attachment no longer matches.');
+        const pending = before.pendingAttachment;
+        return this.transitionResourceDocument(current, (model) => {
+            model.attachmentRevision = pending.attachmentRevision;
+            model.sessionId = cloneSessionId(pending.sessionId);
+            delete model.pendingAttachment;
+            model.updatedAt = new Date();
+        }, 'The resource attachment changed concurrently.', 'Committing the resource attachment has an ambiguous outcome.');
+    }
+    async beginResourceRetirement(projectIdArg, resourceIdArg) {
+        const current = await ControllerResourceModel.exact.findStoredOne({ id: resourceIdArg });
+        if (!current)
+            throw new AuthError('invalid_resource', 'The resource does not exist.');
+        const before = ControllerResourceModel.exact.toPersisted(current);
+        if (before.controllerId !== this.requireControllerId() || before.projectId !== projectIdArg) {
+            throw new AuthError('invalid_resource', 'The resource is unavailable.');
+        }
+        if (before.lifecycle !== 'active')
+            return cloneResourceDocument(before);
+        if (before.pendingAttachment) {
+            throw new AuthError('concurrent_change', 'The resource attachment must settle before retirement.');
+        }
+        const now = new Date();
+        return this.transitionResourceDocument(current, (model) => {
+            model.lifecycle = 'retiring';
+            model.retiringAt = now;
+            model.updatedAt = now;
+        }, 'The resource changed concurrently.', 'Preparing resource retirement has an ambiguous outcome.');
+    }
+    async completeResourceRetirement(projectIdArg, resourceIdArg) {
+        const current = await ControllerResourceModel.exact.findStoredOne({ id: resourceIdArg });
+        if (!current)
+            throw new AuthError('invalid_resource', 'The resource does not exist.');
+        const before = ControllerResourceModel.exact.toPersisted(current);
+        if (before.controllerId !== this.requireControllerId() || before.projectId !== projectIdArg) {
+            throw new AuthError('invalid_resource', 'The resource is unavailable.');
+        }
+        if (before.lifecycle === 'retired')
+            return cloneResourceDocument(before);
+        if (before.lifecycle !== 'retiring') {
+            throw new AuthError('concurrent_change', 'The resource is not retiring.');
+        }
+        const now = new Date();
+        return this.transitionResourceDocument(current, (model) => {
+            model.lifecycle = 'retired';
+            model.retiredAt = now;
+            model.updatedAt = now;
+        }, 'The resource changed concurrently.', 'Completing resource retirement has an ambiguous outcome.');
+    }
+    async markTerminalResourceStopped(projectIdArg, resourceIdArg, outcomeArg = {}) {
+        const current = await ControllerResourceModel.exact.findStoredOne({ id: resourceIdArg });
+        if (!current)
+            throw new AuthError('invalid_resource', 'The terminal resource does not exist.');
+        const before = ControllerResourceModel.exact.toPersisted(current);
+        if (before.controllerId !== this.requireControllerId()
+            || before.projectId !== projectIdArg
+            || before.kind !== 'terminal'
+            || !before.terminal
+            || before.lifecycle === 'retired')
+            throw new AuthError('invalid_resource', 'The terminal resource is unavailable.');
+        const stoppedAt = outcomeArg.stoppedAt ?? new Date();
+        return this.transitionResourceDocument(current, (model) => {
+            model.terminal = {
+                command: before.terminal.command,
+                args: [...before.terminal.args],
+                cwd: before.terminal.cwd,
+                stoppedAt,
+                ...(outcomeArg.lastExitCode === undefined ? {} : { lastExitCode: outcomeArg.lastExitCode }),
+            };
+            model.updatedAt = stoppedAt;
+        }, 'The terminal resource changed concurrently.', 'Persisting the stopped terminal resource has an ambiguous outcome.');
+    }
+    async markTerminalResourceRunning(projectIdArg, resourceIdArg) {
+        const current = await ControllerResourceModel.exact.findStoredOne({ id: resourceIdArg });
+        if (!current)
+            throw new AuthError('invalid_resource', 'The terminal resource does not exist.');
+        const before = ControllerResourceModel.exact.toPersisted(current);
+        if (before.controllerId !== this.requireControllerId()
+            || before.projectId !== projectIdArg
+            || before.kind !== 'terminal'
+            || !before.terminal
+            || before.lifecycle !== 'active')
+            throw new AuthError('invalid_resource', 'The terminal resource is unavailable.');
+        const now = new Date();
+        return this.transitionResourceDocument(current, (model) => {
+            model.terminal = {
+                command: before.terminal.command,
+                args: [...before.terminal.args],
+                cwd: before.terminal.cwd,
+            };
+            model.updatedAt = now;
+        }, 'The terminal resource changed concurrently.', 'Persisting the running terminal resource has an ambiguous outcome.');
+    }
+    async getSettings() {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        const stored = await ControllerSettingsModel.exact.findStoredOne({
+            id: `${controllerId}:settings`,
+        });
+        if (stored) {
+            const persisted = ControllerSettingsModel.exact.toPersisted(stored);
+            return { ...persisted, defaultModels: persisted.defaultModels.map(cloneModelChoice) };
+        }
+        return { id: `${controllerId}:settings`, controllerId, defaultModels: [] };
+    }
+    async updateSettings(patchArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        const settingsId = `${controllerId}:settings`;
+        const defaultModelsUpdate = patchArg.defaultModels === undefined
+            ? undefined
+            : patchArg.defaultModels.map(cloneModelChoice);
+        const applyPatch = (targetArg) => {
+            if (defaultModelsUpdate !== undefined) {
+                targetArg.defaultModels = defaultModelsUpdate;
+            }
+            if (patchArg.autoAcceptPermissions !== undefined) {
+                if (patchArg.autoAcceptPermissions) {
+                    targetArg.autoAcceptPermissions = true;
+                }
+                else {
+                    // Disabled is an absent key; undefined values are dropped on write.
+                    delete targetArg.autoAcceptPermissions;
+                }
+            }
+            if (patchArg.selectedOpenCodeProviderConnectionId !== undefined) {
+                if (patchArg.selectedOpenCodeProviderConnectionId === null) {
+                    delete targetArg.selectedOpenCodeProviderConnectionId;
+                }
+                else {
+                    targetArg.selectedOpenCodeProviderConnectionId = patchArg.selectedOpenCodeProviderConnectionId;
+                }
+            }
+        };
+        const stored = await ControllerSettingsModel.exact.findStoredOne({ id: settingsId });
+        if (!stored) {
+            const candidate = {
+                id: settingsId,
+                controllerId,
+                defaultModels: [],
+            };
+            applyPatch(candidate);
+            const insertResult = await ControllerSettingsModel.exact.insert(candidate);
+            if (insertResult.status !== 'conflict') {
+                return ControllerSettingsModel.exact.toPersisted(insertResult.document);
+            }
+            // fall through to transition against the concurrently created document
+        }
+        const current = stored ?? await ControllerSettingsModel.exact.findStoredOne({ id: settingsId });
+        if (!current) {
+            throw new AuthError('ambiguous_write', 'The settings document has an ambiguous state.');
+        }
+        const result = await ControllerSettingsModel.exact.transition({
+            current,
+            change: (model) => {
+                applyPatch(model);
+            },
+        });
+        if (result.status !== 'transitioned') {
+            throw new AuthError('concurrent_change', 'The settings changed concurrently and were not updated.');
+        }
+        const persisted = ControllerSettingsModel.exact.toPersisted(result.document);
+        return { ...persisted, defaultModels: persisted.defaultModels.map(cloneModelChoice) };
+    }
+    async getSessionLayout(projectIdArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        const stored = await ControllerSessionGroupsModel.exact.findStoredOne({
+            id: `${controllerId}:groups:${projectIdArg}`,
+        });
+        if (!stored)
+            return { groups: [], ungroupedSessionIds: [], revision: 0 };
+        const persisted = ControllerSessionGroupsModel.exact.toPersisted(stored);
+        return {
+            groups: persisted.groups.map((group) => ({
+                ...group,
+                sessionIds: group.sessionIds.filter(isSessionId).map((sessionId) => ({ ...sessionId })),
+            })),
+            ungroupedSessionIds: (persisted.ungroupedSessionIds ?? []).filter(isSessionId).map((sessionId) => ({ ...sessionId })),
+            revision: persisted.revision ?? 0,
+        };
+    }
+    async updateSessionLayout(projectIdArg, groupsArg, ungroupedSessionIdsArg, expectedRevisionArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        const documentId = `${controllerId}:groups:${projectIdArg}`;
+        const stored = await ControllerSessionGroupsModel.exact.findStoredOne({ id: documentId });
+        const groups = groupsArg.map((group) => ({
+            id: group.id,
+            name: group.name,
+            sessionIds: group.sessionIds.map((sessionId) => ({ ...sessionId })),
+        }));
+        const groupedSessionIds = new Set(groups.flatMap((group) => group.sessionIds.map(controllerRuntimeIdKey)));
+        const storedPersisted = stored
+            ? ControllerSessionGroupsModel.exact.toPersisted(stored)
+            : undefined;
+        const storedRevision = storedPersisted?.revision ?? 0;
+        if (expectedRevisionArg !== undefined && expectedRevisionArg !== storedRevision) {
+            throw new AuthError('concurrent_change', 'The session layout changed in another client.');
+        }
+        const persistedUngroupedIds = storedPersisted?.ungroupedSessionIds ?? [];
+        const ungroupedSessionIds = ungroupedSessionIdsArg === undefined
+            ? persistedUngroupedIds.filter((sessionId) => !groupedSessionIds.has(controllerRuntimeIdKey(sessionId)))
+            : ungroupedSessionIdsArg.map((sessionId) => ({ ...sessionId }));
+        const candidate = {
+            id: documentId,
+            controllerId,
+            projectId: projectIdArg,
+            groups,
+            ungroupedSessionIds,
+            revision: storedRevision + 1,
+        };
+        if (!stored) {
+            const insertResult = await ControllerSessionGroupsModel.exact.insert(candidate);
+            if (insertResult.status !== 'conflict') {
+                return { groups, ungroupedSessionIds: ungroupedSessionIds.filter(isSessionId), revision: candidate.revision };
+            }
+            if (expectedRevisionArg !== undefined) {
+                throw new AuthError('concurrent_change', 'The session layout changed in another client.');
+            }
+            // A legacy client did not supply a revision, so preserve its prior
+            // last-write behavior against the concurrently created document.
+        }
+        const current = stored ?? await ControllerSessionGroupsModel.exact.findStoredOne({ id: documentId });
+        if (!current) {
+            throw new AuthError('ambiguous_write', 'The session groups document has an ambiguous state.');
+        }
+        const currentPersisted = ControllerSessionGroupsModel.exact.toPersisted(current);
+        const currentRevision = currentPersisted.revision ?? 0;
+        if (expectedRevisionArg !== undefined && expectedRevisionArg !== currentRevision) {
+            throw new AuthError('concurrent_change', 'The session layout changed in another client.');
+        }
+        const transitionUngroupedSessionIds = ungroupedSessionIdsArg === undefined
+            ? (currentPersisted.ungroupedSessionIds ?? []).filter((sessionId) => !groupedSessionIds.has(controllerRuntimeIdKey(sessionId)))
+            : candidate.ungroupedSessionIds;
+        const result = await ControllerSessionGroupsModel.exact.transition({
+            current,
+            change: (model) => {
+                model.groups = candidate.groups;
+                model.ungroupedSessionIds = transitionUngroupedSessionIds;
+                model.revision = currentRevision + 1;
+            },
+        });
+        if (result.status !== 'transitioned') {
+            throw new AuthError('concurrent_change', 'The session groups changed concurrently and were not updated.');
+        }
+        const persisted = ControllerSessionGroupsModel.exact.toPersisted(result.document);
+        return {
+            groups: persisted.groups.map((group) => ({
+                ...group,
+                sessionIds: group.sessionIds.filter(isSessionId),
+            })),
+            ungroupedSessionIds: (persisted.ungroupedSessionIds ?? []).filter(isSessionId),
+            revision: persisted.revision ?? 0,
+        };
+    }
+    async removeSessionFromLayout(projectIdArg, sessionIdArg) {
+        const sessionKey = controllerRuntimeIdKey(sessionIdArg);
+        return this.filterSessionLayout(projectIdArg, (sessionId) => controllerRuntimeIdKey(sessionId) !== sessionKey);
+    }
+    async pruneTerminalLayoutEntries(projectIdArg, liveTerminalIdsArg) {
+        const liveTerminalKeys = new Set(liveTerminalIdsArg.map(controllerRuntimeIdKey));
+        return this.filterSessionLayout(projectIdArg, (layoutItemId) => (layoutItemId.harnessId !== 'controller'
+            || liveTerminalKeys.has(controllerRuntimeIdKey(layoutItemId))));
+    }
+    async pruneArchivedSessionLayoutEntries(projectIdArg, archivedSessionIdsArg) {
+        const archivedSessionKeys = new Set(archivedSessionIdsArg.map(controllerRuntimeIdKey));
+        return this.filterSessionLayout(projectIdArg, (sessionId) => !archivedSessionKeys.has(controllerRuntimeIdKey(sessionId)));
+    }
+    async filterSessionLayout(projectIdArg, keepSessionArg) {
+        this.assertInitialized();
+        const documentId = `${this.requireControllerId()}:groups:${projectIdArg}`;
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const current = await ControllerSessionGroupsModel.exact.findStoredOne({ id: documentId });
+            if (!current)
+                return false;
+            const persisted = ControllerSessionGroupsModel.exact.toPersisted(current);
+            const groups = persisted.groups.map((group) => ({
+                ...group,
+                sessionIds: group.sessionIds.filter(keepSessionArg),
+            }));
+            const ungroupedSessionIds = (persisted.ungroupedSessionIds ?? []).filter(keepSessionArg);
+            const changed = groups.some((group, index) => (group.sessionIds.length !== persisted.groups[index].sessionIds.length)) || ungroupedSessionIds.length !== (persisted.ungroupedSessionIds ?? []).length;
+            if (!changed)
+                return false;
+            const result = await ControllerSessionGroupsModel.exact.transition({
+                current,
+                change: (model) => {
+                    model.groups = groups;
+                    model.ungroupedSessionIds = ungroupedSessionIds;
+                    model.revision = (persisted.revision ?? 0) + 1;
+                },
+            });
+            if (result.status === 'transitioned')
+                return true;
+        }
+        throw new AuthError('concurrent_change', 'The session layout changed concurrently and was not pruned.');
+    }
+    sessionStateIdentity(projectIdArg, sessionIdArg) {
+        const controllerId = this.requireControllerId();
+        if (typeof projectIdArg !== 'string'
+            || projectIdArg.length === 0
+            || projectIdArg.length > 64
+            || typeof sessionIdArg?.nativeId !== 'string'
+            || sessionIdArg.nativeId.length === 0
+            || Buffer.byteLength(sessionIdArg.nativeId, 'utf8') > 512
+            || (sessionIdArg.harnessId !== 'opencode' && sessionIdArg.harnessId !== 'flex')) {
+            throw new AuthError('invalid_project', 'The session-state scope is malformed.');
+        }
+        const sessionId = { ...sessionIdArg };
+        return {
+            controllerId,
+            projectId: projectIdArg,
+            sessionId,
+            id: controllerSessionStateId(controllerId, projectIdArg, sessionId),
+        };
+    }
+    createEmptySessionStateDocument(projectIdArg, sessionIdArg, updateIdArg) {
+        const identity = this.sessionStateIdentity(projectIdArg, sessionIdArg);
+        return {
+            ...identity,
+            scratchpad: { text: '', revision: 0 },
+            intelligenceExchanges: [],
+            updateId: updateIdArg,
+        };
+    }
+    async findStoredSessionState(projectIdArg, sessionIdArg) {
+        this.assertInitialized();
+        const { id } = this.sessionStateIdentity(projectIdArg, sessionIdArg);
+        return (await ControllerSessionStateModel.exact.findStoredOne({ id })) ?? undefined;
+    }
+    async insertSessionState(candidateArg) {
+        try {
+            const result = await ControllerSessionStateModel.exact.insert(candidateArg);
+            if (result.status === 'conflict') {
+                throw new AuthError('concurrent_change', 'The session state was created concurrently.');
+            }
+            return ControllerSessionStateModel.exact.toPersisted(result.document);
+        }
+        catch (errorArg) {
+            if (!isAmbiguousWrite(errorArg))
+                throw errorArg;
+            const reconciled = await ControllerSessionStateModel.exact.findStoredOne({ id: candidateArg.id });
+            if (reconciled) {
+                const document = ControllerSessionStateModel.exact.toPersisted(reconciled);
+                if (document.updateId === candidateArg.updateId)
+                    return document;
+            }
+            throw new AuthError('ambiguous_write', 'The session-state insertion has an ambiguous outcome.', { cause: errorArg });
+        }
+    }
+    async transitionSessionState(currentArg, changeArg) {
+        const currentDocument = ControllerSessionStateModel.exact.toPersisted(currentArg);
+        const updateId = randomAuthorityValue();
+        try {
+            const result = await ControllerSessionStateModel.exact.transition({
+                current: currentArg,
+                change: (model) => {
+                    changeArg(model);
+                    model.updateId = updateId;
+                },
+            });
+            if (result.status !== 'transitioned') {
+                throw new AuthError('concurrent_change', 'The session state changed concurrently.');
+            }
+            return ControllerSessionStateModel.exact.toPersisted(result.document);
+        }
+        catch (errorArg) {
+            if (!isAmbiguousWrite(errorArg))
+                throw errorArg;
+            const reconciled = await ControllerSessionStateModel.exact.findStoredOne({
+                id: currentDocument.id,
+            });
+            if (reconciled) {
+                const document = ControllerSessionStateModel.exact.toPersisted(reconciled);
+                if (document.updateId === updateId)
+                    return document;
+            }
+            throw new AuthError('ambiguous_write', 'The session-state transition has an ambiguous outcome.', { cause: errorArg });
+        }
+    }
+    async getSessionState(projectIdArg, sessionIdArg) {
+        const identity = this.sessionStateIdentity(projectIdArg, sessionIdArg);
+        const stored = await this.findStoredSessionState(projectIdArg, sessionIdArg);
+        if (!stored) {
+            return {
+                scratchpad: { id: identity.id, text: '', revision: 0 },
+                intelligenceExchanges: [],
+            };
+        }
+        return toPublicSessionState(ControllerSessionStateModel.exact.toPersisted(stored));
+    }
+    loadFlexProjectManagement(projectIdArg, sessionIdArg, sessionGenerationArg) {
+        return this.runSessionStateMutation(async () => {
+            assertFlexSessionGeneration(sessionGenerationArg);
+            const runtimeId = { harnessId: 'flex', nativeId: sessionIdArg };
+            for (let attempt = 0; attempt < 3; attempt += 1) {
+                const stored = await this.findStoredSessionState(projectIdArg, runtimeId);
+                if (!stored) {
+                    const candidate = this.createEmptySessionStateDocument(projectIdArg, runtimeId, randomAuthorityValue());
+                    const snapshot = {
+                        schemaVersion: 1,
+                        revision: 0,
+                        ...sessionGenerationArg,
+                        scratchpad: '',
+                        tasks: [],
+                    };
+                    plugins.flexharness.assertFlexProjectManagementSnapshot(snapshot);
+                    candidate.flexProjectManagement = snapshot;
+                    try {
+                        const inserted = await this.insertSessionState(candidate);
+                        return cloneProjectManagementRecord(inserted.flexProjectManagement);
+                    }
+                    catch (errorArg) {
+                        if (!(errorArg instanceof AuthError) || errorArg.code !== 'concurrent_change') {
+                            throw errorArg;
+                        }
+                        continue;
+                    }
+                }
+                const current = ControllerSessionStateModel.exact.toPersisted(stored);
+                if (current.flexProjectManagement) {
+                    return cloneProjectManagementRecord(current.flexProjectManagement);
+                }
+                if (current.deletedAt)
+                    return undefined;
+                const snapshot = {
+                    schemaVersion: 1,
+                    revision: 0,
+                    ...sessionGenerationArg,
+                    scratchpad: current.scratchpad.text,
+                    tasks: [],
+                };
+                plugins.flexharness.assertFlexProjectManagementSnapshot(snapshot);
+                try {
+                    const transitioned = await this.transitionSessionState(stored, (document) => {
+                        document.flexProjectManagement = snapshot;
+                    });
+                    return cloneProjectManagementRecord(transitioned.flexProjectManagement);
+                }
+                catch (errorArg) {
+                    if (!(errorArg instanceof AuthError) || errorArg.code !== 'concurrent_change') {
+                        throw errorArg;
+                    }
+                }
+            }
+            throw new AuthError('concurrent_change', 'The Flex project-management state remained busy during initialization.');
+        });
+    }
+    saveFlexProjectManagement(projectIdArg, sessionIdArg, snapshotArg, expectedRevisionArg, writeContextArg) {
+        return this.runSessionStateMutation(async () => {
+            plugins.flexharness.assertFlexProjectManagementSnapshot(snapshotArg);
+            assertProjectManagementNextRevision(snapshotArg, expectedRevisionArg);
+            assertProjectManagementWriteContext(writeContextArg);
+            const snapshot = cloneProjectManagementRecord(snapshotArg);
+            const runtimeId = { harnessId: 'flex', nativeId: sessionIdArg };
+            const stored = await this.findStoredSessionState(projectIdArg, runtimeId);
+            if (!stored) {
+                if (expectedRevisionArg !== 0) {
+                    throw new plugins.flexharness.FlexHarnessStoreConflictError(projectManagementStoreKey(projectIdArg, sessionIdArg), expectedRevisionArg, 0);
+                }
+                const candidate = this.createEmptySessionStateDocument(projectIdArg, runtimeId, randomAuthorityValue());
+                candidate.flexProjectManagement = snapshot;
+                if (snapshot.scratchpad !== '') {
+                    candidate.scratchpad = {
+                        text: snapshot.scratchpad,
+                        revision: 1,
+                        updatedAt: new Date(),
+                        updatedBy: projectManagementUpdater(writeContextArg),
+                    };
+                }
+                try {
+                    await this.insertSessionState(candidate);
+                    return;
+                }
+                catch (errorArg) {
+                    if (errorArg instanceof AuthError && errorArg.code === 'concurrent_change') {
+                        throw new plugins.flexharness.FlexHarnessStoreConflictError(projectManagementStoreKey(projectIdArg, sessionIdArg), expectedRevisionArg, 0);
+                    }
+                    throw errorArg;
+                }
+            }
+            const current = ControllerSessionStateModel.exact.toPersisted(stored);
+            const currentProjectManagement = current.flexProjectManagement;
+            const actualRevision = currentProjectManagement?.revision ?? 0;
+            const sameGeneration = currentProjectManagement
+                ? sameProjectManagementGeneration(currentProjectManagement, snapshot)
+                : false;
+            const canInitialize = currentProjectManagement
+                ? canInitializeProjectManagementGeneration(currentProjectManagement, snapshot, expectedRevisionArg)
+                : expectedRevisionArg === 0;
+            const conflicts = currentProjectManagement
+                ? sameGeneration
+                    ? Object.hasOwn(currentProjectManagement, 'deletedAt')
+                        || actualRevision !== expectedRevisionArg
+                    : !canInitialize
+                : !canInitialize || (!current.deletedAt && current.scratchpad.text !== snapshot.scratchpad);
+            if (conflicts) {
+                throw new plugins.flexharness.FlexHarnessStoreConflictError(projectManagementStoreKey(projectIdArg, sessionIdArg), expectedRevisionArg, actualRevision);
+            }
+            const reviving = current.deletedAt !== undefined;
+            await this.transitionSessionState(stored, (document) => {
+                if (reviving) {
+                    delete document.deletedAt;
+                    document.intelligenceExchanges = [];
+                    delete document.modelChoice;
+                }
+                if (reviving || document.scratchpad.text !== snapshot.scratchpad) {
+                    document.scratchpad = {
+                        text: snapshot.scratchpad,
+                        revision: document.scratchpad.revision + 1,
+                        updatedAt: new Date(),
+                        updatedBy: projectManagementUpdater(writeContextArg),
+                    };
+                }
+                document.flexProjectManagement = snapshot;
+            });
+        });
+    }
+    tombstoneFlexProjectManagement(projectIdArg, sessionIdArg, tombstoneArg, expectedRevisionArg) {
+        return this.runSessionStateMutation(async () => {
+            plugins.flexharness.assertFlexProjectManagementTombstone(tombstoneArg);
+            assertProjectManagementNextRevision(tombstoneArg, expectedRevisionArg);
+            const tombstone = cloneProjectManagementRecord(tombstoneArg);
+            const runtimeId = { harnessId: 'flex', nativeId: sessionIdArg };
+            const stored = await this.findStoredSessionState(projectIdArg, runtimeId);
+            const deletedAt = new Date(tombstone.deletedAt);
+            if (!stored) {
+                if (expectedRevisionArg !== 0) {
+                    throw new plugins.flexharness.FlexHarnessStoreConflictError(projectManagementStoreKey(projectIdArg, sessionIdArg), expectedRevisionArg, 0);
+                }
+                const candidate = this.createEmptySessionStateDocument(projectIdArg, runtimeId, randomAuthorityValue());
+                candidate.flexProjectManagement = tombstone;
+                this.applySessionStateTombstone(candidate, deletedAt);
+                try {
+                    await this.insertSessionState(candidate);
+                    return;
+                }
+                catch (errorArg) {
+                    if (errorArg instanceof AuthError && errorArg.code === 'concurrent_change') {
+                        throw new plugins.flexharness.FlexHarnessStoreConflictError(projectManagementStoreKey(projectIdArg, sessionIdArg), expectedRevisionArg, 0);
+                    }
+                    throw errorArg;
+                }
+            }
+            const current = ControllerSessionStateModel.exact.toPersisted(stored);
+            const currentProjectManagement = current.flexProjectManagement;
+            const actualRevision = currentProjectManagement?.revision ?? 0;
+            if (currentProjectManagement && sameProjectManagementGeneration(currentProjectManagement, tombstone)) {
+                if (Object.hasOwn(currentProjectManagement, 'deletedAt'))
+                    return;
+                if (actualRevision !== expectedRevisionArg) {
+                    throw new plugins.flexharness.FlexHarnessStoreConflictError(projectManagementStoreKey(projectIdArg, sessionIdArg), expectedRevisionArg, actualRevision);
+                }
+            }
+            else if (currentProjectManagement
+                ? !canInitializeProjectManagementGeneration(currentProjectManagement, tombstone, expectedRevisionArg)
+                : expectedRevisionArg !== 0) {
+                throw new plugins.flexharness.FlexHarnessStoreConflictError(projectManagementStoreKey(projectIdArg, sessionIdArg), expectedRevisionArg, actualRevision);
+            }
+            await this.transitionSessionState(stored, (document) => {
+                document.flexProjectManagement = tombstone;
+                this.applySessionStateTombstone(document, deletedAt);
+            });
+        });
+    }
+    purgeFlexProjectManagementNamespace(projectIdArg) {
+        return this.runSessionStateMutation(async () => {
+            this.assertInitialized();
+            const controllerId = this.requireControllerId();
+            this.sessionStateIdentity(projectIdArg, { harnessId: 'flex', nativeId: 'validation' });
+            let lastStoredId;
+            for (let pageIndex = 0; pageIndex < maxSessionStateRetirementPages; pageIndex += 1) {
+                const storedEntries = await ControllerSessionStateModel.exact.findStored({
+                    filter: {
+                        controllerId,
+                        projectId: projectIdArg,
+                        flexProjectManagement: { $exists: true },
+                        ...(lastStoredId === undefined ? {} : { _id: { $gt: lastStoredId } }),
+                    },
+                    sort: { _id: 1 },
+                    limit: sessionStateRetirementPageLimit,
+                });
+                for (const stored of storedEntries) {
+                    await this.transitionSessionState(stored, (document) => {
+                        delete document.flexProjectManagement;
+                    });
+                }
+                const lastStored = storedEntries.at(-1);
+                if (!lastStored || storedEntries.length < sessionStateRetirementPageLimit)
+                    return;
+                lastStoredId = lastStored._id;
+            }
+            throw new Error('Flex project-management namespace purge exceeded its bounded scan.');
+        });
+    }
+    async setSessionModelChoice(projectIdArg, sessionIdArg, modelChoiceArg) {
+        if (modelChoiceArg.harnessId !== sessionIdArg.harnessId) {
+            throw new Error('The session model choice belongs to a different harness.');
+        }
+        const modelChoice = cloneModelChoice(modelChoiceArg);
+        const stored = await this.findStoredSessionState(projectIdArg, sessionIdArg);
+        if (!stored) {
+            const candidate = this.createEmptySessionStateDocument(projectIdArg, sessionIdArg, randomAuthorityValue());
+            candidate.modelChoice = modelChoice;
+            return toPublicSessionState(await this.insertSessionState(candidate));
+        }
+        const current = ControllerSessionStateModel.exact.toPersisted(stored);
+        if (current.deletedAt) {
+            throw new AuthError('concurrent_change', 'The deleted session state cannot be recreated.');
+        }
+        return toPublicSessionState(await this.transitionSessionState(stored, (document) => {
+            document.modelChoice = modelChoice;
+        }));
+    }
+    async clearStoredSessionModelChoiceForProviderConnection(storedArg, providerConnectionIdArg, signalArg) {
+        let stored = storedArg;
+        for (let attempt = 0; attempt < sessionModelChoiceClearTransitionMaxAttempts; attempt++) {
+            signalArg?.throwIfAborted();
+            const current = ControllerSessionStateModel.exact.toPersisted(stored);
+            if (current.deletedAt
+                || current.modelChoice?.harnessId !== 'flex'
+                || current.modelChoice.providerConnectionId !== providerConnectionIdArg)
+                return false;
+            try {
+                await this.transitionSessionState(stored, (document) => {
+                    if (document.modelChoice?.harnessId === 'flex'
+                        && document.modelChoice.providerConnectionId === providerConnectionIdArg)
+                        delete document.modelChoice;
+                });
+                return true;
+            }
+            catch (errorArg) {
+                if (!(errorArg instanceof AuthError)
+                    || (errorArg.code !== 'concurrent_change' && errorArg.code !== 'ambiguous_write'))
+                    throw errorArg;
+                const latest = await this.findStoredSessionState(current.projectId, current.sessionId);
+                if (!latest)
+                    return false;
+                stored = latest;
+            }
+        }
+        throw new AuthError('concurrent_change', 'The session model choice remained busy during provider cleanup.');
+    }
+    async clearSessionModelChoicesForProviderConnection(providerConnectionIdArg, signalArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        if (typeof providerConnectionIdArg !== 'string'
+            || providerConnectionIdArg.length === 0
+            || Buffer.byteLength(providerConnectionIdArg, 'utf8') > 512) {
+            throw new Error('The provider connection identifier is malformed.');
+        }
+        let clearedCount = 0;
+        let lastStoredId;
+        while (true) {
+            signalArg?.throwIfAborted();
+            const storedEntries = await ControllerSessionStateModel.exact.findStored({
+                filter: {
+                    controllerId,
+                    deletedAt: { $exists: false },
+                    modelChoice: { $exists: true },
+                    ...(lastStoredId === undefined ? {} : { _id: { $gt: lastStoredId } }),
+                },
+                sort: { _id: 1 },
+                limit: sessionStateRetirementPageLimit,
+            });
+            for (let index = 0; index < storedEntries.length; index += 8) {
+                signalArg?.throwIfAborted();
+                const page = storedEntries.slice(index, index + 8);
+                await Promise.all(page.map(async (storedEntry) => {
+                    if (await this.clearStoredSessionModelChoiceForProviderConnection(storedEntry, providerConnectionIdArg, signalArg))
+                        clearedCount += 1;
+                }));
+            }
+            const lastStored = storedEntries.at(-1);
+            if (!lastStored || storedEntries.length < sessionStateRetirementPageLimit)
+                return clearedCount;
+            lastStoredId = lastStored._id;
+        }
+    }
+    saveSessionScratchpad(projectIdArg, sessionIdArg, textArg, expectedRevisionArg) {
+        return this.runSessionStateMutation(() => this.saveSessionScratchpadUnqueued(projectIdArg, sessionIdArg, textArg, expectedRevisionArg));
+    }
+    async saveSessionScratchpadUnqueued(projectIdArg, sessionIdArg, textArg, expectedRevisionArg) {
+        const stored = await this.findStoredSessionState(projectIdArg, sessionIdArg);
+        const now = new Date();
+        if (!stored) {
+            if (expectedRevisionArg !== 0) {
+                throw new AuthError('concurrent_change', 'The scratchpad revision is stale.');
+            }
+            const candidate = this.createEmptySessionStateDocument(projectIdArg, sessionIdArg, randomAuthorityValue());
+            candidate.scratchpad = {
+                text: textArg,
+                revision: 1,
+                updatedAt: now,
+                updatedBy: 'user',
+            };
+            return toPublicSessionState(await this.insertSessionState(candidate));
+        }
+        const current = ControllerSessionStateModel.exact.toPersisted(stored);
+        if (current.deletedAt) {
+            throw new AuthError('concurrent_change', 'The deleted session state cannot be recreated.');
+        }
+        if (current.scratchpad.revision !== expectedRevisionArg) {
+            throw new AuthError('concurrent_change', 'The scratchpad revision is stale.');
+        }
+        const next = await this.transitionSessionState(stored, (document) => {
+            document.scratchpad = {
+                text: textArg,
+                revision: expectedRevisionArg + 1,
+                updatedAt: now,
+                updatedBy: 'user',
+            };
+            this.applyFlexProjectManagementScratchpad(document, textArg);
+        });
+        return toPublicSessionState(next);
+    }
+    admitSessionIntelligence(projectIdArg, sessionIdArg, questionArg) {
+        return this.runSessionStateMutation(() => this.admitSessionIntelligenceUnqueued(projectIdArg, sessionIdArg, questionArg));
+    }
+    async admitSessionIntelligenceUnqueued(projectIdArg, sessionIdArg, questionArg) {
+        const exchangeId = plugins.crypto.randomBytes(16).toString('base64url');
+        const createdAt = new Date();
+        let stored = await this.findStoredSessionState(projectIdArg, sessionIdArg);
+        if (!stored) {
+            const candidate = this.createEmptySessionStateDocument(projectIdArg, sessionIdArg, randomAuthorityValue());
+            candidate.intelligenceExchanges = [{
+                    id: exchangeId,
+                    question: questionArg,
+                    status: 'running',
+                    scratchpadRevisionAtAdmission: 0,
+                    createdAt,
+                }];
+            const inserted = await this.insertSessionState(candidate);
+            return {
+                exchange: toPublicIntelligenceExchange(inserted.intelligenceExchanges[0]),
+                scratchpadRevision: 0,
+                scratchpadText: '',
+            };
+        }
+        const current = ControllerSessionStateModel.exact.toPersisted(stored);
+        if (current.deletedAt) {
+            throw new AuthError('concurrent_change', 'The deleted session state cannot be recreated.');
+        }
+        if (current.intelligenceExchanges.some((exchange) => exchange.status === 'running' || exchange.temporarySessionId !== undefined)) {
+            throw new AuthError('concurrent_change', 'Session Intelligence is already running or its cleanup is still pending.');
+        }
+        const scratchpadRevision = current.scratchpad.revision;
+        const next = await this.transitionSessionState(stored, (document) => {
+            document.intelligenceExchanges = trimSessionStateExchanges([
+                ...document.intelligenceExchanges,
+                {
+                    id: exchangeId,
+                    question: questionArg,
+                    status: 'running',
+                    scratchpadRevisionAtAdmission: scratchpadRevision,
+                    createdAt,
+                },
+            ], exchangeId);
+        });
+        const exchange = next.intelligenceExchanges.find((entry) => entry.id === exchangeId);
+        return {
+            exchange: toPublicIntelligenceExchange(exchange),
+            scratchpadRevision,
+            scratchpadText: current.scratchpad.text,
+        };
+    }
+    attachSessionIntelligenceTemporarySession(projectIdArg, sessionIdArg, exchangeIdArg, temporarySessionIdArg) {
+        return this.runSessionStateMutation(() => this.attachSessionIntelligenceTemporarySessionUnqueued(projectIdArg, sessionIdArg, exchangeIdArg, temporarySessionIdArg));
+    }
+    async attachSessionIntelligenceTemporarySessionUnqueued(projectIdArg, sessionIdArg, exchangeIdArg, temporarySessionIdArg) {
+        const stored = await this.findStoredSessionState(projectIdArg, sessionIdArg);
+        if (!stored)
+            throw new AuthError('concurrent_change', 'The intelligence admission is missing.');
+        const current = ControllerSessionStateModel.exact.toPersisted(stored);
+        const exchange = current.intelligenceExchanges.find((entry) => entry.id === exchangeIdArg);
+        if (current.deletedAt || exchange?.status !== 'running') {
+            throw new AuthError('concurrent_change', 'The intelligence admission is no longer active.');
+        }
+        await this.transitionSessionState(stored, (document) => {
+            const target = document.intelligenceExchanges.find((entry) => entry.id === exchangeIdArg);
+            target.temporarySessionId = temporarySessionIdArg;
+        });
+    }
+    completeSessionIntelligence(projectIdArg, sessionIdArg, exchangeIdArg, answerArg, scratchpadTextArg, modelArg) {
+        return this.runSessionStateMutation(() => this.completeSessionIntelligenceUnqueued(projectIdArg, sessionIdArg, exchangeIdArg, answerArg, scratchpadTextArg, modelArg));
+    }
+    async completeSessionIntelligenceUnqueued(projectIdArg, sessionIdArg, exchangeIdArg, answerArg, scratchpadTextArg, modelArg) {
+        const stored = await this.findStoredSessionState(projectIdArg, sessionIdArg);
+        if (!stored)
+            return undefined;
+        const current = ControllerSessionStateModel.exact.toPersisted(stored);
+        const exchange = current.intelligenceExchanges.find((entry) => entry.id === exchangeIdArg);
+        if (current.deletedAt || exchange?.status !== 'running')
+            return undefined;
+        const scratchpadConflict = current.scratchpad.revision !== exchange.scratchpadRevisionAtAdmission;
+        const completedAt = new Date();
+        const next = await this.transitionSessionState(stored, (document) => {
+            const target = document.intelligenceExchanges.find((entry) => entry.id === exchangeIdArg);
+            document.intelligenceExchanges = trimSessionStateExchanges(document.intelligenceExchanges.map((entry) => entry.id === exchangeIdArg
+                ? {
+                    id: target.id,
+                    question: target.question,
+                    status: 'completed',
+                    answer: answerArg,
+                    model: modelArg,
+                    ...(scratchpadConflict ? { scratchpadConflict: true } : {}),
+                    ...(target.temporarySessionId === undefined
+                        ? {}
+                        : { temporarySessionId: target.temporarySessionId }),
+                    createdAt: target.createdAt,
+                    completedAt,
+                }
+                : entry), exchangeIdArg);
+            if (!scratchpadConflict && document.scratchpad.text !== scratchpadTextArg) {
+                document.scratchpad = {
+                    text: scratchpadTextArg,
+                    revision: document.scratchpad.revision + 1,
+                    updatedAt: completedAt,
+                    updatedBy: 'intelligence',
+                };
+                this.applyFlexProjectManagementScratchpad(document, scratchpadTextArg);
+            }
+        });
+        return toPublicSessionState(next);
+    }
+    failSessionIntelligence(projectIdArg, sessionIdArg, exchangeIdArg, errorArg, modelArg) {
+        return this.runSessionStateMutation(() => this.failSessionIntelligenceUnqueued(projectIdArg, sessionIdArg, exchangeIdArg, errorArg, modelArg));
+    }
+    async failSessionIntelligenceUnqueued(projectIdArg, sessionIdArg, exchangeIdArg, errorArg, modelArg) {
+        const stored = await this.findStoredSessionState(projectIdArg, sessionIdArg);
+        if (!stored)
+            return undefined;
+        const current = ControllerSessionStateModel.exact.toPersisted(stored);
+        const exchange = current.intelligenceExchanges.find((entry) => entry.id === exchangeIdArg);
+        if (current.deletedAt || exchange?.status !== 'running')
+            return undefined;
+        const completedAt = new Date();
+        const next = await this.transitionSessionState(stored, (document) => {
+            const target = document.intelligenceExchanges.find((entry) => entry.id === exchangeIdArg);
+            document.intelligenceExchanges = trimSessionStateExchanges(document.intelligenceExchanges.map((entry) => entry.id === exchangeIdArg
+                ? {
+                    id: target.id,
+                    question: target.question,
+                    status: 'error',
+                    error: errorArg,
+                    ...(modelArg === undefined ? {} : { model: modelArg }),
+                    ...(target.temporarySessionId === undefined
+                        ? {}
+                        : { temporarySessionId: target.temporarySessionId }),
+                    createdAt: target.createdAt,
+                    completedAt,
+                }
+                : entry), exchangeIdArg);
+        });
+        return toPublicSessionState(next);
+    }
+    recoverInterruptedSessionIntelligence() {
+        return this.runSessionStateMutation(() => this.recoverInterruptedSessionIntelligenceUnqueued());
+    }
+    async recoverInterruptedSessionIntelligenceUnqueued() {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        const storedEntries = await ControllerSessionStateModel.exact.findStored({
+            filter: {
+                controllerId,
+                deletedAt: { $exists: false },
+                intelligenceExchanges: { $elemMatch: { status: 'running' } },
+            },
+            limit: sessionStateRecoveryLimit,
+        });
+        const temporarySessionIds = [];
+        let recoveredCount = 0;
+        for (const stored of storedEntries) {
+            const current = ControllerSessionStateModel.exact.toPersisted(stored);
+            for (const exchange of current.intelligenceExchanges) {
+                if (exchange.status === 'running' && exchange.temporarySessionId) {
+                    temporarySessionIds.push({
+                        projectId: current.projectId,
+                        sessionId: current.sessionId,
+                        exchangeId: exchange.id,
+                        nativeId: exchange.temporarySessionId,
+                    });
+                }
+            }
+            const completedAt = new Date();
+            await this.transitionSessionState(stored, (document) => {
+                document.intelligenceExchanges = document.intelligenceExchanges.map((exchange) => exchange.status === 'running'
+                    ? {
+                        id: exchange.id,
+                        question: exchange.question,
+                        status: 'error',
+                        error: 'Session Intelligence was interrupted by a controller restart.',
+                        ...(exchange.temporarySessionId === undefined
+                            ? {}
+                            : { temporarySessionId: exchange.temporarySessionId }),
+                        createdAt: exchange.createdAt,
+                        completedAt,
+                    }
+                    : exchange);
+            });
+            recoveredCount += 1;
+        }
+        return {
+            recoveredCount,
+            exhaustive: storedEntries.length < sessionStateRecoveryLimit,
+            temporarySessionIds,
+        };
+    }
+    async listProjectSessionIntelligenceCleanupObligations(projectIdArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        if (typeof projectIdArg !== 'string'
+            || projectIdArg.length === 0
+            || projectIdArg.length > 64) {
+            throw new AuthError('invalid_project', 'The project identifier is malformed.');
+        }
+        const storedEntries = await ControllerSessionStateModel.exact.findStored({
+            filter: {
+                controllerId,
+                projectId: projectIdArg,
+                deletedAt: { $exists: false },
+                intelligenceExchanges: { $elemMatch: { temporarySessionId: { $exists: true } } },
+            },
+            limit: sessionStateRecoveryLimit,
+        });
+        return storedEntries.flatMap((stored) => {
+            const current = ControllerSessionStateModel.exact.toPersisted(stored);
+            return current.intelligenceExchanges.flatMap((exchange) => exchange.temporarySessionId
+                ? [{
+                        projectId: current.projectId,
+                        sessionId: current.sessionId,
+                        exchangeId: exchange.id,
+                        nativeId: exchange.temporarySessionId,
+                    }]
+                : []);
+        });
+    }
+    async getSessionIntelligenceCleanupObligations(projectIdArg, sessionIdArg) {
+        const stored = await this.findStoredSessionState(projectIdArg, sessionIdArg);
+        if (!stored)
+            return [];
+        const current = ControllerSessionStateModel.exact.toPersisted(stored);
+        if (current.deletedAt)
+            return [];
+        return current.intelligenceExchanges.flatMap((exchange) => exchange.temporarySessionId
+            ? [{
+                    projectId: current.projectId,
+                    sessionId: current.sessionId,
+                    exchangeId: exchange.id,
+                    nativeId: exchange.temporarySessionId,
+                }]
+            : []);
+    }
+    async findProjectSessionIntelligenceTemporarySessionIds(projectIdArg, candidateIdsArg, signalArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        if (typeof projectIdArg !== 'string'
+            || projectIdArg.length === 0
+            || projectIdArg.length > 64
+            || candidateIdsArg.length > 512
+            || candidateIdsArg.some((id) => (typeof id !== 'string'
+                || id.length === 0
+                || Buffer.byteLength(id, 'utf8') > 512))) {
+            throw new AuthError('invalid_project', 'The temporary-session lookup is malformed.');
+        }
+        const candidateIds = [...new Set(candidateIdsArg)];
+        if (candidateIds.length === 0)
+            return new Set();
+        const storedEntries = await ControllerSessionStateModel.exact.findStored({
+            filter: {
+                controllerId,
+                projectId: projectIdArg,
+                deletedAt: { $exists: false },
+                intelligenceExchanges: {
+                    $elemMatch: { temporarySessionId: { $in: candidateIds } },
+                },
+            },
+            limit: candidateIds.length,
+            signal: signalArg,
+        });
+        const candidateSet = new Set(candidateIds);
+        return new Set(storedEntries.flatMap((stored) => ControllerSessionStateModel.exact.toPersisted(stored).intelligenceExchanges.flatMap((exchange) => exchange.temporarySessionId
+            && candidateSet.has(exchange.temporarySessionId)
+            ? [exchange.temporarySessionId]
+            : [])));
+    }
+    async isSessionStateTombstoned(projectIdArg, sessionIdArg) {
+        const stored = await this.findStoredSessionState(projectIdArg, sessionIdArg);
+        if (!stored)
+            return false;
+        return ControllerSessionStateModel.exact.toPersisted(stored).deletedAt !== undefined;
+    }
+    async retireProjectSessionStates(projectIdArg, cleanupTemporarySessionArg, signalArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        if (typeof projectIdArg !== 'string'
+            || projectIdArg.length === 0
+            || projectIdArg.length > 64) {
+            throw new AuthError('invalid_project', 'The project identifier is malformed.');
+        }
+        const temporarySessionIds = new Set();
+        let retiredCount = 0;
+        let lastStoredId;
+        for (let pageIndex = 0; pageIndex < maxSessionStateRetirementPages; pageIndex += 1) {
+            signalArg?.throwIfAborted();
+            const storedEntries = await ControllerSessionStateModel.exact.findStored({
+                filter: {
+                    controllerId,
+                    projectId: projectIdArg,
+                    deletedAt: { $exists: false },
+                    ...(lastStoredId === undefined ? {} : { _id: { $gt: lastStoredId } }),
+                },
+                sort: { _id: 1 },
+                limit: sessionStateRetirementPageLimit,
+            });
+            signalArg?.throwIfAborted();
+            for (const stored of storedEntries) {
+                const current = ControllerSessionStateModel.exact.toPersisted(stored);
+                for (const exchange of current.intelligenceExchanges) {
+                    if (!exchange.temporarySessionId || temporarySessionIds.has(exchange.temporarySessionId)) {
+                        continue;
+                    }
+                    signalArg?.throwIfAborted();
+                    await cleanupTemporarySessionArg(exchange.temporarySessionId);
+                    temporarySessionIds.add(exchange.temporarySessionId);
+                }
+                signalArg?.throwIfAborted();
+                const retired = await this.runSessionStateMutation(async () => {
+                    const latest = await this.findStoredSessionState(projectIdArg, current.sessionId);
+                    if (!latest || ControllerSessionStateModel.exact.toPersisted(latest).deletedAt)
+                        return false;
+                    await this.transitionSessionState(latest, (document) => {
+                        this.applySessionStateTombstone(document, new Date());
+                    });
+                    return true;
+                });
+                if (retired)
+                    retiredCount += 1;
+            }
+            const lastStored = storedEntries.at(-1);
+            if (!lastStored || storedEntries.length < sessionStateRetirementPageLimit) {
+                return { retiredCount, temporarySessionIds: [...temporarySessionIds] };
+            }
+            lastStoredId = lastStored._id;
+        }
+        throw new Error(`Project session-state retirement cleared ${retiredCount} state(s) before exceeding its bounded scan.`);
+    }
+    clearSessionIntelligenceTemporarySession(projectIdArg, sessionIdArg, exchangeIdArg, temporarySessionIdArg) {
+        return this.runSessionStateMutation(() => this.clearSessionIntelligenceTemporarySessionUnqueued(projectIdArg, sessionIdArg, exchangeIdArg, temporarySessionIdArg));
+    }
+    async clearSessionIntelligenceTemporarySessionUnqueued(projectIdArg, sessionIdArg, exchangeIdArg, temporarySessionIdArg) {
+        const stored = await this.findStoredSessionState(projectIdArg, sessionIdArg);
+        if (!stored)
+            return;
+        const current = ControllerSessionStateModel.exact.toPersisted(stored);
+        const exchange = current.intelligenceExchanges.find((entry) => entry.id === exchangeIdArg);
+        if (current.deletedAt || exchange?.temporarySessionId !== temporarySessionIdArg)
+            return;
+        await this.transitionSessionState(stored, (document) => {
+            const target = document.intelligenceExchanges.find((entry) => entry.id === exchangeIdArg);
+            if (target?.temporarySessionId === temporarySessionIdArg) {
+                delete target.temporarySessionId;
+            }
+        });
+    }
+    tombstoneSessionState(projectIdArg, sessionIdArg) {
+        return this.runSessionStateMutation(() => this.tombstoneSessionStateUnqueued(projectIdArg, sessionIdArg));
+    }
+    async tombstoneSessionStateUnqueued(projectIdArg, sessionIdArg) {
+        const stored = await this.findStoredSessionState(projectIdArg, sessionIdArg);
+        const deletedAt = new Date();
+        if (!stored) {
+            const candidate = this.createEmptySessionStateDocument(projectIdArg, sessionIdArg, randomAuthorityValue());
+            candidate.deletedAt = deletedAt;
+            await this.insertSessionState(candidate);
+            return;
+        }
+        const current = ControllerSessionStateModel.exact.toPersisted(stored);
+        if (current.deletedAt)
+            return;
+        await this.transitionSessionState(stored, (document) => {
+            this.applySessionStateTombstone(document, deletedAt);
+        });
+    }
+    applyFlexProjectManagementScratchpad(documentArg, textArg) {
+        const current = documentArg.flexProjectManagement;
+        if (!current || 'deletedAt' in current || current.scratchpad === textArg)
+            return;
+        const snapshot = {
+            ...current,
+            revision: current.revision + 1,
+            scratchpad: textArg,
+        };
+        plugins.flexharness.assertFlexProjectManagementSnapshot(snapshot);
+        documentArg.flexProjectManagement = snapshot;
+    }
+    applySessionStateTombstone(documentArg, deletedAtArg) {
+        const projectManagement = documentArg.flexProjectManagement;
+        if (projectManagement && !Object.hasOwn(projectManagement, 'deletedAt')) {
+            const tombstone = {
+                schemaVersion: 1,
+                revision: projectManagement.revision + 1,
+                sessionGenerationId: projectManagement.sessionGenerationId,
+                sessionGenerationSequence: projectManagement.sessionGenerationSequence,
+                deletedAt: deletedAtArg.toISOString(),
+            };
+            plugins.flexharness.assertFlexProjectManagementTombstone(tombstone);
+            documentArg.flexProjectManagement = tombstone;
+        }
+        documentArg.scratchpad = {
+            text: '',
+            revision: documentArg.scratchpad.revision,
+            ...(documentArg.scratchpad.updatedAt === undefined
+                ? {}
+                : { updatedAt: documentArg.scratchpad.updatedAt }),
+            ...(documentArg.scratchpad.updatedBy === undefined
+                ? {}
+                : { updatedBy: documentArg.scratchpad.updatedBy }),
+        };
+        documentArg.intelligenceExchanges = [];
+        delete documentArg.modelChoice;
+        documentArg.deletedAt = deletedAtArg;
+    }
+    async createTempPassword(ttlMsArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        if (!Number.isSafeInteger(ttlMsArg)
+            || ttlMsArg < tempPasswordTtlMinMs
+            || ttlMsArg > tempPasswordTtlMaxMs) {
+            throw new AuthError('temp_password_invalid', 'A temporary password lifetime must be between one minute and 24 hours.');
+        }
+        const now = Date.now();
+        const active = (await ControllerTempPasswordModel.exact.findStored({
+            filter: { controllerId },
+            limit: maxActiveTempPasswords * 4,
+        }))
+            .map((entry) => ControllerTempPasswordModel.exact.toPersisted(entry))
+            .filter((entry) => entry.expiresAt.getTime() > now);
+        if (active.length >= maxActiveTempPasswords) {
+            throw new AuthError('temp_password_limit', `At most ${maxActiveTempPasswords} temporary passwords can be active; wait for one to expire.`);
+        }
+        const password = plugins.crypto.randomBytes(24).toString('base64url');
+        const id = `${controllerId}:temppass:${randomAuthorityValue()}`;
+        const insertResult = await ControllerTempPasswordModel.exact.insert({
+            id,
+            controllerId,
+            secretHash: hashSetupCode(password),
+            createdAt: new Date(now),
+            expiresAt: new Date(now + ttlMsArg),
+        });
+        if (insertResult.status === 'conflict') {
+            throw new AuthError('concurrent_change', 'The temporary password identifier conflicts.');
+        }
+        const persisted = ControllerTempPasswordModel.exact.toPersisted(insertResult.document);
+        return { password, credentialId: `temp:${persisted.id}`, expiresAt: persisted.expiresAt };
+    }
+    async verifyTempPassword(passwordArg) {
+        this.assertInitialized();
+        const controllerId = this.requireControllerId();
+        if (typeof passwordArg !== 'string' || !tempPasswordPattern.test(passwordArg)) {
+            return undefined;
+        }
+        const candidateHash = hashSetupCode(passwordArg);
+        const now = Date.now();
+        const stored = await ControllerTempPasswordModel.exact.findStored({
+            filter: { controllerId },
+            limit: maxActiveTempPasswords * 4,
+        });
+        for (const entry of stored) {
+            const persisted = ControllerTempPasswordModel.exact.toPersisted(entry);
+            if (persisted.expiresAt.getTime() <= now)
+                continue;
+            if (hashesEqual(persisted.secretHash, candidateHash)) {
+                return { credentialId: `temp:${persisted.id}`, expiresAt: persisted.expiresAt };
+            }
+        }
+        return undefined;
+    }
+    assertRuntimeConfigMatches(storedArg, requestedArg) {
+        if (!runtimeConfigsEqual(storedArg, requestedArg)) {
+            throw new AuthError('config_mismatch', 'The stored controller runtime configuration is immutable and does not match.');
+        }
+    }
+    auditEventsEqual(leftArg, rightArg) {
+        return leftArg.id === rightArg.id
+            && leftArg.controllerId === rightArg.controllerId
+            && leftArg.timestamp.getTime() === rightArg.timestamp.getTime()
+            && leftArg.type === rightArg.type
+            && leftArg.outcome === rightArg.outcome
+            && leftArg.operationId === rightArg.operationId
+            && leftArg.peerId === rightArg.peerId
+            && leftArg.credentialId === rightArg.credentialId
+            && (leftArg.sessionId === undefined
+                ? rightArg.sessionId === undefined
+                : rightArg.sessionId !== undefined
+                    && controllerRuntimeIdKey(leftArg.sessionId) === controllerRuntimeIdKey(rightArg.sessionId))
+            && (leftArg.requestId === undefined
+                ? rightArg.requestId === undefined
+                : rightArg.requestId !== undefined
+                    && controllerRuntimeIdKey(leftArg.requestId) === controllerRuntimeIdKey(rightArg.requestId));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.authstore.js","sourceRoot":"","sources":["../../ts/classes.authstore.ts"],"names":[],"mappings":"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"}