fuli-context 0.7.4-beta.2 → 0.7.5

package/src/graphiti/federated-application.js

@@ -1,6 +1,10 @@
 import { dirname } from 'node:path';
 
 import { GraphitiProviderClient } from './provider-client.js';
+import {
+  aggregatePublicCapabilities,
+  createWorkspaceProvider
+} from './workspace-provider-client.js';
 import {
   canonicalProviderUrl,
   readGraphRuntimeConfig
@@ -24,17 +28,12 @@ import {
   createFuliSourceMarker,
   sourceConsoleUrl
 } from './source-marker.js';
-import {
-  recallTaskKnowledge,
-  TASK_KNOWLEDGE_RETRIEVAL_GUIDANCE
-} from './task-knowledge-recall.js';
 import { resolvePersonalProjectPath } from './project-path-context.js';
 import { mergeExternalKnowledgeProjection } from '../external-knowledge/graph-projection.js';
 import { TaskContextRegistry } from '../mcp/task-context-registry.js';
 import { attachExternalKnowledgeRuntime } from '../external-knowledge/runtime.js';
 import { resolveSetupPaths } from '../setup/paths.js';
 import {
-  agentProjectResolution,
   beginTaskContext as beginTaskContextWorkflow,
   checkpointTaskKnowledge as checkpointTaskKnowledgeWorkflow,
   discoverCommonKnowledgeCandidates as discoverCommonKnowledgeCandidatesWorkflow,
@@ -56,6 +55,10 @@ import {
   providerEpisode
 } from './knowledge-provider-mapping.js';
 import { providerProjectProfile } from './project-profile-mapping.js';
+import {
+  ProjectAgentControlPlaneApplication,
+  projectAgentControlPlaneHooks
+} from './project-agent-control-plane.js';
 import {
   finishKnowledgeReview as finishKnowledgeReviewWorkflow,
   listKnowledgeReviewCandidates as listKnowledgeReviewCandidatesWorkflow,
@@ -73,10 +76,8 @@ import {
   relatedProjectGuidance
 } from './related-project-suggestions.js';
 import {
-  agentCollaborationPreference,
-  agentDeferredPreferenceConflict,
-  deferredPreferenceConflicts
-} from './collaboration-preference-projection.js';
+  getCollaborationPreferences as getCollaborationPreferencesWorkflow
+} from './collaboration-preference-workflow.js';
 import { buildUserTasteSkill } from './user-taste-skill.js';
 import { getWritingTasteProfile as getWritingTasteProfileWorkflow } from './writing-taste-profile-workflow.js';
 import {
@@ -129,7 +130,7 @@ function providerRequestTimeoutFromEnv(env) {
   return parsed;
 }
 
-export class FederatedGraphApplication {
+export class FederatedGraphApplication extends ProjectAgentControlPlaneApplication {
   constructor(config, {
     fetchImpl = globalThis.fetch,
     capturePolicyStore = new CapturePolicyStore(),
@@ -139,6 +140,7 @@ export class FederatedGraphApplication {
     taskContextRegistry = new TaskContextRegistry(),
     providerRequestTimeoutMs = undefined
   } = {}) {
+    super();
     this.graphiti = true;
     this.config = config;
     this.capturePolicyStore = capturePolicyStore;
@@ -153,20 +155,12 @@ export class FederatedGraphApplication {
       fetchImpl,
       requestTimeoutMs: providerRequestTimeoutMs
     });
-    this.workspaces = new Map(
-      config.workspaces.map((workspace) => {
-        const url = canonicalProviderUrl(workspace.providerUrl);
-        return [url, {
-          ...workspace,
-          client: new GraphitiProviderClient({
-            baseUrl: url,
-            accessToken: workspace.accessToken,
-            fetchImpl,
-            requestTimeoutMs: providerRequestTimeoutMs
-          })
-        }];
-      })
-    );
+    this.workspaces = new Map(config.workspaces.map((workspace) => {
+      const provider = createWorkspaceProvider(workspace, {
+        fetchImpl, requestTimeoutMs: providerRequestTimeoutMs
+      });
+      return [provider.providerUrl, provider];
+    }));
   }
 
   async beginTaskContext(input) {
@@ -207,10 +201,17 @@ export class FederatedGraphApplication {
       const result = await this.personal.commit({
         space_id: input.spaceId,
         personal_project_id: input.personalProjectId ?? null,
+        project_agent_id: input.projectAgentId ?? null,
         episode
       });
       return { route: 'personal', ...result };
     }
+    if (input.projectAgentId) {
+      throw new ApplicationError(
+        ApplicationErrorCode.VALIDATION,
+        'Project Agent knowledge can only be captured in the personal graph'
+      );
+    }
     if (episode.sensitivity !== 'normal') {
       throw new ApplicationError(
         ApplicationErrorCode.VALIDATION,
@@ -253,6 +254,7 @@ export class FederatedGraphApplication {
 
   async getCollaborationPreferences({
     personalProjectId = null,
+    projectAgentId = null,
     projectPath = null,
     taskPrompt = null,
     limit = 100,
@@ -263,80 +265,18 @@ export class FederatedGraphApplication {
       personalProjectId,
       projectPath
     });
-    const resolvedProjectId = projectResolution.personalProjectId;
-    const [result, queuedConflicts] = await Promise.all([
-      this.personal.collaborationPreferences(
-        this.config.personal.spaceId,
-        resolvedProjectId,
-        limit
-      ),
-      this.personal.listPreferenceConflicts(
-        this.config.personal.spaceId,
-        'ai_pending',
-        limit
-      )
-    ]);
-    const deferredConflicts = deferredPreferenceConflicts(
-      result,
-      queuedConflicts
+    return getCollaborationPreferencesWorkflow(
+      this,
+      projectResolution,
+      {
+        projectAgentId,
+        taskPrompt,
+        limit,
+        agentInvocation,
+        agentToolName
+      },
+      (items, toolName) => this.#recordAgentViews(items, toolName)
     );
-    const taskKnowledgeRecall = taskPrompt === null
-      ? null
-      : await recallTaskKnowledge(this, projectResolution, taskPrompt);
-    if (agentInvocation) {
-      const items = [
-        ...(result.global_preferences ?? []),
-        ...(result.project_preferences ?? [])
-      ];
-      await this.#recordAgentViews(items.map(({ id, item_kind: itemKind }) => ({
-        item_id: id,
-        item_kind: itemKind
-      })), agentToolName);
-    }
-    const applicationGuidance = {
-      apply: 'effective_preferences',
-      global_scope: 'Apply personal-global preferences in every user task.',
-      project_scope: resolvedProjectId
-        ? `Also apply preferences scoped to ${resolvedProjectId} and confirmed ancestor preferences whose descendants or selected-projects mode explicitly reaches it.`
-        : 'No exact personal project matched; do not apply project-scoped preferences.',
-      inheritance: 'Project preference inheritance follows only PART_OF or USES_KNOWLEDGE_FROM for at most two hops. Preserve inherited_from_project_id, scope_path, and scope_distance. An exact item wins only after confirmation authority is compared; weight never expands scope or resolves a conflict.',
-      related_projects: 'RELATED_TO preferences never auto-apply. Use structured related-project suggestions to ask before a one-time read-only expansion.',
-      conflicts: 'Do not apply entries listed in conflicts until the user resolves them.',
-      deferred_conflicts: 'If the current task would use a deferred_conflict, call resolve_deferred_preference_conflict before applying either side. Ignore unrelated deferred conflicts. The resolution must preserve the AI audit marker.',
-      authority: 'Human or authoritative-source confirmed preferences outrank agent-confirmed preferences. Agent-confirmed preferences are usable but lower priority and remain explicitly marked.',
-      pending: 'Pending preferences are available only through on-demand knowledge search; invalid and unrelated-project preferences are excluded. Automatic preference injection never counts as usage evidence.',
-      knowledge_retrieval: TASK_KNOWLEDGE_RETRIEVAL_GUIDANCE
-    };
-    if (!agentInvocation) {
-      return {
-        ...result,
-        deferred_conflicts: deferredConflicts,
-        application_guidance: applicationGuidance,
-        project_resolution: agentProjectResolution(projectResolution),
-        ...(taskKnowledgeRecall ? { task_knowledge_recall: taskKnowledgeRecall } : {})
-      };
-    }
-    return {
-      effective_preferences: (result.effective_preferences ?? [])
-        .map(agentCollaborationPreference),
-      deferred_conflicts: deferredConflicts.map(agentDeferredPreferenceConflict),
-      application_guidance: applicationGuidance,
-      ...(taskKnowledgeRecall ? { task_knowledge_recall: taskKnowledgeRecall } : {}),
-      context: {
-        personal_space_id: result.personal_space_id,
-        personal_project_id: result.personal_project_id,
-        global_preference_count: (result.global_preferences ?? []).length,
-        project_preference_count: (result.project_preferences ?? []).length,
-        inherited_project_preference_count: (result.project_preferences ?? [])
-          .filter(({ inherited_from_project_id: projectId }) => Boolean(projectId))
-          .length,
-        conflict_count: (result.conflicts ?? []).length,
-        ai_deferred_conflict_count: deferredConflicts.length,
-        overridden_global_count: (result.overridden_global_ids ?? []).length,
-        source_truncated: result.truncated === true,
-        project_resolution: agentProjectResolution(projectResolution)
-      }
-    };
   }
 
   async getUserTasteSkill({
@@ -419,6 +359,7 @@ export class FederatedGraphApplication {
     query,
     projectIds = [],
     personalProjectId = null,
+    projectAgentId = null,
     contextPersonalProjectIds = [],
     personalProjectScope = 'bounded',
     limit = 12,
@@ -433,6 +374,11 @@ export class FederatedGraphApplication {
     if (!['bounded', 'all_local_confirmed'].includes(personalProjectScope)) {
       throw new TypeError('Unknown personal project search scope');
     }
+    if (projectAgentId && (!personalProjectId || personalProjectScope !== 'bounded')) {
+      throw new TypeError(
+        'Project Agent search requires one bounded active personal project'
+      );
+    }
     const subscriptions = projectIds.length
       ? await this.personal.listSubscriptions(personalSpaceId)
       : [];
@@ -451,21 +397,25 @@ export class FederatedGraphApplication {
       )
       : personalContextProjectIds(personalProjectId, contextPersonalProjectIds);
     const personalSearches = personalProjectSearchBatches(selectedPersonalProjectIds)
-      .map((personalProjectIds, index) => this.personal.search({
+      .map((personalProjectIds, index) => {
+        const activePersonalProjectId = (
+          personalProjectScope === 'bounded' &&
+          personalProjectId &&
+          personalProjectIds.includes(personalProjectId)
+        ) ? personalProjectId : null;
+        return this.personal.search({
         space_ids: [personalSpaceId],
         query,
         limit,
         include_historical: includeHistorical,
         include_exploratory: includePending,
         personal_project_ids: personalProjectIds,
-        active_personal_project_id: (
-          personalProjectScope === 'bounded' &&
-          personalProjectId &&
-          personalProjectIds.includes(personalProjectId)
-        ) ? personalProjectId : null,
+        active_personal_project_id: activePersonalProjectId,
+        project_agent_id: activePersonalProjectId ? projectAgentId : null,
         inherit_project_knowledge: personalProjectScope === 'bounded',
         include_personal_global: index === 0
-      }));
+        });
+      });
     const grouped = groupSubscriptions(selectedSubscriptions);
     const workspaceSearches = [...grouped.entries()].map(([providerUrl, items]) => {
       const projectIdsForProvider = items.map(({ project_id: projectId }) => projectId);
@@ -553,6 +503,7 @@ export class FederatedGraphApplication {
       entities,
       personalGlobalIncluded: true,
       personalProjectScope,
+      projectAgentId,
       searchedPersonalProjectIds: selectedPersonalProjectIds,
       requestedProjectIds,
       searchedProjectIds,
@@ -1159,10 +1110,17 @@ export class FederatedGraphApplication {
         try {
           return {
             providerUrl: workspace.providerUrl,
+            protocol: workspace.protocol,
+            capabilities: workspace.capabilities,
             ...(await workspace.client.health())
           };
         } catch {
-          return { providerUrl: workspace.providerUrl, status: 'unavailable' };
+          return {
+            providerUrl: workspace.providerUrl,
+            protocol: workspace.protocol,
+            capabilities: workspace.capabilities,
+            status: 'unavailable'
+          };
         }
       })
     ]);
@@ -1200,13 +1158,9 @@ export class FederatedGraphApplication {
       capturePolicy: this.getCapturePolicy(),
       agentAccessPolicy: this.getAgentAccessPolicy(),
       publicProvider: { configured, status: publicStatus },
-      capabilities: {
-        browsePublicProjects: connected,
-        publishProject: connected,
-        submitKnowledge: connected,
-        subscribeProject: connected,
-        reviewProposals: connected && spaces.projects.some(({ role }) => role === 'maintainer')
-      }
+      capabilities: aggregatePublicCapabilities(
+        this.workspaces, providers.workspaces, spaces.projects
+      )
     };
   }
 
@@ -1233,6 +1187,14 @@ export class FederatedGraphApplication {
     }
   }
 
+  [projectAgentControlPlaneHooks.assertActivePersonalSpace](personalSpaceId) {
+    this.#assertActivePersonalSpace(personalSpaceId);
+  }
+
+  async [projectAgentControlPlaneHooks.resolvePreferenceProject](input) {
+    return this.#resolvePreferenceProject(input);
+  }
+
   #workspace(providerUrl) {
     const requested = providerUrl
       ? canonicalProviderUrl(providerUrl)

package/src/graphiti/knowledge-provider-mapping.js

@@ -71,7 +71,8 @@ function assertReasoningSummaries(items, collectionName) {
 }
 
 export function assertPublicKnowledgeEligible(episode) {
-  const blocked = [...episode.entities, ...episode.relationships].find((item) =>
+  const items = [...episode.entities, ...episode.relationships];
+  const blocked = items.find((item) =>
     item.profile_aspect ||
     item.confirmation_status !== 'confirmed' ||
     !item.confirmation_basis?.confirmed_by ||
@@ -83,6 +84,11 @@ export function assertPublicKnowledgeEligible(episode) {
       'Only knowledge with an auditable confirmation can enter public review'
     );
   }
+  if (items.some((item) => (item.origin_quadrant ?? 'known_known') !== 'known_known')) {
+    throw new TypeError(
+      'Only knowledge originally captured as known-known can enter public review'
+    );
+  }
 }
 
 export function providerConfirmationBasis(basis) {

package/src/graphiti/project-agent-control-plane.js

@@ -0,0 +1,263 @@
+import { agentProjectResolution } from './agent-knowledge-workflows.js';
+import {
+  authorizeExecutor as authorizeExecutorWorkflow,
+  cleanupProjectAgentTestRoles as cleanupProjectAgentTestRolesWorkflow,
+  coordinateProjectAgentTask as coordinateProjectAgentTaskWorkflow,
+  createProjectAgentAssignment as createProjectAgentAssignmentWorkflow,
+  decideProjectAgentRecruitment as decideProjectAgentRecruitmentWorkflow,
+  deleteExecutor as deleteExecutorWorkflow,
+  deleteExecutorRoutingRule as deleteExecutorRoutingRuleWorkflow,
+  deleteProjectAgent as deleteProjectAgentWorkflow,
+  endProjectAgentAssignment as endProjectAgentAssignmentWorkflow,
+  getExecutor as getExecutorWorkflow,
+  getExecutorRoutingRule as getExecutorRoutingRuleWorkflow,
+  getProjectAgent as getProjectAgentWorkflow,
+  getProjectAgentContext as getProjectAgentContextWorkflow,
+  getProjectAgentRecruitmentPolicy as getProjectAgentRecruitmentPolicyWorkflow,
+  ignoreProjectAgentRoutingLearning as ignoreProjectAgentRoutingLearningWorkflow,
+  listCurrentProjectAgents as listCurrentProjectAgentsWorkflow,
+  listExecutorRoutingRules as listExecutorRoutingRulesWorkflow,
+  listExecutors as listExecutorsWorkflow,
+  listProjectAgentAssignments as listProjectAgentAssignmentsWorkflow,
+  listProjectAgentRecruitments as listProjectAgentRecruitmentsWorkflow,
+  listProjectAgentRoutingLearning as listProjectAgentRoutingLearningWorkflow,
+  listProjectAgentTasks as listProjectAgentTasksWorkflow,
+  listProjectAgents as listProjectAgentsWorkflow,
+  preflightExecutor as preflightExecutorWorkflow,
+  recordProjectAgentExecutorActual as recordProjectAgentExecutorActualWorkflow,
+  recordProjectAgentTaskActivity as recordProjectAgentTaskActivityWorkflow,
+  recordProjectAgentTaskOutcome as recordProjectAgentTaskOutcomeWorkflow,
+  replaceProjectAgentAssignment as replaceProjectAgentAssignmentWorkflow,
+  reportExecutorHealth as reportExecutorHealthWorkflow,
+  resetProjectAgentRoutingLearning as resetProjectAgentRoutingLearningWorkflow,
+  submitProjectAgentTask as submitProjectAgentTaskWorkflow,
+  updateExecutorRoutingRule as updateExecutorRoutingRuleWorkflow,
+  updateProjectAgentRecruitmentPolicy as updateProjectAgentRecruitmentPolicyWorkflow,
+  upsertExecutor as upsertExecutorWorkflow,
+  upsertExecutorRoutingRule as upsertExecutorRoutingRuleWorkflow,
+  upsertProjectAgent as upsertProjectAgentWorkflow,
+  viewProjectAgentActivity as viewProjectAgentActivityWorkflow,
+  viewProjectAgentTask as viewProjectAgentTaskWorkflow
+} from './project-agent-workflows.js';
+
+export const projectAgentControlPlaneHooks = Object.freeze({
+  assertActivePersonalSpace: Symbol('assertActivePersonalSpace'),
+  resolvePreferenceProject: Symbol('resolvePreferenceProject')
+});
+
+export class ProjectAgentControlPlaneApplication {
+  async upsertProjectAgent(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return upsertProjectAgentWorkflow(this, input);
+  }
+
+  async listProjectAgents(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return listProjectAgentsWorkflow(this, input);
+  }
+
+  async listCurrentProjectAgents(input) {
+    const resolution = await this.#resolveProject(input.projectPath);
+    return listCurrentProjectAgentsWorkflow(
+      this,
+      agentProjectResolution(resolution),
+      input
+    );
+  }
+
+  async getProjectAgent(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return getProjectAgentWorkflow(this, input);
+  }
+
+  async deleteProjectAgent(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return deleteProjectAgentWorkflow(this, input);
+  }
+
+  async cleanupProjectAgentTestRoles(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return cleanupProjectAgentTestRolesWorkflow(this, input);
+  }
+
+  async createProjectAgentAssignment(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return createProjectAgentAssignmentWorkflow(this, input);
+  }
+
+  async listProjectAgentAssignments(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return listProjectAgentAssignmentsWorkflow(this, input);
+  }
+
+  async endProjectAgentAssignment(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return endProjectAgentAssignmentWorkflow(this, input);
+  }
+
+  async replaceProjectAgentAssignment(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return replaceProjectAgentAssignmentWorkflow(this, input);
+  }
+
+  async submitProjectAgentTask(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return submitProjectAgentTaskWorkflow(this, input);
+  }
+
+  async coordinateProjectAgentTask(input) {
+    const resolution = await this.#resolveProject(input.projectPath);
+    return coordinateProjectAgentTaskWorkflow(
+      this,
+      agentProjectResolution(resolution),
+      input
+    );
+  }
+
+  async listProjectAgentTasks(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return listProjectAgentTasksWorkflow(this, input);
+  }
+
+  async viewProjectAgentTask(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return viewProjectAgentTaskWorkflow(this, input);
+  }
+
+  async recordProjectAgentTaskActivity(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return recordProjectAgentTaskActivityWorkflow(this, input);
+  }
+
+  async viewProjectAgentActivity(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return viewProjectAgentActivityWorkflow(this, input);
+  }
+
+  async getProjectAgentRecruitmentPolicy(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return getProjectAgentRecruitmentPolicyWorkflow(this, input);
+  }
+
+  async updateProjectAgentRecruitmentPolicy(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return updateProjectAgentRecruitmentPolicyWorkflow(this, input);
+  }
+
+  async listProjectAgentRecruitments(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return listProjectAgentRecruitmentsWorkflow(this, input);
+  }
+
+  async decideProjectAgentRecruitment(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return decideProjectAgentRecruitmentWorkflow(this, input);
+  }
+
+  async upsertExecutor(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return upsertExecutorWorkflow(this, input);
+  }
+
+  async listExecutors(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return listExecutorsWorkflow(this, input);
+  }
+
+  async getExecutor(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return getExecutorWorkflow(this, input);
+  }
+
+  async deleteExecutor(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return deleteExecutorWorkflow(this, input);
+  }
+
+  async preflightExecutor(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return preflightExecutorWorkflow(this, input);
+  }
+
+  async authorizeExecutor(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return authorizeExecutorWorkflow(this, input);
+  }
+
+  async reportExecutorHealth(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return reportExecutorHealthWorkflow(this, input);
+  }
+
+  async recordProjectAgentExecutorActual(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return recordProjectAgentExecutorActualWorkflow(this, input);
+  }
+
+  async upsertExecutorRoutingRule(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return upsertExecutorRoutingRuleWorkflow(this, input);
+  }
+
+  async updateExecutorRoutingRule(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return updateExecutorRoutingRuleWorkflow(this, input);
+  }
+
+  async listExecutorRoutingRules(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return listExecutorRoutingRulesWorkflow(this, input);
+  }
+
+  async getExecutorRoutingRule(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return getExecutorRoutingRuleWorkflow(this, input);
+  }
+
+  async deleteExecutorRoutingRule(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return deleteExecutorRoutingRuleWorkflow(this, input);
+  }
+
+  async recordProjectAgentTaskOutcome(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return recordProjectAgentTaskOutcomeWorkflow(this, input);
+  }
+
+  async listProjectAgentRoutingLearning(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return listProjectAgentRoutingLearningWorkflow(this, input);
+  }
+
+  async ignoreProjectAgentRoutingLearning(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return ignoreProjectAgentRoutingLearningWorkflow(this, input);
+  }
+
+  async resetProjectAgentRoutingLearning(input) {
+    this.#assertSpace(input.personalSpaceId);
+    return resetProjectAgentRoutingLearningWorkflow(this, input);
+  }
+
+  async getProjectAgentContext(input) {
+    const resolution = await this.#resolveProject(input.projectPath);
+    return getProjectAgentContextWorkflow(
+      this,
+      agentProjectResolution(resolution),
+      input
+    );
+  }
+
+  #assertSpace(personalSpaceId) {
+    this[projectAgentControlPlaneHooks.assertActivePersonalSpace](
+      personalSpaceId
+    );
+  }
+
+  #resolveProject(projectPath) {
+    return this[projectAgentControlPlaneHooks.resolvePreferenceProject]({
+      personalProjectId: null,
+      projectPath
+    });
+  }
+}