agl 1.0.17 → 21.0.2

package/dist_ts/classes.harnessoperationmanager.js

@@ -0,0 +1,602 @@
+import * as plugins from './plugins.js';
+import { controllerRuntimeIdKey, } from '../dist_ts_interfaces/interfaces.js';
+import { ControllerDraftManager } from './classes.draftmanager.js';
+import { ControllerUploadManager, } from './classes.uploadmanager.js';
+const maximumActiveHarnessOperations = 64;
+const maximumHarnessOperationsPerSession = 16;
+const maximumPendingUploadCleanups = 64;
+const harnessOperationCleanupTimeoutMs = 10_000;
+export class ControllerHarnessOperationConflictError extends Error {
+    constructor(messageArg) {
+        super(messageArg);
+        this.name = 'ControllerHarnessOperationConflictError';
+    }
+}
+export class ControllerHarnessOperationLimitError extends Error {
+    constructor(messageArg) {
+        super(messageArg);
+        this.name = 'ControllerHarnessOperationLimitError';
+    }
+}
+const cloneDraft = (draftArg) => ({
+    text: draftArg.text,
+    attachments: draftArg.attachments.map((attachment) => ({ ...attachment })),
+    revision: draftArg.revision,
+});
+const cloneReservation = (reservationArg) => ({
+    ...reservationArg,
+    sessionId: { ...reservationArg.sessionId },
+    draft: cloneDraft(reservationArg.draft),
+});
+export class ControllerHarnessOperationManager {
+    options;
+    drafts = new ControllerDraftManager();
+    uploads = new ControllerUploadManager();
+    operationsBySession = new Map();
+    operationsByOpenCodeMessage = new Map();
+    operationsByFlexQueue = new Map();
+    pendingUploadCleanups = new Map();
+    harnessAdmissionGenerations = new Map();
+    sealedHarnessAdmissions = new Map();
+    activeOperationCount = 0;
+    operationBarrier;
+    closed = false;
+    closePromise;
+    cleanupTimeoutMs;
+    constructor(options) {
+        this.options = options;
+        const cleanupTimeoutMs = options.cleanupTimeoutMs ?? harnessOperationCleanupTimeoutMs;
+        if (!Number.isSafeInteger(cleanupTimeoutMs) || cleanupTimeoutMs < 1) {
+            throw new Error('cleanupTimeoutMs must be a positive safe integer.');
+        }
+        this.cleanupTimeoutMs = cleanupTimeoutMs;
+    }
+    getDraft(projectIdArg, sessionIdArg) {
+        return this.drafts.get(this.sessionKey(projectIdArg, sessionIdArg));
+    }
+    updateDraft(projectIdArg, sessionIdArg, expectedRevisionArg, patchArg) {
+        if (this.closed)
+            throw new Error('The harness operation manager is closed.');
+        const result = this.drafts.update(this.sessionKey(projectIdArg, sessionIdArg), expectedRevisionArg, patchArg);
+        if (result.update)
+            this.options.onDraftChanged(projectIdArg, sessionIdArg, result.update);
+        return result.draft;
+    }
+    async reserve(kindArg, projectIdArg, sessionIdArg, draftRevisionArg, optionsArg) {
+        if (this.closed)
+            throw new Error('The harness operation manager is closed.');
+        if (sessionIdArg.harnessId !== 'opencode' && sessionIdArg.harnessId !== 'flex') {
+            throw new Error('Only session harnesses may reserve prompt operations.');
+        }
+        const harnessId = sessionIdArg.harnessId;
+        const harnessAdmissionGeneration = this.currentHarnessAdmissionGeneration(harnessId);
+        this.assertHarnessAdmission(harnessId, harnessAdmissionGeneration);
+        const key = this.sessionKey(projectIdArg, sessionIdArg);
+        let operations = this.operationsBySession.get(key) ?? [];
+        if (operations.some((operation) => operation.reservation.draft.revision === draftRevisionArg)) {
+            throw new ControllerHarnessOperationConflictError('The composer draft revision is already being submitted.');
+        }
+        if (this.pendingUploadCleanups.size > 0) {
+            await this.retryPendingUploadCleanups().catch(() => undefined);
+        }
+        if (this.closed)
+            throw new Error('The harness operation manager is closed.');
+        this.assertHarnessAdmission(harnessId, harnessAdmissionGeneration);
+        operations = this.operationsBySession.get(key) ?? [];
+        if (operations.some((operation) => operation.reservation.draft.revision === draftRevisionArg)) {
+            throw new ControllerHarnessOperationConflictError('The composer draft revision is already being submitted.');
+        }
+        if (this.activeOperationCount >= maximumActiveHarnessOperations
+            || operations.length >= maximumHarnessOperationsPerSession
+            || this.pendingUploadCleanups.size >= maximumPendingUploadCleanups) {
+            throw new ControllerHarnessOperationLimitError('The active harness operation limit is exhausted.');
+        }
+        const draft = this.drafts.snapshot(key, draftRevisionArg);
+        if (!optionsArg.allowAttachments && draft.attachments.length > 0) {
+            throw new Error('Attachments are not supported by this composer command.');
+        }
+        const reservation = {
+            operationId: plugins.crypto.randomBytes(16).toString('base64url'),
+            createdAt: Date.now(),
+            kind: kindArg,
+            projectId: projectIdArg,
+            sessionId: { ...sessionIdArg },
+            draft,
+            promptSuffix: '',
+        };
+        const active = {
+            reservation,
+            harnessAdmissionGeneration,
+            state: 'submitting',
+            observedTerminal: false,
+        };
+        operations.push(active);
+        this.operationsBySession.set(key, operations);
+        this.activeOperationCount += 1;
+        try {
+            const upload = await this.uploads.create(draft.attachments);
+            if (upload)
+                active.upload = upload;
+            if (this.closed || !this.operationsBySession.get(key)?.includes(active)) {
+                throw new Error('The harness operation reservation closed during upload materialization.');
+            }
+            this.assertHarnessAdmission(harnessId, harnessAdmissionGeneration);
+            if (upload) {
+                reservation.promptSuffix = upload.promptSuffix;
+                reservation.uploadDirectory = upload.directory;
+            }
+            return cloneReservation(reservation);
+        }
+        catch (errorArg) {
+            await this.releaseActive(active);
+            throw errorArg;
+        }
+    }
+    accept(reservationArg) {
+        const active = this.requireActive(reservationArg);
+        if (active.state !== 'submitting') {
+            throw new Error('The harness operation is not awaiting submission acceptance.');
+        }
+        active.state = 'accepted';
+        const draft = this.clearReservationDraft(reservationArg);
+        if (active.observedTerminal)
+            void this.releaseActive(active).catch(() => undefined);
+        return draft;
+    }
+    bindOpenCodeMessage(reservationArg, messageIdArg) {
+        const active = this.requireActive(reservationArg);
+        if (reservationArg.sessionId.harnessId !== 'opencode' || messageIdArg.harnessId !== 'opencode') {
+            throw new Error('Only OpenCode operations may bind an OpenCode message ID.');
+        }
+        if (active.reservation.messageId) {
+            throw new Error('The harness operation already has a native message ID.');
+        }
+        const key = this.openCodeMessageKey(reservationArg.projectId, reservationArg.sessionId, messageIdArg);
+        if (this.operationsByOpenCodeMessage.has(key)) {
+            throw new Error('The OpenCode message ID is already bound to another operation.');
+        }
+        active.reservation.messageId = { ...messageIdArg };
+        reservationArg.messageId = { ...messageIdArg };
+        this.operationsByOpenCodeMessage.set(key, active);
+    }
+    clearReservationDraft(reservationArg) {
+        const result = this.drafts.clearExact(this.sessionKey(reservationArg.projectId, reservationArg.sessionId), reservationArg.draft.revision);
+        if (result.update) {
+            this.options.onDraftChanged(reservationArg.projectId, reservationArg.sessionId, result.update);
+        }
+        return result.draft;
+    }
+    markOutcomeUnknown(reservationArg) {
+        const active = this.findActive(reservationArg);
+        if (!active)
+            return;
+        active.state = 'outcomeUnknown';
+        if (active.observedTerminal)
+            void this.releaseActive(active).catch(() => undefined);
+    }
+    async fail(reservationArg) {
+        const active = this.findActive(reservationArg);
+        if (active)
+            await this.releaseActive(active);
+        else
+            await this.retryPendingUploadCleanup(reservationArg.operationId);
+    }
+    async complete(reservationArg) {
+        const active = this.findActive(reservationArg);
+        if (active)
+            await this.releaseActive(active);
+        else
+            await this.retryPendingUploadCleanup(reservationArg.operationId);
+    }
+    bindFlex(reservationArg, queueIdArg, runIdArg) {
+        const active = this.requireActive(reservationArg);
+        const queueKey = this.flexQueueKey(reservationArg.projectId, reservationArg.sessionId, queueIdArg);
+        if (this.operationsByFlexQueue.has(queueKey)) {
+            throw new Error('The Flex queue entry is already bound to a harness operation.');
+        }
+        active.flexQueueKey = queueKey;
+        active.flexQueueId = queueIdArg;
+        active.flexRunId = runIdArg;
+        this.operationsByFlexQueue.set(queueKey, active);
+    }
+    bindFlexRun(projectIdArg, sessionIdArg, queueIdArg, runIdArg) {
+        const active = this.operationsByFlexQueue.get(this.flexQueueKey(projectIdArg, sessionIdArg, queueIdArg));
+        if (!active || active.flexQueueId !== queueIdArg)
+            return false;
+        if (active.flexRunId && active.flexRunId !== runIdArg) {
+            throw new Error('The Flex queue entry was bound to conflicting run IDs.');
+        }
+        active.flexRunId = runIdArg;
+        return true;
+    }
+    async completeFlex(projectIdArg, sessionIdArg, queueIdArg, runIdArg) {
+        const queueKey = this.flexQueueKey(projectIdArg, sessionIdArg, queueIdArg);
+        const active = this.operationsByFlexQueue.get(queueKey);
+        if (!active
+            || active.flexQueueId !== queueIdArg
+            || (active.flexRunId !== undefined && active.flexRunId !== runIdArg)
+            || (active.flexRunId === undefined && runIdArg !== undefined))
+            return false;
+        if (active.state === 'submitting') {
+            active.observedTerminal = true;
+            return true;
+        }
+        await this.releaseActive(active);
+        return true;
+    }
+    ownsFlexRun(projectIdArg, sessionIdArg, queueIdArg, runIdArg) {
+        if (sessionIdArg.harnessId !== 'flex')
+            return false;
+        return (this.operationsBySession.get(this.sessionKey(projectIdArg, sessionIdArg)) ?? [])
+            .some((active) => active.flexQueueId === queueIdArg && active.flexRunId === runIdArg);
+    }
+    async completeOpenCodeMessage(projectIdArg, sessionIdArg, messageIdArg) {
+        if (sessionIdArg.harnessId !== 'opencode' || messageIdArg.harnessId !== 'opencode')
+            return false;
+        const active = this.operationsByOpenCodeMessage.get(this.openCodeMessageKey(projectIdArg, sessionIdArg, messageIdArg));
+        if (!active)
+            return false;
+        active.observedTerminal = true;
+        if (active.state !== 'submitting') {
+            await this.releaseActive(active);
+        }
+        return true;
+    }
+    getActive(projectIdArg, sessionIdArg) {
+        const active = this.operationsBySession.get(this.sessionKey(projectIdArg, sessionIdArg))?.[0];
+        return active ? {
+            reservation: cloneReservation(active.reservation),
+            state: active.state,
+            ...(active.flexQueueId ? { flexQueueId: active.flexQueueId } : {}),
+            ...(active.flexRunId ? { flexRunId: active.flexRunId } : {}),
+        } : undefined;
+    }
+    getOperation(reservationArg) {
+        const active = this.findActive(reservationArg);
+        return active ? {
+            reservation: cloneReservation(active.reservation),
+            state: active.state,
+            ...(active.flexQueueId ? { flexQueueId: active.flexQueueId } : {}),
+            ...(active.flexRunId ? { flexRunId: active.flexRunId } : {}),
+        } : undefined;
+    }
+    listSessionActive(projectIdArg, sessionIdArg) {
+        return (this.operationsBySession.get(this.sessionKey(projectIdArg, sessionIdArg)) ?? [])
+            .map((active) => ({
+            reservation: cloneReservation(active.reservation),
+            state: active.state,
+            ...(active.flexQueueId ? { flexQueueId: active.flexQueueId } : {}),
+            ...(active.flexRunId ? { flexRunId: active.flexRunId } : {}),
+        }));
+    }
+    bindFlexMessage(projectIdArg, sessionIdArg, queueIdArg, runIdArg, messageIdArg) {
+        const active = this.operationsByFlexQueue.get(this.flexQueueKey(projectIdArg, sessionIdArg, queueIdArg));
+        if (!active
+            || active.flexQueueId !== queueIdArg
+            || active.flexRunId !== runIdArg
+            || messageIdArg.harnessId !== 'flex') {
+            return false;
+        }
+        if (active.reservation.messageId) {
+            if (controllerRuntimeIdKey(active.reservation.messageId) === controllerRuntimeIdKey(messageIdArg)) {
+                return true;
+            }
+            throw new Error('The Flex queue entry was bound to conflicting message IDs.');
+        }
+        active.reservation.messageId = { ...messageIdArg };
+        return true;
+    }
+    listProjectActive(projectIdArg) {
+        const prefix = `${projectIdArg}\0`;
+        return [...this.operationsBySession.entries()]
+            .filter(([key]) => key.startsWith(prefix))
+            .flatMap(([, operations]) => operations.map((active) => ({
+            reservation: cloneReservation(active.reservation),
+            state: active.state,
+            ...(active.flexQueueId ? { flexQueueId: active.flexQueueId } : {}),
+            ...(active.flexRunId ? { flexRunId: active.flexRunId } : {}),
+        })));
+    }
+    listHarnessActive(harnessIdArg) {
+        return [...this.operationsBySession.values()].flat()
+            .filter((active) => active.reservation.sessionId.harnessId === harnessIdArg)
+            .map((active) => ({
+            reservation: cloneReservation(active.reservation),
+            state: active.state,
+            ...(active.flexQueueId ? { flexQueueId: active.flexQueueId } : {}),
+            ...(active.flexRunId ? { flexRunId: active.flexRunId } : {}),
+        }));
+    }
+    assertExclusive(reservationArg) {
+        const active = this.requireActive(reservationArg);
+        const operations = this.operationsBySession.get(this.sessionKey(reservationArg.projectId, reservationArg.sessionId)) ?? [];
+        if (operations.some((operation) => operation !== active)) {
+            throw new ControllerHarnessOperationConflictError('Another harness operation is still active for this conversation.');
+        }
+    }
+    sealHarnessAdmission(harnessIdArg) {
+        if (this.closed)
+            throw new Error('The harness operation manager is closed.');
+        const generation = this.currentHarnessAdmissionGeneration(harnessIdArg) + 1;
+        this.harnessAdmissionGenerations.set(harnessIdArg, generation);
+        this.sealedHarnessAdmissions.set(harnessIdArg, generation);
+        return generation;
+    }
+    reopenHarnessAdmission(harnessIdArg, generationArg) {
+        if (this.closed
+            || this.currentHarnessAdmissionGeneration(harnessIdArg) !== generationArg
+            || this.sealedHarnessAdmissions.get(harnessIdArg) !== generationArg)
+            return false;
+        this.sealedHarnessAdmissions.delete(harnessIdArg);
+        return true;
+    }
+    assertCurrentHarnessAdmission(reservationArg) {
+        const active = this.requireActive(reservationArg);
+        const harnessId = reservationArg.sessionId.harnessId;
+        if (harnessId !== 'opencode' && harnessId !== 'flex') {
+            throw new Error('Only session harnesses may own prompt operations.');
+        }
+        this.assertHarnessAdmission(harnessId, active.harnessAdmissionGeneration);
+    }
+    beginOperationBarrier(harnessIdArg, maximumSessionsArg = 64) {
+        if (this.closed)
+            throw new Error('The harness operation manager is closed.');
+        if (this.operationBarrier) {
+            throw new ControllerHarnessOperationConflictError('Harness prompt admission is already sealed.');
+        }
+        const token = plugins.crypto.randomBytes(16).toString('base64url');
+        this.operationBarrier = { token, ...(harnessIdArg ? { harnessId: harnessIdArg } : {}) };
+        const operations = [...this.operationsBySession.values()].flat().filter((operation) => (harnessIdArg === undefined || operation.reservation.sessionId.harnessId === harnessIdArg));
+        const sessionsByKey = new Map();
+        for (const operation of operations) {
+            const { projectId, sessionId } = operation.reservation;
+            sessionsByKey.set(this.sessionKey(projectId, sessionId), {
+                projectId,
+                sessionId: { ...sessionId },
+            });
+        }
+        if (sessionsByKey.size > maximumSessionsArg) {
+            this.operationBarrier = undefined;
+            throw new ControllerHarnessOperationLimitError('Too many active sessions are present for a bounded harness handoff.');
+        }
+        return {
+            token,
+            ...(harnessIdArg ? { harnessId: harnessIdArg } : {}),
+            operationIds: operations.map((operation) => operation.reservation.operationId),
+            sessions: [...sessionsByKey.values()],
+        };
+    }
+    beginUpgradeBarrier(maximumSessionsArg = 64) {
+        return this.beginOperationBarrier(undefined, maximumSessionsArg);
+    }
+    async waitForOperationBarrier(barrierArg, timeoutMsArg, signalArg) {
+        this.assertOperationBarrier(barrierArg);
+        const pendingIds = new Set(barrierArg.operationIds);
+        const deadline = Date.now() + timeoutMsArg;
+        while (pendingIds.size > 0 && Date.now() < deadline) {
+            signalArg?.throwIfAborted();
+            const activeIds = new Set([...this.operationsBySession.values()].flat()
+                .map((operation) => operation.reservation.operationId));
+            for (const operationId of pendingIds) {
+                if (!activeIds.has(operationId))
+                    pendingIds.delete(operationId);
+            }
+            if (pendingIds.size > 0) {
+                await new Promise((resolve) => setTimeout(resolve, 50));
+            }
+        }
+        signalArg?.throwIfAborted();
+        return pendingIds.size === 0;
+    }
+    waitForUpgradeBarrier(barrierArg, timeoutMsArg, signalArg) {
+        return this.waitForOperationBarrier(barrierArg, timeoutMsArg, signalArg);
+    }
+    endOperationBarrier(barrierArg) {
+        this.assertOperationBarrier(barrierArg);
+        this.operationBarrier = undefined;
+    }
+    endUpgradeBarrier(barrierArg) {
+        this.endOperationBarrier(barrierArg);
+    }
+    async purgeSession(projectIdArg, sessionIdArg) {
+        const key = this.sessionKey(projectIdArg, sessionIdArg);
+        const operations = [...(this.operationsBySession.get(key) ?? [])];
+        await Promise.all(operations.map((active) => this.releaseActive(active)));
+        this.drafts.purge(key);
+    }
+    async releaseSession(projectIdArg, sessionIdArg) {
+        const operations = [
+            ...(this.operationsBySession.get(this.sessionKey(projectIdArg, sessionIdArg)) ?? []),
+        ];
+        await Promise.all(operations.map((active) => this.releaseActive(active)));
+    }
+    async purgeProject(projectIdArg) {
+        const prefix = `${projectIdArg}\0`;
+        const operations = [...this.operationsBySession.entries()]
+            .filter(([key]) => key.startsWith(prefix))
+            .flatMap(([, active]) => active);
+        await Promise.all(operations.map((active) => this.releaseActive(active)));
+        this.drafts.purgePrefix(prefix);
+    }
+    async releaseHarness(harnessIdArg) {
+        const operations = [...this.operationsBySession.values()].flat().filter((active) => active.reservation.sessionId.harnessId === harnessIdArg);
+        await Promise.all(operations.map((active) => this.releaseActive(active)));
+    }
+    async close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closed = true;
+        this.operationBarrier = undefined;
+        const closePromise = (async () => {
+            await Promise.allSettled([...this.operationsBySession.values()].map((operations) => Promise.all(operations.map((active) => this.releaseActive(active)))));
+            this.drafts.clear();
+            const errors = [];
+            try {
+                await this.waitForCleanup(this.uploads.close(), 'Harness upload-manager cleanup exceeded its deadline.');
+            }
+            catch (errorArg) {
+                errors.push(errorArg);
+            }
+            try {
+                await this.retryPendingUploadCleanups();
+            }
+            catch (errorArg) {
+                errors.push(errorArg);
+            }
+            if (errors.length > 0) {
+                throw new AggregateError(errors, 'Harness operation resource cleanup failed.');
+            }
+        })();
+        this.closePromise = closePromise;
+        try {
+            await closePromise;
+        }
+        catch (errorArg) {
+            if (this.closePromise === closePromise)
+                this.closePromise = undefined;
+            throw errorArg;
+        }
+    }
+    sessionKey(projectIdArg, sessionIdArg) {
+        return `${projectIdArg}\0${controllerRuntimeIdKey(sessionIdArg)}`;
+    }
+    assertOperationBarrier(barrierArg) {
+        if (!this.operationBarrier
+            || barrierArg.token !== this.operationBarrier.token
+            || barrierArg.harnessId !== this.operationBarrier.harnessId) {
+            throw new Error('The harness operation admission barrier is no longer authoritative.');
+        }
+    }
+    currentHarnessAdmissionGeneration(harnessIdArg) {
+        return this.harnessAdmissionGenerations.get(harnessIdArg) ?? 0;
+    }
+    assertHarnessAdmission(harnessIdArg, expectedGenerationArg) {
+        if (this.currentHarnessAdmissionGeneration(harnessIdArg) !== expectedGenerationArg) {
+            throw new ControllerHarnessOperationConflictError('The harness prompt belongs to a stale runtime generation.');
+        }
+        if (this.sealedHarnessAdmissions.has(harnessIdArg)
+            || (this.operationBarrier
+                && (this.operationBarrier.harnessId === undefined
+                    || this.operationBarrier.harnessId === harnessIdArg))) {
+            throw new ControllerHarnessOperationConflictError('Harness prompt admission is temporarily sealed.');
+        }
+    }
+    flexQueueKey(projectIdArg, sessionIdArg, queueIdArg) {
+        return `${this.sessionKey(projectIdArg, sessionIdArg)}\0${queueIdArg}`;
+    }
+    openCodeMessageKey(projectIdArg, sessionIdArg, messageIdArg) {
+        return `${this.sessionKey(projectIdArg, sessionIdArg)}\0${controllerRuntimeIdKey(messageIdArg)}`;
+    }
+    findActive(reservationArg) {
+        const operations = this.operationsBySession.get(this.sessionKey(reservationArg.projectId, reservationArg.sessionId));
+        return operations?.find((active) => active.reservation.operationId === reservationArg.operationId);
+    }
+    requireActive(reservationArg) {
+        const active = this.findActive(reservationArg);
+        if (!active)
+            throw new Error('The harness operation reservation is no longer active.');
+        return active;
+    }
+    async releaseActive(activeArg) {
+        if (activeArg.releasePromise)
+            return activeArg.releasePromise;
+        const releasePromise = (async () => {
+            if (activeArg.upload)
+                await this.cleanupUpload(activeArg, activeArg.upload);
+            this.finalizeRelease(activeArg);
+        })();
+        activeArg.releasePromise = releasePromise;
+        try {
+            await releasePromise;
+        }
+        finally {
+            if (activeArg.releasePromise === releasePromise)
+                activeArg.releasePromise = undefined;
+        }
+    }
+    async waitForCleanup(cleanupArg, messageArg) {
+        let timeout;
+        try {
+            await Promise.race([
+                cleanupArg,
+                new Promise((_resolve, reject) => {
+                    timeout = setTimeout(() => reject(new Error(messageArg)), this.cleanupTimeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+        }
+    }
+    finalizeRelease(activeArg) {
+        const key = this.sessionKey(activeArg.reservation.projectId, activeArg.reservation.sessionId);
+        const operations = this.operationsBySession.get(key);
+        const operationIndex = operations?.indexOf(activeArg) ?? -1;
+        const wasActive = operations !== undefined && operationIndex >= 0;
+        if (operations && operationIndex >= 0) {
+            operations.splice(operationIndex, 1);
+            this.activeOperationCount -= 1;
+            if (operations.length === 0)
+                this.operationsBySession.delete(key);
+        }
+        if (activeArg.flexQueueKey
+            && this.operationsByFlexQueue.get(activeArg.flexQueueKey) === activeArg)
+            this.operationsByFlexQueue.delete(activeArg.flexQueueKey);
+        const messageId = activeArg.reservation.messageId;
+        if (messageId?.harnessId === 'opencode') {
+            const messageKey = this.openCodeMessageKey(activeArg.reservation.projectId, activeArg.reservation.sessionId, messageId);
+            if (this.operationsByOpenCodeMessage.get(messageKey) === activeArg) {
+                this.operationsByOpenCodeMessage.delete(messageKey);
+            }
+        }
+        if (!wasActive)
+            return;
+        queueMicrotask(() => {
+            try {
+                this.options.onOperationReleased?.(cloneReservation(activeArg.reservation));
+            }
+            catch {
+                // Release ownership must not depend on observer behavior.
+            }
+        });
+    }
+    cleanupUpload(activeArg, uploadArg) {
+        const operationId = activeArg.reservation.operationId;
+        let pending = this.pendingUploadCleanups.get(operationId);
+        if (!pending) {
+            pending = { active: activeArg, upload: uploadArg };
+            this.pendingUploadCleanups.set(operationId, pending);
+        }
+        if (!pending.cleanupPromise) {
+            const cleanupPromise = pending.upload.cleanup().then(() => {
+                if (pending.active.upload === pending.upload)
+                    pending.active.upload = undefined;
+                if (this.pendingUploadCleanups.get(operationId) === pending) {
+                    this.pendingUploadCleanups.delete(operationId);
+                }
+                this.finalizeRelease(pending.active);
+            }).finally(() => {
+                if (pending.cleanupPromise === cleanupPromise)
+                    pending.cleanupPromise = undefined;
+            });
+            pending.cleanupPromise = cleanupPromise;
+        }
+        return this.waitForCleanup(pending.cleanupPromise, 'Harness operation upload cleanup exceeded its deadline.');
+    }
+    async retryPendingUploadCleanup(operationIdArg) {
+        const pending = this.pendingUploadCleanups.get(operationIdArg);
+        if (pending)
+            await this.releaseActive(pending.active);
+    }
+    async retryPendingUploadCleanups() {
+        const results = await Promise.allSettled([...this.pendingUploadCleanups.values()].map((pending) => this.releaseActive(pending.active)));
+        const errors = results
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length > 0) {
+            throw new AggregateError(errors, 'Harness operation upload cleanup retry failed.');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.harnessoperationmanager.js","sourceRoot":"","sources":["../../ts/classes.harnessoperationmanager.ts"],"names":[],"mappings":"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"}