devchain-cli 0.24.2 → 0.25.0

package/dist/server/modules/storage/local/local-storage.service.js

@@ -17,935 +17,144 @@ const common_1 = require("@nestjs/common");
 const better_sqlite3_1 = require("drizzle-orm/better-sqlite3");
 const db_provider_1 = require("../db/db.provider");
 const logger_1 = require("../../../common/logging/logger");
-const feature_flags_1 = require("../../../common/config/feature-flags");
 const base_storage_delegate_1 = require("./delegates/base-storage.delegate");
-const agent_delegate_1 = require("./delegates/agent.delegate");
-const agent_profile_delegate_1 = require("./delegates/agent-profile.delegate");
-const epic_delegate_1 = require("./delegates/epic.delegate");
-const guest_delegate_1 = require("./delegates/guest.delegate");
-const profile_provider_config_delegate_1 = require("./delegates/profile-provider-config.delegate");
-const prompt_delegate_1 = require("./delegates/prompt.delegate");
-const provider_delegate_1 = require("./delegates/provider.delegate");
-const provider_model_delegate_1 = require("./delegates/provider-model.delegate");
-const provider_effort_delegate_1 = require("./delegates/provider-effort.delegate");
-const provider_plugin_policy_delegate_1 = require("./delegates/provider-plugin-policy.delegate");
 const project_delegate_1 = require("./delegates/project.delegate");
 const project_workspace_delegate_1 = require("./delegates/project-workspace.delegate");
-const record_delegate_1 = require("./delegates/record.delegate");
 const remote_delegate_1 = require("./delegates/remote.delegate");
 const provider_auth_delegate_1 = require("./delegates/provider-auth.delegate");
 const project_replica_read_delegate_1 = require("./delegates/project-replica-read.delegate");
 const project_replica_delegate_1 = require("./delegates/project-replica.delegate");
 const project_host_delegate_1 = require("./delegates/project-host.delegate");
-const review_delegate_1 = require("./delegates/review.delegate");
-const skill_source_delegate_1 = require("./delegates/skill-source.delegate");
 const status_delegate_1 = require("./delegates/status.delegate");
-const subscriber_delegate_1 = require("./delegates/subscriber.delegate");
+const epic_delegate_1 = require("./delegates/epic.delegate");
 const tag_delegate_1 = require("./delegates/tag.delegate");
+const prompt_delegate_1 = require("./delegates/prompt.delegate");
+const provider_delegate_1 = require("./delegates/provider.delegate");
+const skill_source_delegate_1 = require("./delegates/skill-source.delegate");
+const agent_profile_delegate_1 = require("./delegates/agent-profile.delegate");
+const profile_provider_config_delegate_1 = require("./delegates/profile-provider-config.delegate");
+const agent_delegate_1 = require("./delegates/agent.delegate");
+const record_delegate_1 = require("./delegates/record.delegate");
+const watcher_delegate_1 = require("./delegates/watcher.delegate");
+const subscriber_delegate_1 = require("./delegates/subscriber.delegate");
+const guest_delegate_1 = require("./delegates/guest.delegate");
+const review_delegate_1 = require("./delegates/review.delegate");
+const provider_model_delegate_1 = require("./delegates/provider-model.delegate");
+const provider_effort_delegate_1 = require("./delegates/provider-effort.delegate");
+const provider_plugin_policy_delegate_1 = require("./delegates/provider-plugin-policy.delegate");
 const scheduled_epic_delegate_1 = require("./delegates/scheduled-epic.delegate");
 const session_delegate_1 = require("./delegates/session.delegate");
 const integration_delegate_1 = require("./delegates/integration.delegate");
-const integration_credential_cipher_1 = require("./integration-credential-cipher");
-const watcher_delegate_1 = require("./delegates/watcher.delegate");
 const external_managed_subtask_delegate_1 = require("./delegates/external-managed-subtask.delegate");
 const external_estimate_log_delegate_1 = require("./delegates/external-estimate-log.delegate");
+const integration_credential_cipher_1 = require("./integration-credential-cipher");
 const committed_event_store_1 = require("../../events/services/committed-event.store");
 const durable_event_registry_service_1 = require("../../events/services/durable-event-registry.service");
