src/components/EntityGrid.vue

@@ -164,6 +164,10 @@ import { Contact } from "../db/tables/contacts";
 import { PlanData } from "../interfaces/records";
 import { NotificationIface } from "../constants/app";
 import { UNNAMED_ENTITY_NAME } from "@/constants/entities";
+import { PlatformServiceMixin } from "@/utils/PlatformServiceMixin";
+import { getHeaders } from "../libs/endorserServer";
+import { logger } from "../utils/logger";
+import { TIMEOUTS } from "@/utils/notify";
 
 /**
  * Constants for infinite scroll configuration
@@ -191,6 +195,7 @@ const RECENT_CONTACTS_COUNT = 3;
     ProjectCard,
     SpecialEntityCard,
   },
+  mixins: [PlatformServiceMixin],
 })
 export default class EntityGrid extends Vue {
   /** Type of entities to display */
@@ -202,23 +207,30 @@ export default class EntityGrid extends Vue {
   isSearching = false;
   searchTimeout: NodeJS.Timeout | null = null;
   filteredEntities: Contact[] | PlanData[] = [];
+  searchBeforeId: string | undefined = undefined;
+  isLoadingSearchMore = false;
+
+  // API server for project searches
+  apiServer = "";
 
   // Infinite scroll state
   displayedCount = INITIAL_BATCH_SIZE;
   infiniteScrollReset?: () => void;
   scrollContainer?: HTMLElement;
+  isLoadingMore = false; // Prevent duplicate callback calls
 
   /**
    * Array of entities to display
    *
+   * For contacts: Must be a COMPLETE list from local database.
+   * Use $contactsByDateAdded() to ensure all contacts are included.
+   * Client-side filtering assumes the complete list is available.
    * IMPORTANT: When passing Contact[] arrays, they must be sorted by date added
    * (newest first) for the "Recently Added" section to display correctly.
-   * Use $contactsByDateAdded() instead of $getAllContacts() or $contacts().
    *
-   * The recentContacts computed property assumes contacts are already sorted
+   * For projects: Can be partial list (pagination supported).
-   * by date added and simply takes the first 3. If contacts are sorted
+   * Server-side search will fetch matching results with pagination,
-   * alphabetically or in another order, the wrong contacts will appear in
+   * regardless of what's in this prop.
-   * "Recently Added".
    */
   @Prop({ required: true })
   entities!: Contact[] | PlanData[];
@@ -286,6 +298,23 @@ export default class EntityGrid extends Vue {
     entityType: "people" | "projects",
   ) => Contact[] | PlanData[];
 
+  /**
+   * Optional callback function to load more entities from server
+   * Called when infinite scroll reaches end and more data is available
+   * Required for projects when using server-side pagination
+   *
+   * @param entities - Current array of entities
+   * @returns Promise that resolves when more entities are loaded
+   *
+   * @example
+   * :load-more-callback="async (entities) => {
+   *   const lastEntity = entities[entities.length - 1];
+   *   await loadMoreFromServer(lastEntity.rowId);
+   * }"
+   */
+  @Prop({ default: null })
+  loadMoreCallback?: (entities: Contact[] | PlanData[]) => Promise<void>;
+
   /**
    * CSS classes for the empty state message
    */
@@ -457,24 +486,162 @@ export default class EntityGrid extends Vue {
 
   /**
    * Perform the actual search
+   * Routes to server-side search for projects or client-side filtering for contacts
    */
   async performSearch(): Promise<void> {
     if (!this.searchTerm.trim()) {
       this.filteredEntities = [];
       this.displayedCount = INITIAL_BATCH_SIZE;
+      this.searchBeforeId = undefined;
       this.infiniteScrollReset?.();
       return;
     }
 
     this.isSearching = true;
+    this.searchBeforeId = undefined; // Reset pagination for new search
+
+    try {
+      if (this.entityType === "projects") {
+        // Server-side search for projects (initial load, no beforeId)
+        await this.performProjectSearch();
+      } else {
+        // Client-side filtering for contacts (complete list)
+        await this.performContactSearch();
+      }
+
+      // Reset displayed count when search completes
+      this.displayedCount = INITIAL_BATCH_SIZE;
+      this.infiniteScrollReset?.();
+    } finally {
+      this.isSearching = false;
+    }
+  }
+
+  /**
+   * Perform server-side project search with optional pagination
+   * Uses claimContents parameter for search and beforeId for pagination.
+   * Results are appended when paginating, replaced on initial search.
+   *
+   * @param beforeId - Optional rowId for pagination (loads projects before this ID)
+   */
+  async performProjectSearch(beforeId?: string): Promise<void> {
+    if (!this.apiServer) {
+      this.filteredEntities = [];
+      if (this.notify) {
+        this.notify(
+          {
+            group: "alert",
+            type: "danger",
+            title: "Error",
+            text: "API server not configured",
+          },
+          TIMEOUTS.SHORT,
+        );
+      }
+      return;
+    }
+
+    const searchLower = this.searchTerm.toLowerCase().trim();
+    let url = `${this.apiServer}/api/v2/report/plans?claimContents=${encodeURIComponent(searchLower)}`;
+
+    if (beforeId) {
+      url += `&beforeId=${encodeURIComponent(beforeId)}`;
+    }
 
     try {
-      // Simulate async search (in case we need to add API calls later)
+      const response = await fetch(url, {
+        method: "GET",
+        headers: await getHeaders(this.activeDid),
+      });
+
+      if (response.status !== 200) {
+        throw new Error("Failed to search projects");
+      }
+
+      const results = await response.json();
+      if (results.data) {
+        const newProjects = results.data.map(
+          (plan: PlanData & { rowId?: string }) => ({
+            ...plan,
+            rowId: plan.rowId,
+          }),
+        );
+
+        logger.debug("[EntityGrid] Project search results", {
+          beforeId,
+          newProjectsCount: newProjects.length,
+          hasRowId:
+            newProjects.length > 0
+              ? !!newProjects[newProjects.length - 1]?.rowId
+              : false,
+          lastRowId:
+            newProjects.length > 0
+              ? newProjects[newProjects.length - 1]?.rowId
+              : undefined,
+        });
+
+        if (beforeId) {
+          // Pagination: append new projects to existing search results
+          this.filteredEntities.push(...newProjects);
+        } else {
+          // Initial search: replace array
+          this.filteredEntities = newProjects;
+        }
+
+        // Update searchBeforeId for next pagination
+        // Use the last project's rowId, or undefined if no more results
+        if (newProjects.length > 0) {
+          const lastProject = newProjects[newProjects.length - 1];
+          // Only set searchBeforeId if rowId exists (indicates more results available)
+          this.searchBeforeId = lastProject.rowId || undefined;
+          logger.debug("[EntityGrid] Updated searchBeforeId", {
+            searchBeforeId: this.searchBeforeId,
+            filteredEntitiesCount: this.filteredEntities.length,
+          });
+        } else {
+          this.searchBeforeId = undefined; // No more results
+          logger.debug("[EntityGrid] No more search results", {
+            filteredEntitiesCount: this.filteredEntities.length,
+          });
+        }
+      } else {
+        if (!beforeId) {
+          // Only clear on initial search, not pagination
+          this.filteredEntities = [];
+        }
+        this.searchBeforeId = undefined;
+      }
+    } catch (error) {
+      logger.error("Error searching projects:", error);
+      if (!beforeId) {
+        // Only clear on initial search error, not pagination error
+        this.filteredEntities = [];
+      }
+      this.searchBeforeId = undefined;
+      if (this.notify) {
+        this.notify(
+          {
+            group: "alert",
+            type: "danger",
+            title: "Error",
+            text: "Failed to search projects. Please try again.",
+          },
+          TIMEOUTS.STANDARD,
+        );
+      }
+    }
+  }
+
+  /**
+   * Client-side contact search
+   * Assumes entities prop contains complete contact list from local database
+   */
+  async performContactSearch(): Promise<void> {
+    // Simulate async (for consistency with project search)
     await new Promise((resolve) => setTimeout(resolve, 100));
 
     const searchLower = this.searchTerm.toLowerCase().trim();
 
-      if (this.entityType === "people") {
     this.filteredEntities = (this.entities as Contact[])
       .filter((contact: Contact) => {
         const name = contact.name?.toLowerCase() || "";
@@ -487,25 +654,9 @@ export default class EntityGrid extends Vue {
         const nameB = (b.name || b.did).toLowerCase();
         return nameA.localeCompare(nameB);
       });
-      } else {
-        this.filteredEntities = (this.entities as PlanData[])
-          .filter((project: PlanData) => {
-            const name = project.name?.toLowerCase() || "";
-            const handleId = project.handleId.toLowerCase();
-            return name.includes(searchLower) || handleId.includes(searchLower);
-          })
-          .sort((a: PlanData, b: PlanData) => {
-            // Sort alphabetically by name
-            return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
-          });
-      }
 
-      // Reset displayed count when search completes
+    // Contacts don't need pagination (complete list)
-      this.displayedCount = INITIAL_BATCH_SIZE;
+    this.searchBeforeId = undefined;
-      this.infiniteScrollReset?.();
-    } finally {
-      this.isSearching = false;
-    }
   }
 
   /**
@@ -516,6 +667,7 @@ export default class EntityGrid extends Vue {
     this.filteredEntities = [];
     this.isSearching = false;
     this.displayedCount = INITIAL_BATCH_SIZE;
+    this.searchBeforeId = undefined;
     this.infiniteScrollReset?.();
 
     // Clear any pending timeout
@@ -535,12 +687,34 @@ export default class EntityGrid extends Vue {
     }
 
     if (this.searchTerm.trim()) {
-      // Search mode: check filtered entities
+      // Search mode: check if more results available
+      if (this.entityType === "projects") {
+        // Projects: can load more if:
+        // 1. We have more already-loaded results to show, OR
+        // 2. We've shown all loaded results AND there's a searchBeforeId to load more
+        const hasMoreLoaded =
+          this.displayedCount < this.filteredEntities.length;
+        const canLoadMoreFromServer =
+          this.displayedCount >= this.filteredEntities.length &&
+          !!this.searchBeforeId &&
+          !this.isLoadingSearchMore;
+        return hasMoreLoaded || canLoadMoreFromServer;
+      } else {
+        // Contacts: client-side filtering returns all results at once
         return this.displayedCount < this.filteredEntities.length;
       }
+    }
 
+    // Non-search mode: existing logic
     if (this.entityType === "projects") {
-      // Projects: check if more available
+      // Projects: if we've shown all loaded entities and callback exists, callback handles server-side availability
+      if (
+        this.displayedCount >= this.entities.length &&
+        this.loadMoreCallback
+      ) {
+        return !this.isLoadingMore; // Only return true if not already loading
+      }
+      // Otherwise, check if more in memory
       return this.displayedCount < this.entities.length;
     }
 
@@ -553,16 +727,74 @@ export default class EntityGrid extends Vue {
   /**
    * Initialize infinite scroll on mount
    */
-  mounted(): void {
+  async mounted(): Promise<void> {
+    // Load apiServer for project searches
+    if (this.entityType === "projects") {
+      const settings = await this.$accountSettings();
+      this.apiServer = settings.apiServer || "";
+    }
+
     this.$nextTick(() => {
       const container = this.$refs.scrollContainer as HTMLElement;
 
       if (container) {
         const { reset } = useInfiniteScroll(
           container,
-          () => {
+          async () => {
-            // Load more: increment displayedCount
+            // Search mode: handle search pagination
+            if (this.searchTerm.trim()) {
+              if (this.entityType === "projects") {
+                // Projects: load more search results if available
+                if (
+                  this.displayedCount >= this.filteredEntities.length &&
+                  this.searchBeforeId &&
+                  !this.isLoadingSearchMore
+                ) {
+                  this.isLoadingSearchMore = true;
+                  try {
+                    await this.performProjectSearch(this.searchBeforeId);
+                    // After loading more, reset scroll state to allow further loading
+                    this.infiniteScrollReset?.();
+                  } catch (error) {
+                    logger.error("Error loading more search results:", error);
+                    // Error already handled in performProjectSearch
+                  } finally {
+                    this.isLoadingSearchMore = false;
+                  }
+                } else {
+                  // Show more from already-loaded search results
+                  this.displayedCount += INCREMENT_SIZE;
+                }
+              } else {
+                // Contacts: show more from already-filtered results
                 this.displayedCount += INCREMENT_SIZE;
+              }
+            } else {
+              // Non-search mode: existing logic
+              // For projects: if we've shown all entities and callback exists, call it
+              if (
+                this.entityType === "projects" &&
+                this.displayedCount >= this.entities.length &&
+                this.loadMoreCallback &&
+                !this.isLoadingMore
+              ) {
+                this.isLoadingMore = true;
+                try {
+                  await this.loadMoreCallback(this.entities);
+                  // After callback, entities prop will update via Vue reactivity
+                  // Reset scroll state to allow further loading
+                  this.infiniteScrollReset?.();
+                } catch (error) {
+                  // Error handling is up to the callback, but we should reset loading state
+                  console.error("Error in loadMoreCallback:", error);
+                } finally {
+                  this.isLoadingMore = false;
+                }
+              } else {
+                // Normal case: increment displayedCount to show more from memory
+                this.displayedCount += INCREMENT_SIZE;
+              }
+            }
           },
           {
             distance: 50, // pixels from bottom
@@ -588,19 +820,27 @@ export default class EntityGrid extends Vue {
   }
 
   /**
-   * Watch for changes in search term to reset displayed count
+   * Watch for changes in search term to reset displayed count and pagination
    */
   @Watch("searchTerm")
   onSearchTermChange(): void {
+    // Reset displayed count and pagination when search term changes
     this.displayedCount = INITIAL_BATCH_SIZE;
+    this.searchBeforeId = undefined;
     this.infiniteScrollReset?.();
   }
 
   /**
-   * Watch for changes in entities prop to reset displayed count
+   * Watch for changes in entities prop to clear search and reset displayed count
    */
   @Watch("entities")
   onEntitiesChange(): void {
+    // Clear search when entities change (fresh dialog open)
+    if (this.searchTerm) {
+      this.searchTerm = "";
+      this.filteredEntities = [];
+      this.searchBeforeId = undefined;
+    }
     this.displayedCount = INITIAL_BATCH_SIZE;
     this.infiniteScrollReset?.();
   }

src/components/EntitySelectionStep.vue

@@ -23,6 +23,7 @@ properties * * @author Matthew Raymer */
       :you-selectable="youSelectable"
       :notify="notify"
       :conflict-context="conflictContext"
+      :load-more-callback="shouldShowProjects ? loadMoreCallback : undefined"
       @entity-selected="handleEntitySelected"
     />
 
@@ -148,6 +149,10 @@ export default class EntitySelectionStep extends Vue {
   @Prop()
   notify?: (notification: NotificationIface, timeout?: number) => void;
 
+  /** Callback function to load more projects from server */
+  @Prop()
+  loadMoreCallback?: (entities: PlanData[]) => Promise<void>;
+
   /**
    * CSS classes for the cancel button
    */

src/components/GiftedDialog.vue

@@ -29,6 +29,11 @@
         :unit-code="unitCode"
         :offer-id="offerId"
         :notify="$notify"
+        :load-more-callback="
+          giverEntityType === 'project' || recipientEntityType === 'project'
+            ? handleLoadMoreProjects
+            : undefined
+        "
         @entity-selected="handleEntitySelected"
         @cancel="cancel"
       />
@@ -489,9 +494,17 @@ export default class GiftedDialog extends Vue {
     this.firstStep = false;
   }
 
-  async loadProjects() {
+  /**
+   * Load projects from the API
+   * @param beforeId - Optional rowId for pagination (loads projects before this ID)
+   */
+  async loadProjects(beforeId?: string) {
     try {
-      const response = await fetch(this.apiServer + "/api/v2/report/plans", {
+      let url = this.apiServer + "/api/v2/report/plans";
+      if (beforeId) {
+        url += `?beforeId=${encodeURIComponent(beforeId)}`;
+      }
+      const response = await fetch(url, {
         method: "GET",
         headers: await getHeaders(this.activeDid),
       });
@@ -502,14 +515,56 @@ export default class GiftedDialog extends Vue {
 
       const results = await response.json();
       if (results.data) {
-        this.projects = results.data;
+        // Ensure rowId is included in project data
+        const newProjects = results.data.map(
+          (plan: PlanData & { rowId?: string }) => ({
+            ...plan,
+            rowId: plan.rowId,
+          }),
+        );
+
+        if (beforeId) {
+          // Pagination: append new projects
+          this.projects.push(...newProjects);
+        } else {
+          // Initial load: replace array
+          this.projects = newProjects;
+        }
       }
     } catch (error) {
       logger.error("Error loading projects:", error);
       this.safeNotify.error("Failed to load projects", TIMEOUTS.STANDARD);
+      // Don't clear existing projects if this was a pagination request
+      if (!beforeId) {
+        this.projects = [];
+      }
     }
   }
 
+  /**
+   * Handle loading more projects when EntityGrid reaches the end
+   * Called by EntitySelectionStep via loadMoreCallback
+   * @param entities - Current array of projects
+   */
+  async handleLoadMoreProjects(
+    entities: Array<{
+      handleId: string;
+      rowId?: string;
+    }>,
+  ): Promise<void> {
+    if (entities.length === 0) {
+      return;
+    }
+
+    const lastProject = entities[entities.length - 1];
+    if (!lastProject.rowId) {
+      // No rowId means we can't paginate - likely end of data
+      return;
+    }
+
+    await this.loadProjects(lastProject.rowId);
+  }
+
   selectProject(project: PlanData) {
     this.giver = {
       did: project.handleId,

src/components/MeetingProjectDialog.vue

@@ -0,0 +1,128 @@
+<template>
+  <div v-if="visible" class="dialog-overlay">
+    <div class="dialog">
+      <!-- Header -->
+      <h2 class="text-lg font-semibold leading-[1.25] mb-4">Select Project</h2>
+
+      <!-- EntityGrid for projects -->
+      <EntityGrid
+        :entity-type="'projects'"
+        :entities="allProjects"
+        :active-did="activeDid"
+        :all-my-dids="allMyDids"
+        :all-contacts="allContacts"
+        :conflict-checker="() => false"
+        :show-you-entity="false"
+        :show-unnamed-entity="false"
+        :notify="notify"
+        :conflict-context="'project'"
+        :load-more-callback="loadMoreCallback"
+        @entity-selected="handleEntitySelected"
+      />
+
+      <!-- Cancel Button -->
+      <div class="flex gap-2 mt-4">
+        <button
+          class="block w-full text-center text-md uppercase bg-gradient-to-b from-slate-400 to-slate-700 shadow-[inset_0_-1px_0_0_rgba(0,0,0,0.5)] text-white px-2 py-2 rounded-md"
+          @click="handleCancel"
+        >
+          Cancel
+        </button>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script lang="ts">
+import { Component, Prop, Vue, Emit } from "vue-facing-decorator";
+import EntityGrid from "./EntityGrid.vue";
+import { Contact } from "../db/tables/contacts";
+import { PlanData } from "../interfaces/records";
+import { NotificationIface } from "../constants/app";
+
+/**
+ * MeetingProjectDialog - Dialog for selecting a project link for a meeting
+ *
+ * Features:
+ * - EntityGrid integration for project selection
+ * - No special entities (You, Unnamed)
+ * - Immediate assignment on project selection
+ * - Cancel button to close without selection
+ */
+@Component({
+  components: {
+    EntityGrid,
+  },
+})
+export default class MeetingProjectDialog extends Vue {
+  /** Whether the dialog is visible */
+  visible = false;
+
+  /** Array of available projects */
+  @Prop({ required: true })
+  allProjects!: PlanData[];
+
+  /** Active user's DID */
+  @Prop({ required: true })
+  activeDid!: string;
+
+  /** All user's DIDs */
+  @Prop({ required: true })
+  allMyDids!: string[];
+
+  /** All contacts */
+  @Prop({ required: true })
+  allContacts!: Contact[];
+
+  /** Notification function from parent component */
+  @Prop()
+  notify?: (notification: NotificationIface, timeout?: number) => void;
+
+  /** Callback function to load more projects from server */
+  @Prop()
+  loadMoreCallback?: (entities: PlanData[]) => Promise<void>;
+
+  /**
+   * Handle entity selection from EntityGrid
+   * Immediately assigns the selected project and closes the dialog
+   */
+  handleEntitySelected(event: {
+    type: "person" | "project";
+    data: Contact | PlanData;
+  }) {
+    const project = event.data as PlanData;
+    this.emitAssign(project);
+    this.close();
+  }
+
+  /**
+   * Handle cancel button click
+   */
+  handleCancel(): void {
+    this.close();
+  }
+
+  /**
+   * Open the dialog
+   */
+  open(): void {
+    this.visible = true;
+  }
+
+  /**
+   * Close the dialog
+   */
+  close(): void {
+    this.visible = false;
+  }
+
+  // Emit methods using @Emit decorator
+
+  @Emit("assign")
+  emitAssign(project: PlanData): PlanData {
+    return project;
+  }
+}
+</script>
+
+<style scoped></style>

src/components/ProjectCard.vue

@@ -8,7 +8,7 @@ issuer information. * * @author Matthew Raymer */
   >
     <ProjectIcon
       :entity-id="project.handleId"
-      :icon-size="48"
+      :icon-size="30"
       :image-url="project.image"
       class="!size-[2rem] shrink-0 border border-slate-300 bg-white overflow-hidden rounded-full"
     />

src/views/OnboardMeetingSetupView.vue

@@ -186,16 +186,59 @@
         <div>
           <label
             for="projectLink"
-            class="block text-sm font-medium text-gray-700"
+            class="block text-sm font-medium text-gray-700 mb-1"
             >Project Link</label
           >
-          <input
+          <div class="w-full flex items-stretch">
-            id="projectLink"
+            <div
-            v-model="newOrUpdatedMeetingInputs.projectLink"
+              class="flex items-center gap-2 grow border border-slate-400 border-r-0 last:border-r px-3 py-2 rounded-l last:rounded overflow-hidden cursor-pointer hover:bg-slate-100"
-            type="text"
+              @click="openProjectLinkDialog"
-            class="mt-1 block w-full rounded-md border border-gray-300 px-3 py-2 shadow-sm focus:border-blue-500 focus:outline-none"
+            >
-            placeholder="Project ID"
+              <div>
+                <ProjectIcon
+                  v-if="selectedProject"
+                  :entity-id="selectedProject.handleId"
+                  :icon-size="30"
+                  :image-url="selectedProject.image"
+                  class="!size-[2rem] shrink-0 border border-slate-300 bg-white overflow-hidden rounded-full"
                 />
+                <font-awesome
+                  v-else
+                  icon="folder-open"
+                  class="text-slate-400"
+                />
+              </div>
+              <div class="overflow-hidden">
+                <div
+                  :class="{
+                    'text-sm font-semibold': selectedProject,
+                    'text-slate-400': !selectedProject,
+                  }"
+                  class="truncate"
+                >
+                  {{
+                    selectedProject
+                      ? selectedProject.name || "Unnamed Project"
+                      : "Select Project…"
+                  }}
+                </div>
+                <div
+                  v-if="selectedProject"
+                  class="text-xs text-slate-500 truncate"
+                >
+                  <font-awesome icon="user" class="text-slate-400" />
+                  {{ selectedProjectIssuerName }}
+                </div>
+              </div>
+            </div>
+            <button
+              v-if="selectedProject"
+              class="text-rose-600 px-3 py-2 border border-slate-400 border-l-0 rounded-r hover:bg-rose-600 hover:text-white hover:border-rose-600"
+              @click="unsetProjectLink"
+            >
+              <font-awesome icon="trash-can" />
+            </button>
+          </div>
         </div>
 
         <button
@@ -224,6 +267,17 @@
       </form>
     </div>
 
+    <MeetingProjectDialog
+      ref="meetingProjectDialog"
+      :all-projects="allProjects"
+      :active-did="activeDid"
+      :all-my-dids="allMyDids"
+      :all-contacts="allContacts"
+      :notify="$notify"
+      :load-more-callback="handleLoadMoreProjects"
+      @assign="handleProjectLinkAssigned"
+    />
+
     <!-- Members Section -->
     <div
       v-if="!isLoading && currentMeeting != null && !!currentMeeting.password"
@@ -292,10 +346,13 @@ import { RouteLocationNormalizedLoaded, Router } from "vue-router";
 import QuickNav from "../components/QuickNav.vue";
 import TopMessage from "../components/TopMessage.vue";
 import MembersList from "../components/MembersList.vue";
+import MeetingProjectDialog from "../components/MeetingProjectDialog.vue";
+import ProjectIcon from "../components/ProjectIcon.vue";
 import {
   errorStringForLog,
   getHeaders,
   serverMessageForUser,
+  didInfo,
 } from "../libs/endorserServer";
 import { encryptMessage } from "../libs/crypto";
 import { PlatformServiceMixin } from "@/utils/PlatformServiceMixin";
@@ -309,6 +366,8 @@ import {
   NOTIFY_MEETING_DELETED,
   NOTIFY_MEETING_LINK_COPIED,
 } from "@/constants/notifications";
+import { PlanData } from "../interfaces/records";
+import { Contact } from "../db/tables/contacts";
 interface ServerMeeting {
   groupId: number; // from the server
   name: string; // to & from the server
@@ -331,6 +390,8 @@ interface MeetingSetupInputs {
     QuickNav,
     TopMessage,
     MembersList,
+    MeetingProjectDialog,
+    ProjectIcon,
   },
   mixins: [PlatformServiceMixin],
 })
@@ -354,6 +415,9 @@ export default class OnboardMeetingView extends Vue {
   isRegistered = false;
   showDeleteConfirm = false;
   fullName = "";
+  allProjects: PlanData[] = [];
+  allContacts: Contact[] = [];
+  allMyDids: string[] = [];
   get minDateTime() {
     const now = new Date();
     now.setMinutes(now.getMinutes() + 5); // Set minimum 5 minutes in the future
@@ -370,6 +434,15 @@ export default class OnboardMeetingView extends Vue {
     this.fullName = settings?.firstName || "";
     this.isRegistered = !!settings?.isRegistered;
 
+    // Load contacts and DIDs for dialog
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.allContacts = await (this as any).$contactsByDateAdded();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.allMyDids = await (this as any).$getAllAccountDids();
+
+    // Load projects
+    await this.loadProjects();
+
     await this.fetchCurrentMeeting();
     this.isLoading = false;
   }
@@ -710,5 +783,137 @@ export default class OnboardMeetingView extends Vue {
       this.notify.error("Failed to copy meeting link to clipboard.");
     }
   }
+
+  /**
+   * Load projects from the API
+   * @param beforeId - Optional rowId for pagination (loads projects before this ID)
+   */
+  async loadProjects(beforeId?: string) {
+    try {
+      const headers = await getHeaders(this.activeDid);
+      let url = `${this.apiServer}/api/v2/report/plans`;
+      if (beforeId) {
+        url += `?beforeId=${encodeURIComponent(beforeId)}`;
+      }
+      const resp = await this.axios.get(url, { headers });
+
+      if (resp.status === 200 && resp.data.data) {
+        const newProjects = resp.data.data.map(
+          (plan: {
+            name: string;
+            description: string;
+            image?: string;
+            handleId: string;
+            issuerDid: string;
+            rowId?: string;
+          }) => ({
+            name: plan.name,
+            description: plan.description,
+            image: plan.image,
+            handleId: plan.handleId,
+            issuerDid: plan.issuerDid,
+            rowId: plan.rowId,
+          }),
+        );
+
+        if (beforeId) {
+          // Pagination: append new projects
+          this.allProjects.push(...newProjects);
+        } else {
+          // Initial load: replace array
+          this.allProjects = newProjects;
+        }
+      }
+    } catch (error) {
+      this.$logAndConsole(
+        "Error loading projects: " + errorStringForLog(error),
+        true,
+      );
+      // Don't show error to user - just leave projects empty (or keep existing if pagination)
+      if (!beforeId) {
+        this.allProjects = [];
+      }
+    }
+  }
+
+  /**
+   * Handle loading more projects when EntityGrid reaches the end
+   * Called by MeetingProjectDialog via loadMoreCallback
+   * @param entities - Current array of projects
+   */
+  async handleLoadMoreProjects(
+    entities: Array<{
+      handleId: string;
+      rowId?: string;
+    }>,
+  ): Promise<void> {
+    if (entities.length === 0) {
+      return;
+    }
+
+    const lastProject = entities[entities.length - 1];
+    if (!lastProject.rowId) {
+      // No rowId means we can't paginate - likely end of data
+      return;
+    }
+
+    await this.loadProjects(lastProject.rowId);
+  }
+
+  /**
+   * Computed property for selected project
+   * Derives the project from projectLink by finding it in allProjects
+   */
+  get selectedProject(): PlanData | null {
+    if (!this.newOrUpdatedMeetingInputs?.projectLink) {
+      return null;
+    }
+    return (
+      this.allProjects.find(
+        (p) => p.handleId === this.newOrUpdatedMeetingInputs?.projectLink,
+      ) || null
+    );
+  }
+
+  /**
+   * Computed property for selected project issuer display name
+   * Uses didInfo to format the issuer name similar to ProjectCard
+   */
+  get selectedProjectIssuerName(): string {
+    if (!this.selectedProject) {
+      return "";
+    }
+    return didInfo(
+      this.selectedProject.issuerDid,
+      this.activeDid,
+      this.allMyDids,
+      this.allContacts,
+    );
+  }
+
+  /**
+   * Open the project link selection dialog
+   */
+  openProjectLinkDialog(): void {
+    (this.$refs.meetingProjectDialog as MeetingProjectDialog).open();
+  }
+
+  /**
+   * Handle project assignment from dialog
+   */
+  handleProjectLinkAssigned(project: PlanData): void {
+    if (this.newOrUpdatedMeetingInputs) {
+      this.newOrUpdatedMeetingInputs.projectLink = project.handleId;
+    }
+  }
+
+  /**
+   * Unset the project link and revert to initial state
+   */
+  unsetProjectLink(): void {
+    if (this.newOrUpdatedMeetingInputs) {
+      this.newOrUpdatedMeetingInputs.projectLink = "";
+    }
+  }
 }
 </script>