+const storage_routes_1 = require("./storage-routes");
+const project_write_gate_1 = require("../write-gate/project-write-gate");
+const storage_write_scope_1 = require("../write-gate/storage-write-scope");
 const logger = (0, logger_1.createLogger)('LocalStorageService');
 let LocalStorageService = class LocalStorageService {
-    db;
-    projectDelegate;
-    projectWorkspaceDelegate;
-    remoteDelegate;
-    providerAuthDelegate;
-    projectReplicaReadDelegate;
-    projectReplicaDelegate;
-    projectHostDelegate;
-    statusDelegate;
-    epicDelegate;
-    tagDelegate;
-    promptDelegate;
-    providerDelegate;
-    skillSourceDelegate;
-    agentProfileDelegate;
-    profileProviderConfigDelegate;
-    agentDelegate;
-    recordDelegate;
-    watcherDelegate;
-    subscriberDelegate;
-    guestDelegate;
-    reviewDelegate;
-    providerModelDelegate;
-    providerEffortDelegate;
-    providerPluginPolicyDelegate;
-    scheduledEpicDelegate;
-    sessionDelegate;
-    integrationDelegate;
-    externalManagedSubtaskDelegate;
-    externalEstimateLogDelegate;
-    constructor(db, integrationCredentialCipher, committedEventStore) {
-        this.db = db;
-        const context = (0, base_storage_delegate_1.createStorageDelegateContext)(this.db);
-        const eventStore = committedEventStore ?? new committed_event_store_1.CommittedEventStore(this.db, new durable_event_registry_service_1.DurableEventRegistryService());
-        this.projectDelegate = new project_delegate_1.ProjectStorageDelegate(context);
-        this.projectWorkspaceDelegate = new project_workspace_delegate_1.ProjectWorkspaceStorageDelegate(context);
+    constructor(db, integrationCredentialCipher, committedEventStore, gate) {
+        const context = (0, base_storage_delegate_1.createStorageDelegateContext)(db);
+        const eventStore = committedEventStore ?? new committed_event_store_1.CommittedEventStore(db, new durable_event_registry_service_1.DurableEventRegistryService());
         const credentialCipher = integrationCredentialCipher ?? new integration_credential_cipher_1.IntegrationCredentialCipher();
-        this.remoteDelegate = new remote_delegate_1.RemoteStorageDelegate(context, credentialCipher);
-        this.providerAuthDelegate = new provider_auth_delegate_1.ProviderAuthStorageDelegate(context, credentialCipher);
-        this.projectReplicaReadDelegate = new project_replica_read_delegate_1.ProjectReplicaReadStorageDelegate(context);
-        this.projectReplicaDelegate = new project_replica_delegate_1.ProjectReplicaStorageDelegate(context, {
-            appendEvent: (event) => eventStore.appendInCurrentTransaction(event),
-        });
-        this.projectHostDelegate = new project_host_delegate_1.ProjectHostStorageDelegate(context);
-        this.statusDelegate = new status_delegate_1.StatusStorageDelegate(context);
-        this.tagDelegate = new tag_delegate_1.TagStorageDelegate(context);
-        const createTag = (data) => this.tagDelegate.createTagSync(data);
-        this.promptDelegate = new prompt_delegate_1.PromptStorageDelegate(context, {
-            createTag,
-        });
-        this.epicDelegate = new epic_delegate_1.EpicStorageDelegate(context, {
-            createTag,
-            getAgent: (id) => this.agentDelegate.getAgentSync(id),
-            getAgentByName: (projectId, name) => this.getAgentByName(projectId, name),
-            getStatus: (id) => this.statusDelegate.getStatus(id),
-            appendEvent: (event) => eventStore.appendInCurrentTransaction(event),
-        });
-        this.providerDelegate = new provider_delegate_1.ProviderStorageDelegate(context, {
-            updateProvider: (id, data) => this.updateProvider(id, data),
-        });
-        this.providerModelDelegate = new provider_model_delegate_1.ProviderModelStorageDelegate(context);
-        this.providerEffortDelegate = new provider_effort_delegate_1.ProviderEffortStorageDelegate(context);
-        this.providerPluginPolicyDelegate = new provider_plugin_policy_delegate_1.ProviderPluginPolicyStorageDelegate(context);
-        this.skillSourceDelegate = new skill_source_delegate_1.SkillSourceStorageDelegate(context);
-        this.agentProfileDelegate = new agent_profile_delegate_1.AgentProfileStorageDelegate(context, {
-            getAgentProfile: (id) => this.getAgentProfile(id),
-            listAgentProfiles: (options) => this.listAgentProfiles(options),
-        });
-        this.profileProviderConfigDelegate = new profile_provider_config_delegate_1.ProfileProviderConfigStorageDelegate(context, {
-            getProfileProviderConfig: (id) => this.getProfileProviderConfig(id),
-        });
-        this.agentDelegate = new agent_delegate_1.AgentStorageDelegate(context, {
-            getAgent: (id) => this.getAgent(id),
-            getAgentProfile: (id) => this.getAgentProfile(id),
-            getProfileProviderConfig: (id) => this.getProfileProviderConfig(id),
-        });
-        this.recordDelegate = new record_delegate_1.RecordStorageDelegate(context, {
-            createTag,
-        });
-        this.watcherDelegate = new watcher_delegate_1.WatcherStorageDelegate(context);
-        this.subscriberDelegate = new subscriber_delegate_1.SubscriberStorageDelegate(context);
-        this.guestDelegate = new guest_delegate_1.GuestStorageDelegate(context);
-        this.reviewDelegate = new review_delegate_1.ReviewStorageDelegate(context);
-        this.scheduledEpicDelegate = new scheduled_epic_delegate_1.ScheduledEpicStorageDelegate(context);
-        this.sessionDelegate = new session_delegate_1.SessionStorageDelegate(context);
-        this.externalManagedSubtaskDelegate = new external_managed_subtask_delegate_1.ExternalManagedSubtaskStorageDelegate(context);
-        this.externalEstimateLogDelegate = new external_estimate_log_delegate_1.ExternalEstimateLogStorageDelegate(context);
-        this.integrationDelegate = new integration_delegate_1.IntegrationStorageDelegate(context, integrationCredentialCipher ?? new integration_credential_cipher_1.IntegrationCredentialCipher(), {
-            createEpicInCurrentTransaction: (data) => this.epicDelegate.createEpicInCurrentTransaction(data),
-            getEpic: (id) => this.epicDelegate.getEpic(id),
-            appendEvent: (event) => eventStore.appendInCurrentTransaction(event),
-            handleConnectionMutation: (connectionId, provider, acknowledgeOrphanRisk) => this.externalManagedSubtaskDelegate.handleConnectionMutationSync(connectionId, provider, acknowledgeOrphanRisk),
-        });
+        const createTag = (data) => delegates.tag.createTagSync(data);
+        const delegates = {
+            project: new project_delegate_1.ProjectStorageDelegate(context),
+            projectWorkspace: new project_workspace_delegate_1.ProjectWorkspaceStorageDelegate(context),
+            remote: new remote_delegate_1.RemoteStorageDelegate(context, credentialCipher),
+            providerAuth: new provider_auth_delegate_1.ProviderAuthStorageDelegate(context, credentialCipher),
+            projectReplicaRead: new project_replica_read_delegate_1.ProjectReplicaReadStorageDelegate(context),
+            projectReplica: new project_replica_delegate_1.ProjectReplicaStorageDelegate(context, {
+                appendEvent: (event) => eventStore.appendInCurrentTransaction(event),
+            }),
+            projectHost: new project_host_delegate_1.ProjectHostStorageDelegate(context),
+            status: new status_delegate_1.StatusStorageDelegate(context),
+            tag: new tag_delegate_1.TagStorageDelegate(context),
+            prompt: new prompt_delegate_1.PromptStorageDelegate(context, {
+                createTag,
+            }),
+            epic: new epic_delegate_1.EpicStorageDelegate(context, {
+                createTag,
+                getAgent: (id) => delegates.agent.getAgentSync(id),
+                getAgentByName: (projectId, name) => delegates.agent.getAgentByName(projectId, name),
+                getStatus: (id) => delegates.status.getStatus(id),
+                appendEvent: (event) => eventStore.appendInCurrentTransaction(event),
+            }),
+            provider: new provider_delegate_1.ProviderStorageDelegate(context, {
+                updateProvider: (id, data) => delegates.provider.updateProvider(id, data),
+            }),
+            providerModel: new provider_model_delegate_1.ProviderModelStorageDelegate(context),
+            providerEffort: new provider_effort_delegate_1.ProviderEffortStorageDelegate(context),
+            providerPluginPolicy: new provider_plugin_policy_delegate_1.ProviderPluginPolicyStorageDelegate(context),
+            skillSource: new skill_source_delegate_1.SkillSourceStorageDelegate(context, gate),
+            agentProfile: new agent_profile_delegate_1.AgentProfileStorageDelegate(context, {
+                getAgentProfile: (id) => delegates.agentProfile.getAgentProfile(id),
+                listAgentProfiles: (options) => delegates.agentProfile.listAgentProfiles(options),
+            }),
+            profileProviderConfig: new profile_provider_config_delegate_1.ProfileProviderConfigStorageDelegate(context, {
+                getProfileProviderConfig: (id) => delegates.profileProviderConfig.getProfileProviderConfig(id),
+            }),
+            agent: new agent_delegate_1.AgentStorageDelegate(context, {
+                getAgent: (id) => delegates.agent.getAgent(id),
+                getAgentProfile: (id) => delegates.agentProfile.getAgentProfile(id),
+                getProfileProviderConfig: (id) => delegates.profileProviderConfig.getProfileProviderConfig(id),
+            }),
+            record: new record_delegate_1.RecordStorageDelegate(context, {
+                createTag,
+            }),
+            watcher: new watcher_delegate_1.WatcherStorageDelegate(context),
+            subscriber: new subscriber_delegate_1.SubscriberStorageDelegate(context),
+            guest: new guest_delegate_1.GuestStorageDelegate(context),
+            review: new review_delegate_1.ReviewStorageDelegate(context),
+            scheduledEpic: new scheduled_epic_delegate_1.ScheduledEpicStorageDelegate(context),
+            session: new session_delegate_1.SessionStorageDelegate(context),
+            externalManagedSubtask: new external_managed_subtask_delegate_1.ExternalManagedSubtaskStorageDelegate(context),
+            externalEstimateLog: new external_estimate_log_delegate_1.ExternalEstimateLogStorageDelegate(context),
+            integration: new integration_delegate_1.IntegrationStorageDelegate(context, credentialCipher, {
+                createEpicWithinTransaction: (data) => delegates.epic.createEpicWithinTransaction(data),
+                getEpic: (id) => delegates.epic.getEpic(id),
+                appendEvent: (event) => eventStore.appendInCurrentTransaction(event),
+                handleConnectionMutation: (connectionId, provider, acknowledgeOrphanRisk) => delegates.externalManagedSubtask.handleConnectionMutationSync(connectionId, provider, acknowledgeOrphanRisk),
+            }),
+        };
+        const lookup = new storage_write_scope_1.ProjectWriteLookup(context.rawClient);
+        for (const method of Object.keys(storage_routes_1.STORAGE_ROUTES)) {
+            const route = storage_routes_1.STORAGE_ROUTES[method];
+            const delegate = delegates[route.delegate];
+            const implementation = delegate[method];
+            if (typeof implementation !== 'function') {
+                throw new Error(`Storage route ${method} does not resolve to a function`);
+            }
+            const bound = implementation.bind(delegate);
+            const scope = route.scope;
+            const resolve = typeof scope === 'function' ? scope : null;
+            const value = resolve && gate
+                ? (...args) => {
+                    if (!gate.hasBlockedProjects())
+                        return bound(...args);
+                    try {
+                        for (const projectId of resolve(args, lookup)) {
+                            if (projectId !== null)
+                                gate.assertWritable(projectId);
+                        }
+                    }
+                    catch (error) {
+                        return Promise.reject(error);
+                    }
+                    return bound(...args);
+                }
+                : bound;
+            Object.defineProperty(this, method, {
+                value,
+                configurable: true,
+                enumerable: true,
+                writable: true,
+            });
+        }
         logger.info('LocalStorageService initialized');
     }
-    getFeatureFlags() {
-        return { ...feature_flags_1.DEFAULT_FEATURE_FLAGS };
-    }
-    async createProject(data) {
-        return this.projectDelegate.createProject(data);
-    }
-    runInTransaction(fn) {
-        return this.projectDelegate.runInTransaction(fn);
-    }
-    async createProjectShell(data, options) {
-        return this.projectDelegate.createProjectShell(data, options);
-    }
-    async getProject(id) {
-        return this.projectDelegate.getProject(id);
-    }
-    async findProjectByPath(path) {
-        return this.projectDelegate.findProjectByPath(path);
-    }
-    async listProjects(options = {}) {
-        return this.projectDelegate.listProjects(options);
-    }
-    async getProjectsByIdPrefix(prefix) {
-        return this.projectDelegate.getProjectsByIdPrefix(prefix);
-    }
-    async getProjectWorkspaceSnapshot(projectId) {
-        return this.projectDelegate.getProjectWorkspaceSnapshot(projectId);
-    }
-    async updateProject(id, data) {
-        return this.projectDelegate.updateProject(id, data);
-    }
-    async deleteProject(id) {
-        return this.projectDelegate.deleteProject(id);
-    }
-    async listProjectWorkspaces() {
-        return this.projectWorkspaceDelegate.listProjectWorkspaces();
-    }
-    async getProjectWorkspace(id) {
-        return this.projectWorkspaceDelegate.getProjectWorkspace(id);
-    }
-    async createProjectWorkspace(name) {
-        return this.projectWorkspaceDelegate.createProjectWorkspace(name);
-    }
-    async renameProjectWorkspace(id, name) {
-        return this.projectWorkspaceDelegate.renameProjectWorkspace(id, name);
-    }
-    async reorderProjectWorkspaces(workspaceIds) {
-        return this.projectWorkspaceDelegate.reorderProjectWorkspaces(workspaceIds);
-    }
-    async deleteProjectWorkspace(id, replacementId) {
-        return this.projectWorkspaceDelegate.deleteProjectWorkspace(id, replacementId);
-    }
-    async readRemoteApiKey(id) {
-        return this.remoteDelegate.readRemoteApiKey(id);
-    }
-    async saveRemoteApiKey(id, key, onlyIfAbsent = false) {
-        return this.remoteDelegate.saveRemoteApiKey(id, key, onlyIfAbsent);
-    }
-    async createRemote(data) {
-        return this.remoteDelegate.createRemote(data);
-    }
-    async getRemote(id) {
-        return this.remoteDelegate.getRemote(id);
-    }
-    async listRemotes(options = {}) {
-        return this.remoteDelegate.listRemotes(options);
-    }
-    async updateRemoteName(id, name) {
-        return this.remoteDelegate.updateRemoteName(id, name);
-    }
-    async updateRemoteBaseUrl(id, baseUrl) {
-        return this.remoteDelegate.updateRemoteBaseUrl(id, baseUrl);
-    }
-    async updateRemoteVmIdentity(id, vmIdentity) {
-        return this.remoteDelegate.updateRemoteVmIdentity(id, vmIdentity);
-    }
-    async updateRemoteTlsCertificate(id, certificate) {
-        return this.remoteDelegate.updateRemoteTlsCertificate(id, certificate);
-    }
-    async createVmProviderConnection(data) {
-        return this.remoteDelegate.createVmProviderConnection(data);
-    }
-    async listVmProviderConnections() {
-        return this.remoteDelegate.listVmProviderConnections();
-    }
-    async getVmProviderConnection(id) {
-        return this.remoteDelegate.getVmProviderConnection(id);
-    }
-    async readVmProviderTokenSecret(id) {
-        return this.remoteDelegate.readVmProviderTokenSecret(id);
-    }
-    async deleteVmProviderConnection(id) {
-        return this.remoteDelegate.deleteVmProviderConnection(id);
-    }
-    async deleteRemote(id) {
-        return this.remoteDelegate.deleteRemote(id);
-    }
-    async listProviderAuthEntries() {
-        return this.providerAuthDelegate.listProviderAuthEntries();
-    }
-    async getProviderAuthEntry(id) {
-        return this.providerAuthDelegate.getProviderAuthEntry(id);
-    }
-    async readProviderAuthPayload(id) {
-        return this.providerAuthDelegate.readProviderAuthPayload(id);
-    }
-    async createProviderAuthEntry(data) {
-        return this.providerAuthDelegate.createProviderAuthEntry(data);
-    }
-    async deleteProviderAuthEntry(id) {
-        return this.providerAuthDelegate.deleteProviderAuthEntry(id);
-    }
-    async updateProviderAuthPayload(id, payload) {
-        return this.providerAuthDelegate.updateProviderAuthPayload(id, payload);
-    }
-    async renameProviderAuthEntry(id, label) {
-        return this.providerAuthDelegate.renameProviderAuthEntry(id, label);
-    }
-    async checkoutProviderAuthEntry(id, remoteId) {
-        return this.providerAuthDelegate.checkoutProviderAuthEntry(id, remoteId);
-    }
-    async releaseProviderAuthEntry(id) {
-        return this.providerAuthDelegate.releaseProviderAuthEntry(id);
-    }
-    async listRemoteProjectBindings() {
-        return this.remoteDelegate.listRemoteProjectBindings();
-    }
-    async getRemoteProjectBinding(projectId) {
-        return this.remoteDelegate.getRemoteProjectBinding(projectId);
-    }
-    async createRemoteProjectBinding(data) {
-        return this.remoteDelegate.createRemoteProjectBinding(data);
-    }
-    async updateRemoteProjectBinding(projectId, data) {
-        return this.remoteDelegate.updateRemoteProjectBinding(projectId, data);
-    }
-    async deleteRemoteProjectBinding(projectId) {
-        return this.remoteDelegate.deleteRemoteProjectBinding(projectId);
-    }
-    async createRemoteOperation(data) {
-        return this.remoteDelegate.createRemoteOperation(data);
-    }
-    async getRemoteOperation(id) {
-        return this.remoteDelegate.getRemoteOperation(id);
-    }
-    async listRemoteOperations(filter) {
-        return this.remoteDelegate.listRemoteOperations(filter);
-    }
-    async updateRemoteOperation(id, data) {
-        return this.remoteDelegate.updateRemoteOperation(id, data);
-    }
-    async readProjectReplicaSource(projectIds, options) {
-        return this.projectReplicaReadDelegate.readProjectReplicaSource(projectIds, options);
-    }
-    async applyProjectReplica(replica, mode, eventFactory, options) {
-        return this.projectReplicaDelegate.applyProjectReplica(replica, mode, eventFactory, options);
-    }
-    async setProjectFrozen(projectId, frozenAt) {
-        return this.projectHostDelegate.setProjectFrozen(projectId, frozenAt);
-    }
-    async listFrozenProjects() {
-        return this.projectHostDelegate.listFrozenProjects();
-    }
-    async releaseProject(projectId) {
-        return this.projectHostDelegate.releaseProject(projectId);
-    }
-    async findEpicIdByIdempotencyKey(projectId, key) {
-        return this.projectHostDelegate.findEpicIdByIdempotencyKey(projectId, key);
-    }
-    async createStatus(data) {
-        return this.statusDelegate.createStatus(data);
-    }
-    async getStatus(id) {
-        return this.statusDelegate.getStatus(id);
-    }
-    async listStatuses(projectId, options = {}) {
-        return this.statusDelegate.listStatuses(projectId, options);
-    }
-    async findStatusByName(projectId, name) {
-        return this.statusDelegate.findStatusByName(projectId, name);
-    }
-    async updateStatus(id, data) {
-        return this.statusDelegate.updateStatus(id, data);
-    }
-    async deleteStatus(id) {
-        return this.statusDelegate.deleteStatus(id);
-    }
-    async createEpic(data, eventFactory) {
-        return this.epicDelegate.createEpic(data, eventFactory);
-    }
-    async createEpicWithinTransaction(data, eventFactory, beforeEventAppend) {
-        return this.epicDelegate.createEpicInCurrentTransaction(data, eventFactory, beforeEventAppend);
-    }
-    async getEpic(id) {
-        return this.epicDelegate.getEpic(id);
-    }
-    async listEpics(projectId, options = {}) {
-        return this.epicDelegate.listEpics(projectId, options);
-    }
-    async listEpicsByStatus(statusId, options = {}) {
-        return this.epicDelegate.listEpicsByStatus(statusId, options);
-    }
-    async listProjectEpics(projectId, options = {}) {
-        return this.epicDelegate.listProjectEpics(projectId, options);
-    }
-    async listAssignedEpics(projectId, options) {
-        return this.epicDelegate.listAssignedEpics(projectId, options);
-    }
-    async createEpicForProject(projectId, input, eventFactory) {
-        return this.epicDelegate.createEpicForProject(projectId, input, eventFactory);
-    }
-    async updateEpic(id, data, expectedVersion, eventFactory) {
-        return this.epicDelegate.updateEpic(id, data, expectedVersion, eventFactory);
-    }
-    async deleteEpic(id, eventFactory) {
-        return this.epicDelegate.deleteEpic(id, eventFactory);
-    }
-    async listSubEpics(parentId, options = {}) {
-        return this.epicDelegate.listSubEpics(parentId, options);
-    }
-    async listParentChildren(parentId, options = {}) {
-        return this.epicDelegate.listParentChildren(parentId, options);
-    }
-    async listSubEpicsForParents(projectId, parentIds, options = {}) {
-        return this.epicDelegate.listSubEpicsForParents(projectId, parentIds, options);
-    }
-    async countSubEpicsByStatus(parentId) {
-        return this.epicDelegate.countSubEpicsByStatus(parentId);
-    }
-    async countEpicsByStatus(statusId) {
-        return this.epicDelegate.countEpicsByStatus(statusId);
-    }
-    async updateEpicsStatus(oldStatusId, newStatusId) {
-        return this.epicDelegate.updateEpicsStatus(oldStatusId, newStatusId);
-    }
-    async listEpicComments(epicId, options = {}) {
-        return this.epicDelegate.listEpicComments(epicId, options);
-    }
-    async createEpicComment(data, eventFactory) {
-        return this.epicDelegate.createEpicComment(data, eventFactory);
-    }
-    async deleteEpicComment(id) {
-        return this.epicDelegate.deleteEpicComment(id);
-    }
-    async findEpicCommentEpicId(commentId) {
-        return this.epicDelegate.findEpicCommentEpicId(commentId);
-    }
-    async deleteEpicCommentScoped(epicId, commentId) {
-        return this.epicDelegate.deleteEpicCommentScoped(epicId, commentId);
-    }
-    async getEpicsByIdPrefix(projectId, prefix) {
-        return this.epicDelegate.getEpicsByIdPrefix(projectId, prefix);
-    }
-    async setEpicRelation(data, context = { trustedLocalHuman: true }) {
-        return this.epicDelegate.setEpicRelation(data, context);
-    }
-    async deleteEpicRelation(epicId, relatedEpicId, context = { trustedLocalHuman: true }) {
-        return this.epicDelegate.deleteEpicRelation(epicId, relatedEpicId, context);
-    }
-    async listEpicRelations(epicId, options = {}) {
-        return this.epicDelegate.listEpicRelations(epicId, options);
-    }
-    async summarizeEpicRelationsBatch(epicIds, options = {}) {
-        return this.epicDelegate.summarizeEpicRelationsBatch(epicIds, options);
-    }
-    async listEpicRelationCandidates(epicId, options = {}) {
-        return this.epicDelegate.listEpicRelationCandidates(epicId, options);
-    }
-    async getWorkspaceEpicsByIdPrefix(epicId, prefix, options = {}) {
-        return this.epicDelegate.getWorkspaceEpicsByIdPrefix(epicId, prefix, options);
-    }
-    async createPrompt(data) {
-        return this.promptDelegate.createPrompt(data);
-    }
-    async createPromptFromSnapshot(data) {
-        return this.promptDelegate.createPromptFromSnapshot(data);
-    }
-    async getPrompt(id) {
-        return this.promptDelegate.getPrompt(id);
-    }
-    async listPrompts(filters = {}) {
-        return this.promptDelegate.listPrompts(filters);
-    }
-    async updatePrompt(id, data, expectedVersion) {
-        return this.promptDelegate.updatePrompt(id, data, expectedVersion);
-    }
-    async deletePrompt(id) {
-        return this.promptDelegate.deletePrompt(id);
-    }
-    async getInitialSessionPrompt(projectId) {
-        return this.promptDelegate.getInitialSessionPrompt(projectId);
-    }
-    async createTag(data) {
-        return this.tagDelegate.createTag(data);
-    }
-    async getTag(id) {
-        return this.tagDelegate.getTag(id);
-    }
-    async listTags(projectId, options = {}) {
-        return this.tagDelegate.listTags(projectId, options);
-    }
-    async updateTag(id, data) {
-        return this.tagDelegate.updateTag(id, data);
-    }
-    async deleteTag(id) {
-        return this.tagDelegate.deleteTag(id);
-    }
-    async createProvider(data) {
-        return this.providerDelegate.createProvider(data);
-    }
-    async createProviderModel(data) {
-        return this.providerModelDelegate.createProviderModel(data);
-    }
-    async listProviderModelsByProvider(providerId) {
-        return this.providerModelDelegate.listProviderModelsByProvider(providerId);
-    }
-    async listProviderModelsByProviderIds(providerIds) {
-        return this.providerModelDelegate.listProviderModelsByProviderIds(providerIds);
-    }
-    async deleteProviderModel(id) {
-        return this.providerModelDelegate.deleteProviderModel(id);
-    }
-    async bulkCreateProviderModels(providerId, names) {
-        return this.providerModelDelegate.bulkCreateProviderModels(providerId, names);
-    }
-    async createProviderEffort(data) {
-        return this.providerEffortDelegate.createProviderEffort(data);
-    }
-    async listProviderEffortsByProvider(providerId) {
-        return this.providerEffortDelegate.listProviderEffortsByProvider(providerId);
-    }
-    async listProviderEffortsByProviderIds(providerIds) {
-        return this.providerEffortDelegate.listProviderEffortsByProviderIds(providerIds);
-    }
-    async deleteProviderEffort(id) {
-        return this.providerEffortDelegate.deleteProviderEffort(id);
-    }
-    async bulkCreateProviderEfforts(providerId, names) {
-        return this.providerEffortDelegate.bulkCreateProviderEfforts(providerId, names);
-    }
-    async getProvider(id) {
-        return this.providerDelegate.getProvider(id);
-    }
-    async listProviders(options = {}) {
-        return this.providerDelegate.listProviders(options);
-    }
-    async listProvidersByIds(ids) {
-        return this.providerDelegate.listProvidersByIds(ids);
-    }
-    async updateProvider(id, data) {
-        return this.providerDelegate.updateProvider(id, data);
-    }
-    async deleteProvider(id) {
-        return this.providerDelegate.deleteProvider(id);
-    }
-    async upsertProviderPluginDefault(data) {
-        return this.providerPluginPolicyDelegate.upsertProviderPluginDefault(data);
-    }
-    async getProviderPluginDefault(providerId, pluginId) {
-        return this.providerPluginPolicyDelegate.getProviderPluginDefault(providerId, pluginId);
-    }
-    async listProviderPluginDefaults(providerId) {
-        return this.providerPluginPolicyDelegate.listProviderPluginDefaults(providerId);
-    }
-    async deleteProviderPluginDefault(providerId, pluginId) {
-        return this.providerPluginPolicyDelegate.deleteProviderPluginDefault(providerId, pluginId);
-    }
-    async upsertProjectProviderPluginOverride(data) {
-        return this.providerPluginPolicyDelegate.upsertProjectProviderPluginOverride(data);
-    }
-    async getProjectProviderPluginOverride(projectId, providerId, pluginId) {
-        return this.providerPluginPolicyDelegate.getProjectProviderPluginOverride(projectId, providerId, pluginId);
-    }
-    async listProjectProviderPluginOverrides(projectId, providerId) {
-        return this.providerPluginPolicyDelegate.listProjectProviderPluginOverrides(projectId, providerId);
-    }
-    async deleteProjectProviderPluginOverride(projectId, providerId, pluginId) {
-        return this.providerPluginPolicyDelegate.deleteProjectProviderPluginOverride(projectId, providerId, pluginId);
-    }
-    getProviderEnvForProject(providerId, projectId) {
-        return this.providerDelegate.getProviderEnvForProject(providerId, projectId);
-    }
-    listEnvScopesByProviderIds(providerIds) {
-        return this.providerDelegate.listEnvScopesByProviderIds(providerIds);
-    }
-    async updateProviderWithScopes(id, data, envScopes, currentEnvKeys) {
-        return Promise.resolve(this.providerDelegate.updateProviderWithScopes(id, data, envScopes, currentEnvKeys));
-    }
-    async getProviderMcpMetadata(id) {
-        return this.providerDelegate.getProviderMcpMetadata(id);
-    }
-    async updateProviderMcpMetadata(id, metadata) {
-        return this.providerDelegate.updateProviderMcpMetadata(id, metadata);
-    }
-    async getSourceProjectEnabled(projectId, sourceName) {
-        return this.skillSourceDelegate.getSourceProjectEnabled(projectId, sourceName);
-    }
-    async setSourceProjectEnabled(projectId, sourceName, enabled, options) {
-        return this.skillSourceDelegate.setSourceProjectEnabled(projectId, sourceName, enabled, options);
-    }
-    async listSourceProjectEnabled(projectId) {
-        return this.skillSourceDelegate.listSourceProjectEnabled(projectId);
-    }
-    async listCommunitySkillSources() {
-        return this.skillSourceDelegate.listCommunitySkillSources();
-    }
-    async getCommunitySkillSource(id) {
-        return this.skillSourceDelegate.getCommunitySkillSource(id);
-    }
-    async getCommunitySkillSourceByName(name) {
-        return this.skillSourceDelegate.getCommunitySkillSourceByName(name);
-    }
-    async createCommunitySkillSource(data, options) {
-        return this.skillSourceDelegate.createCommunitySkillSource(data, options);
-    }
-    async deleteCommunitySkillSource(id) {
-        return this.skillSourceDelegate.deleteCommunitySkillSource(id);
-    }
-    async listLocalSkillSources() {
-        return this.skillSourceDelegate.listLocalSkillSources();
-    }
-    async getLocalSkillSource(id) {
-        return this.skillSourceDelegate.getLocalSkillSource(id);
-    }
-    async getLocalSkillSourceByName(name) {
-        return this.skillSourceDelegate.getLocalSkillSourceByName(name);
-    }
-    async createLocalSkillSource(data, options) {
-        return this.skillSourceDelegate.createLocalSkillSource(data, options);
-    }
-    async deleteLocalSkillSource(id) {
-        return this.skillSourceDelegate.deleteLocalSkillSource(id);
-    }
-    async createAgentProfile(data) {
-        return this.agentProfileDelegate.createAgentProfile(data);
-    }
-    async getAgentProfile(id) {
-        return this.agentProfileDelegate.getAgentProfile(id);
-    }
-    async listAgentProfiles(options = {}) {
-        return this.agentProfileDelegate.listAgentProfiles(options);
-    }
-    async updateAgentProfile(id, data) {
-        return this.agentProfileDelegate.updateAgentProfile(id, data);
-    }
-    async deleteAgentProfile(id) {
-        return this.agentProfileDelegate.deleteAgentProfile(id);
-    }
-    async setAgentProfilePrompts(profileId, promptIdsOrdered) {
-        return this.agentProfileDelegate.setAgentProfilePrompts(profileId, promptIdsOrdered);
-    }
-    async getAgentProfilePrompts(profileId) {
-        return this.agentProfileDelegate.getAgentProfilePrompts(profileId);
-    }
-    async getAgentProfileWithPrompts(id) {
-        return this.agentProfileDelegate.getAgentProfileWithPrompts(id);
-    }
-    async listAgentProfilesWithPrompts(options = {}) {
-        return this.agentProfileDelegate.listAgentProfilesWithPrompts(options);
-    }
-    async createProfileProviderConfig(data) {
-        return this.profileProviderConfigDelegate.createProfileProviderConfig(data);
-    }
-    async createIfMissing(input) {
-        return this.profileProviderConfigDelegate.createIfMissing(input);
-    }
-    async getProfileProviderConfig(id) {
-        return this.profileProviderConfigDelegate.getProfileProviderConfig(id);
-    }
-    async listProfileProviderConfigsByProfile(profileId) {
-        return this.profileProviderConfigDelegate.listProfileProviderConfigsByProfile(profileId);
-    }
-    async listProfileProviderConfigsByIds(ids) {
-        return this.profileProviderConfigDelegate.listProfileProviderConfigsByIds(ids);
-    }
-    async listAllProfileProviderConfigs() {
-        return this.profileProviderConfigDelegate.listAllProfileProviderConfigs();
-    }
-    async updateProfileProviderConfig(id, data) {
-        return this.profileProviderConfigDelegate.updateProfileProviderConfig(id, data);
-    }
-    async deleteProfileProviderConfig(id) {
-        return this.profileProviderConfigDelegate.deleteProfileProviderConfig(id);
-    }
-    async reorderProfileProviderConfigs(profileId, configIds) {
-        return this.profileProviderConfigDelegate.reorderProfileProviderConfigs(profileId, configIds);
-    }
-    async createAgent(data) {
-        return this.agentDelegate.createAgent(data);
-    }
-    async getAgent(id) {
-        return this.agentDelegate.getAgent(id);
-    }
-    async listAgents(projectId, options = {}) {
-        return this.agentDelegate.listAgents(projectId, options);
-    }
-    async listProjectOwners(projectIds) {
-        return this.agentDelegate.listProjectOwners(projectIds);
-    }
-    async getAgentByName(projectId, name) {
-        return this.agentDelegate.getAgentByName(projectId, name);
-    }
-    async updateAgent(id, data) {
-        return this.agentDelegate.updateAgent(id, data);
-    }
-    async deleteAgent(id, options) {
-        return this.agentDelegate.deleteAgent(id, options);
-    }
-    async createRecord(data) {
-        return this.recordDelegate.createRecord(data);
-    }
-    async getRecord(id) {
-        return this.recordDelegate.getRecord(id);
-    }
-    async listRecords(epicId, options = {}) {
-        return this.recordDelegate.listRecords(epicId, options);
-    }
-    async updateRecord(id, data, expectedVersion) {
-        return this.recordDelegate.updateRecord(id, data, expectedVersion);
-    }
-    async deleteRecord(id) {
-        return this.recordDelegate.deleteRecord(id);
-    }
-    async listWatchers(projectId) {
-        return this.watcherDelegate.listWatchers(projectId);
-    }
-    async getWatcher(id) {
-        return this.watcherDelegate.getWatcher(id);
-    }
-    async createWatcher(data) {
-        return this.watcherDelegate.createWatcher(data);
-    }
-    async updateWatcher(id, data) {
-        return this.watcherDelegate.updateWatcher(id, data);
-    }
-    async deleteWatcher(id) {
-        return this.watcherDelegate.deleteWatcher(id);
-    }
-    async listEnabledWatchers() {
-        return this.watcherDelegate.listEnabledWatchers();
-    }
-    async listSubscribers(projectId) {
-        return this.subscriberDelegate.listSubscribers(projectId);
-    }
-    async getSubscriber(id) {
-        return this.subscriberDelegate.getSubscriber(id);
-    }
-    async createSubscriber(data) {
-        return this.subscriberDelegate.createSubscriber(data);
-    }
-    async updateSubscriber(id, data) {
-        return this.subscriberDelegate.updateSubscriber(id, data);
-    }
-    async deleteSubscriber(id) {
-        return this.subscriberDelegate.deleteSubscriber(id);
-    }
-    async findSubscribersByEventName(projectId, eventName) {
-        return this.subscriberDelegate.findSubscribersByEventName(projectId, eventName);
-    }
-    async getProjectByRootPath(rootPath) {
-        return this.projectDelegate.getProjectByRootPath(rootPath);
-    }
-    async findProjectContainingPath(absolutePath) {
-        return this.projectDelegate.findProjectContainingPath(absolutePath);
-    }
-    async createGuest(data) {
-        return this.guestDelegate.createGuest(data);
-    }
-    async getGuest(id) {
-        return this.guestDelegate.getGuest(id);
-    }
-    async getGuestByName(projectId, name) {
-        return this.guestDelegate.getGuestByName(projectId, name);
-    }
-    async getGuestByTmuxSessionId(tmuxSessionId) {
-        return this.guestDelegate.getGuestByTmuxSessionId(tmuxSessionId);
-    }
-    async getGuestsByIdPrefix(prefix) {
-        return this.guestDelegate.getGuestsByIdPrefix(prefix);
-    }
-    async listGuests(projectId) {
-        return this.guestDelegate.listGuests(projectId);
-    }
-    async listAllGuests() {
-        return this.guestDelegate.listAllGuests();
-    }
-    async deleteGuest(id) {
-        return this.guestDelegate.deleteGuest(id);
-    }
-    async updateGuestLastSeen(id, lastSeenAt) {
-        return this.guestDelegate.updateGuestLastSeen(id, lastSeenAt);
-    }
-    async createReview(data) {
-        return this.reviewDelegate.createReview(data);
-    }
-    async getReview(id) {
-        return this.reviewDelegate.getReview(id);
-    }
-    async updateReview(id, data, expectedVersion) {
-        return this.reviewDelegate.updateReview(id, data, expectedVersion);
-    }
-    async deleteReview(id) {
-        return this.reviewDelegate.deleteReview(id);
-    }
-    async listReviews(projectId, options = {}) {
-        return this.reviewDelegate.listReviews(projectId, options);
-    }
-    async createReviewComment(data, targetAgentIds) {
-        return this.reviewDelegate.createReviewComment(data, targetAgentIds);
-    }
-    async getReviewComment(id) {
-        return this.reviewDelegate.getReviewComment(id);
-    }
-    async updateReviewComment(id, data, expectedVersion) {
-        return this.reviewDelegate.updateReviewComment(id, data, expectedVersion);
-    }
-    async listReviewComments(reviewId, options = {}) {
-        return this.reviewDelegate.listReviewComments(reviewId, options);
-    }
-    async addReviewCommentTargets(commentId, agentIds) {
-        return this.reviewDelegate.addReviewCommentTargets(commentId, agentIds);
-    }
-    async getReviewCommentTargets(commentId) {
-        return this.reviewDelegate.getReviewCommentTargets(commentId);
-    }
-    async deleteReviewComment(id) {
-        return this.reviewDelegate.deleteReviewComment(id);
-    }
-    async deleteNonResolvedComments(reviewId) {
-        return this.reviewDelegate.deleteNonResolvedComments(reviewId);
-    }
-    async createScheduledEpic(data) {
-        return this.scheduledEpicDelegate.createScheduledEpic(data);
-    }
-    async getScheduledEpic(id) {
-        return this.scheduledEpicDelegate.getScheduledEpic(id);
-    }
-    async listScheduledEpics(projectId, options = {}) {
-        return this.scheduledEpicDelegate.listScheduledEpics(projectId, options);
-    }
-    async updateScheduledEpic(id, data, expectedVersion, options) {
-        return this.scheduledEpicDelegate.updateScheduledEpic(id, data, expectedVersion, options);
-    }
-    async deleteScheduledEpic(id) {
-        return this.scheduledEpicDelegate.deleteScheduledEpic(id);
-    }
-    async updateScheduledEpicRuntimeState(id, data) {
-        return this.scheduledEpicDelegate.updateScheduledEpicRuntimeState(id, data);
-    }
-    async listDueScheduledEpics(projectId, before) {
-        return this.scheduledEpicDelegate.listDueScheduledEpics(projectId, before);
-    }
-    async createScheduledEpicRun(data) {
-        return this.scheduledEpicDelegate.createScheduledEpicRun(data);
-    }
-    async getScheduledEpicRun(id) {
-        return this.scheduledEpicDelegate.getScheduledEpicRun(id);
-    }
-    async listScheduledEpicRuns(scheduleId, options = {}) {
-        return this.scheduledEpicDelegate.listScheduledEpicRuns(scheduleId, options);
-    }
-    async updateScheduledEpicRun(id, data) {
-        return this.scheduledEpicDelegate.updateScheduledEpicRun(id, data);
-    }
-    async claimScheduledEpicRun(runId) {
-        return this.scheduledEpicDelegate.claimScheduledEpicRun(runId);
-    }
-    async parkSessionsFromAgents(agentIds) {
-        return this.sessionDelegate.parkSessionsFromAgents(agentIds);
-    }
-    async applySessionPlan(toReassign, toDelete) {
-        return this.sessionDelegate.applySessionPlan(toReassign, toDelete);
-    }
-    async replaceIntegrationConnection(data, verify, eventFactory) {
-        return this.integrationDelegate.replaceIntegrationConnection(data, verify, eventFactory);
-    }
-    async getIntegrationConnection(identity) {
-        return this.integrationDelegate.getIntegrationConnection(identity);
-    }
-    async getIntegrationConnectionById(connectionId) {
-        return this.integrationDelegate.getIntegrationConnectionById(connectionId);
-    }
-    async assignUnassignedIntegrationConnection(connectionId, projectId, eventFactory) {
-        return this.integrationDelegate.assignUnassignedIntegrationConnection(connectionId, projectId, eventFactory);
-    }
-    async listIntegrationConnectionsByLegacySourceConnectionId(legacySourceConnectionId) {
-        return this.integrationDelegate.listIntegrationConnectionsByLegacySourceConnectionId(legacySourceConnectionId);
-    }
-    async listIntegrationConnections(projectId) {
-        return this.integrationDelegate.listIntegrationConnections(projectId);
-    }
-    async getIntegrationConnectionCredentials(identity) {
-        return this.integrationDelegate.getIntegrationConnectionCredentials(identity);
-    }
-    async getIntegrationConnectionCredentialsById(connectionId) {
-        return this.integrationDelegate.getIntegrationConnectionCredentialsById(connectionId);
-    }
-    async disconnectIntegrationConnection(identity, eventFactory, options) {
-        return this.integrationDelegate.disconnectIntegrationConnection(identity, eventFactory, options);
-    }
-    async disconnectIntegrationConnectionById(connectionId, eventFactory, options) {
-        return this.integrationDelegate.disconnectIntegrationConnectionById(connectionId, eventFactory, options);
-    }
-    async disconnectUnassignedIntegrationConnection(connectionId, eventFactory, options) {
-        return this.integrationDelegate.disconnectUnassignedIntegrationConnection(connectionId, eventFactory, options);
-    }
-    async updateIntegrationConnectionSyncSetting(identity, subtaskSyncEnabled, eventFactory) {
-        return this.integrationDelegate.updateIntegrationConnectionSyncSetting(identity, subtaskSyncEnabled, eventFactory);
-    }
-    async updateIntegrationConnectionSyncSettingById(connectionId, subtaskSyncEnabled, eventFactory) {
-        return this.integrationDelegate.updateIntegrationConnectionSyncSettingById(connectionId, subtaskSyncEnabled, eventFactory);
-    }
-    async createExternalTaskLink(data) {
-        return this.integrationDelegate.createExternalTaskLink(data);
-    }
-    async createEpicWithExternalTaskLink(data, eventFactory) {
-        return this.integrationDelegate.createEpicWithExternalTaskLink(data, eventFactory);
-    }
-    async findExternalTaskLink(projectId, provider, remoteScopeKey, remoteTaskId) {
-        return this.integrationDelegate.findExternalTaskLink(projectId, provider, remoteScopeKey, remoteTaskId);
-    }
-    async listExternalTaskLinksByRemoteScope(provider, remoteScopeKey) {
-        return this.integrationDelegate.listExternalTaskLinksByRemoteScope(provider, remoteScopeKey);
-    }
-    async listExternalTaskLinksByRemoteTask(provider, remoteTaskId) {
-        return this.integrationDelegate.listExternalTaskLinksByRemoteTask(provider, remoteTaskId);
-    }
-    async listExternalTaskLinksForEpic(epicId) {
-        return this.integrationDelegate.listExternalTaskLinksForEpic(epicId);
-    }
-    async listExternalTaskLinksForEpics(epicIds) {
-        return this.integrationDelegate.listExternalTaskLinksForEpics(epicIds);
-    }
-    async createExternalManagedSubtaskLink(data) {
-        return this.externalManagedSubtaskDelegate.create(data);
-    }
-    async getExternalManagedSubtaskLink(id) {
-        return this.externalManagedSubtaskDelegate.get(id);
-    }
-    async listExternalManagedSubtaskLinksByProvider(provider) {
-        return this.externalManagedSubtaskDelegate.listByProvider(provider);
-    }
-    async listExternalManagedSubtaskLinksByConnection(connectionId) {
-        return this.externalManagedSubtaskDelegate.listByConnection(connectionId);
-    }
-    async listExternalManagedSubtaskLinksForEpicSnapshot(epicIdSnapshot) {
-        return this.externalManagedSubtaskDelegate.listForEpicSnapshot(epicIdSnapshot);
-    }
-    async updateExternalManagedSubtaskLink(id, data) {
-        return this.externalManagedSubtaskDelegate.update(id, data);
-    }
-    async findRecognizedManagedSubtask(epicId, provider, remoteScopeKey, remoteTaskId) {
-        return this.externalManagedSubtaskDelegate.findRecognition(epicId, provider, remoteScopeKey, remoteTaskId);
-    }
-    async confirmExternalManagedSubtaskLink(data) {
-        return this.externalManagedSubtaskDelegate.confirm(data);
-    }
-    async removeExternalManagedSubtaskLink(id) {
-        return this.externalManagedSubtaskDelegate.remove(id);
-    }
-    async getExternalEstimateLogState(identity) {
-        return this.externalEstimateLogDelegate.get(identity);
-    }
-    async getExternalEstimateLogDailyCheckpoint(identity) {
-        return this.externalEstimateLogDelegate.getDailyCheckpoint(identity);
-    }
-    async listExternalEstimateLogStatesByRemoteTask(provider, remoteTaskId) {
-        return this.externalEstimateLogDelegate.listByRemoteTask(provider, remoteTaskId);
-    }
-    async findUnassignedExternalEstimateLogCheckpoint(provider, remoteScopeKey, remoteTaskId) {
-        return this.externalEstimateLogDelegate.findUnassigned(provider, remoteScopeKey, remoteTaskId);
-    }
-    async assignUnassignedExternalEstimateLogCheckpoint(data) {
-        return this.externalEstimateLogDelegate.assignUnassigned(data);
-    }
-    async listExternalEstimateLoggedMinutes(provider, identities) {
-        return this.externalEstimateLogDelegate.listLoggedMinutes(provider, identities);
-    }
-    async setExternalEstimateLoggedMinutes(data) {
-        return this.externalEstimateLogDelegate.setLoggedMinutes(data);
-    }
-    async prepareExternalEstimateLogOperation(data) {
-        return this.externalEstimateLogDelegate.prepare(data);
-    }
-    async markExternalEstimateLogOperationOutcomeUnknown(data) {
-        return this.externalEstimateLogDelegate.markOutcomeUnknown(data);
-    }
-    async confirmExternalEstimateLogOperation(data) {
-        return this.externalEstimateLogDelegate.confirm(data);
-    }
-    async clearExternalEstimateLogOperation(data) {
-        return this.externalEstimateLogDelegate.clear(data);
-    }
-    async storeExternalEstimateLogResolution(data) {
-        return this.externalEstimateLogDelegate.storeResolution(data);
-    }
-    async applyExternalEstimateLogResolution(data) {
-        return this.externalEstimateLogDelegate.applyResolution(data);
-    }
 };
 exports.LocalStorageService = LocalStorageService;
 exports.LocalStorageService = LocalStorageService = __decorate([
@@ -953,8 +162,10 @@ exports.LocalStorageService = LocalStorageService = __decorate([
     __param(0, (0, common_1.Inject)(db_provider_1.DB_CONNECTION)),
     __param(1, (0, common_1.Optional)()),
     __param(2, (0, common_1.Optional)()),
+    __param(3, (0, common_1.Optional)()),
     __metadata("design:paramtypes", [better_sqlite3_1.BetterSQLite3Database,
         integration_credential_cipher_1.IntegrationCredentialCipher,
-        committed_event_store_1.CommittedEventStore])
+        committed_event_store_1.CommittedEventStore,
+        project_write_gate_1.ProjectWriteGate])
 ], LocalStorageService);
 //# sourceMappingURL=local-storage.service.js.map