@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

package/dist/{shared/interfaces/database.identity-queries.d.ts → platform/database/identity-queries.d.ts}

@@ -1,8 +1,8 @@
 /**
  * Database operations for profiles, intents, and their vector search.
  */
-import type { UserIdentity } from '../schemas/identity.schema.js';
-import type { ActiveIntent, ActiveNetworkMembershipPair, ArchiveResult, CreateIntentData, CreatedIntent, IntentRecord, NetworkMembership, OnboardingState, SimilarIntent, SimilarIntentSearchOptions, UpdateIntentData, UserRecord, UserSocial } from './database.entities.js';
+import type { UserIdentity } from '../../protocol/schemas/identity.schema.js';
+import type { ActiveIntent, ActiveNetworkMembershipPair, ArchiveResult, CreateIntentData, CreatedIntent, IntentLifecycleStatus, IntentRecord, NetworkMembership, OnboardingState, SimilarIntent, SimilarIntentSearchOptions, TransitionLifecycleResult, UpdateIntentData, UserRecord, UserSocial } from './entities.js';
 /** Profile, intent-lifecycle and retrieval operations. */
 export interface DatabaseIdentityQueries {
     /**
@@ -26,8 +26,6 @@ export interface DatabaseIdentityQueries {
     /**
      * Updates user account fields (name, location, socials).
      * Merges socials with existing values (does not overwrite the whole object).
-     * Used by create_user_context tool to persist user-provided info before
-     * invoking the Profile Graph in generate mode.
      *
      * @param userId - The unique identifier of the user
      * @param data - Partial user fields to update
@@ -62,17 +60,17 @@ export interface DatabaseIdentityQueries {
      */
     getActiveIntents(userId: string): Promise<ActiveIntent[]>;
     /**
-     * Get active intents that belong to the user and are assigned to a specific index.
-     * Caller must be a member of that index; only the user's own intents are returned.
+     * Get active intents that belong to the user and are assigned to a specific network.
+     * Caller must be a member of that network; only the user's own intents are returned.
      *
-     * @param userId - The user requesting (must be a member of the index)
-     * @param indexNameOrId - Network UUID or display name (e.g. "Commons")
-     * @returns Array of active intents in that index for the user, or empty if not a member / no match
+     * @param userId - The user requesting (must be a member of the network)
+     * @param networkNameOrId - Network UUID or display name (e.g. "Commons")
+     * @returns Array of active intents in that network for the user, or empty if not a member / no match
      */
-    getIntentsInIndexForMember(userId: string, indexNameOrId: string): Promise<ActiveIntent[]>;
+    getIntentsInNetworkForMember(userId: string, networkNameOrId: string): Promise<ActiveIntent[]>;
     /**
      * Creates a new intent with full processing pipeline.
-     * Handles summarization, embedding generation, and index association.
+     * Handles summarization, embedding generation, and network association.
      *
      * Called when the reconciler outputs a "create" action.
      *
@@ -131,6 +129,44 @@ export interface DatabaseIdentityQueries {
      * ```
      */
     archiveIntent(intentId: string): Promise<ArchiveResult>;
+    /**
+     * Atomically transition an owned intent between ACTIVE and PAUSED.
+     * Terminal/archived intents and out-of-scope requests are rejected.
+     * Idempotent: re-requesting the current status reports `changed: false`.
+     *
+     * Called when the reconciler outputs a "transition" action.
+     */
+    transitionIntentLifecycle(input: {
+        intentId: string;
+        userId: string;
+        status: 'ACTIVE' | 'PAUSED';
+        networkScopeId?: string | null;
+    }): Promise<TransitionLifecycleResult>;
+    /**
+     * Compare-and-set a resume back to PAUSED when its discovery-enqueue
+     * acknowledgement failed. A concurrent lifecycle write is never overwritten.
+     */
+    compensateFailedResume(input: {
+        intentId: string;
+        userId: string;
+        lifecycleVersionMs: number;
+        networkScopeId?: string | null;
+    }): Promise<{
+        status: IntentLifecycleStatus;
+        lifecycleVersionMs: number;
+    } | null>;
+    /**
+     * Deletes every intent–network association for an archived intent.
+     * Called as part of the "expire" action's cleanup.
+     */
+    deleteIntentNetworkAssociations(intentId: string): Promise<void>;
+    /**
+     * Expires every non-expired opportunity where this intent appears as an actor.
+     * Called as part of the "expire" action's cleanup.
+     *
+     * @returns The number of opportunities expired.
+     */
+    expireOpportunitiesByIntentActor(intentId: string): Promise<number>;
     /**
      * Retrieves a single intent by ID.
      *
@@ -166,30 +202,30 @@ export interface DatabaseIdentityQueries {
     getIntentWithOwnership(intentId: string, userId: string): Promise<IntentRecord | null>;
     /**
      * Gets Network IDs where the user has auto-assign membership enabled.
-     * Used for determining which indexes to associate new intents with.
+     * Used for determining which networks to associate new intents with.
      *
      * @param userId - The unique identifier of the user
      * @returns Array of network IDs
      *
      * @example
      * ```typescript
-     * const networkIds = await db.getUserIndexIds(userId);
+     * const networkIds = await db.getUserNetworkIds(userId);
      * if (networkIds.length > 0) {
      *   await db.associateIntentWithNetworks(intentId, networkIds);
      * }
      * ```
      */
-    getUserIndexIds(userId: string): Promise<string[]>;
+    getUserNetworkIds(userId: string): Promise<string[]>;
     /**
      * Retrieves all networks the user is a member of with full details.
-     * Used for displaying network memberships in chat (index_query).
+     * Used for displaying network memberships in chat.
      *
      * @param userId - The unique identifier of the user
      * @returns Array of network memberships with details
      */
     getNetworkMemberships(userId: string): Promise<NetworkMembership[]>;
     /**
-     * Get a single network membership by index and user.
+     * Get a single network membership by network and user.
      * Used when the preloaded memberships list may not contain this network (e.g. after isNetworkMember check).
      *
      * @param networkId - The network ID
@@ -199,12 +235,11 @@ export interface DatabaseIdentityQueries {
     getNetworkMembership(networkId: string, userId: string): Promise<NetworkMembership | null>;
     /**
      * Return only requested user/network pairs backed by a live membership row
-     * and a non-deleted network. Permissions are intentionally not filtered:
-     * personal-network contacts are valid discovery participants.
+     * and a non-deleted network. Permissions are intentionally not filtered.
      */
     getActiveNetworkMembershipPairs(pairs: ActiveNetworkMembershipPair[]): Promise<ActiveNetworkMembershipPair[]>;
     /**
-     * Get index by ID with core fields. Used for opportunity presentation and context rendering.
+     * Get network by ID with core fields. Used for opportunity presentation and context rendering.
      */
     getNetwork(networkId: string): Promise<{
         id: string;
@@ -215,7 +250,7 @@ export interface DatabaseIdentityQueries {
         permissions?: Record<string, unknown> | null;
     } | null>;
     /**
-     * Get index by ID with permissions (e.g. joinPolicy). Used by chat tools for create_index_membership.
+     * Get network by ID with permissions (e.g. joinPolicy). Used when a member joins a community.
      */
     getNetworkWithPermissions(networkId: string): Promise<{
         id: string;

package/dist/platform/database/member-queries.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Database operations for user contexts.
+ */
+/** User-context operations. */
+export interface DatabaseMemberQueries {
+    /**
+     * Finds an existing DM conversation between two users, or creates one.
+     * Uses a unique `dmPair` column (sorted user IDs joined by ':') to
+     * prevent duplicate DMs under concurrency. Used by the Start Chat flow
+     * (Plan B Task 8) to atomically surface the h2h conversation when
+     * accepting an opportunity.
+     */
+    getOrCreateDM(userA: string, userB: string, participantType?: 'user' | 'agent'): Promise<{
+        id: string;
+    }>;
+    /**
+     * Clears hiddenAt for a user on a conversation, making it visible in their
+     * conversation list again. Called by startChat when reusing an existing DM
+     * that the user had previously hidden.
+     */
+    unhideConversation(userId: string, conversationId: string): Promise<void>;
+    /** Find a user by email. */
+    getUserByEmail(email: string): Promise<{
+        id: string;
+        name: string;
+        email: string;
+    } | null>;
+    /**
+     * Profile text for a user (sourced from the users row). Used by discovery.
+     */
+    getUserContext(userId: string, networkId: string | null): Promise<{
+        id: string;
+        text: string;
+        embedding: number[];
+        generatedAt: Date;
+    } | null>;
+    /**
+     * Cosine similarity search against intent embeddings using a context embedding.
+     * Restores the profile→intent cross-search deleted when Path B was removed.
+     */
+    searchIntentsByContextEmbedding(params: {
+        embedding: number[];
+        networkIds: string[];
+        excludeUserId: string;
+        limit: number;
+        minScore?: number;
+    }): Promise<Array<{
+        intentId: string;
+        userId: string;
+        networkId: string;
+        payload: string;
+        summary: string | null;
+        similarity: number;
+    }>>;
+}

package/dist/platform/database/member-queries.js

@@ -0,0 +1,4 @@
+/**
+ * Database operations for user contexts.
+ */
+export {};

package/dist/platform/database/negotiation.d.ts

@@ -0,0 +1,38 @@
+import type { NegotiationDecision, NegotiationState, NegotiationTurn } from '../../protocol/negotiation.rules.js';
+/** A host must evaluate the supplied policy against locked, current data and apply its transition atomically. */
+export interface NegotiationDatabase {
+    readNegotiationState(id: string, userId: string): Promise<NegotiationState | null>;
+    commitNegotiationTurn(id: string, userId: string, turn: NegotiationTurn, decide: (state: NegotiationState | null) => NegotiationDecision): Promise<NegotiationDecision>;
+}
+/**
+ * The host's read of a negotiation record.
+ *
+ * Index is the server for every negotiation, so a graph never assembles a
+ * transcript from messages — it asks the host for the turn log of one
+ * opportunity's negotiation, already projected onto the reading seat.
+ */
+/** What one seat decided, and what it said about it. */
+export interface NegotiationContextTurn {
+    action: 'propose' | 'counter' | 'accept' | 'decline';
+    message: string;
+    /** True when the viewer's own seat authored this turn. */
+    own: boolean;
+}
+/** How a negotiation ended, once it has. */
+export type NegotiationContextOutcome = 'agreed' | 'declined' | 'closed';
+/** One negotiation, from the reading seat's side. */
+export interface NegotiationContextRecord {
+    outcome: NegotiationContextOutcome | null;
+    turns: NegotiationContextTurn[];
+}
+/** The one thing a host must do for negotiation-grounded presentation. */
+export interface NegotiationContextDatabase {
+    /**
+     * The negotiation attached to an opportunity, as one seat sees it.
+     *
+     * @param opportunityId - The opportunity.
+     * @param viewerUserId - The reading seat's owner.
+     * @returns The record, or null when there is none or the viewer holds no seat.
+     */
+    readNegotiationContext(opportunityId: string, viewerUserId: string): Promise<NegotiationContextRecord | null>;
+}

package/dist/{shared/interfaces/database.network-queries.d.ts → platform/database/network-queries.d.ts}

@@ -1,13 +1,13 @@
 /**
- * Database operations for intent-network assignment and index ownership.
+ * Database operations for intent-network assignment and network ownership.
  */
-import type { UserIdentity } from '../schemas/identity.schema.js';
-import type { NetworkAssignmentMetadata } from '../schemas/network-assignment.schema.js';
-import type { ActiveIntent, AssignmentNetworkMembership, Id, IndexMemberDetails, IndexedIntentDetails, IntentNetworkFinalAssignmentResult, NetworkAssignmentContext, OwnedIndex, UpdateIndexSettingsData } from './database.entities.js';
-/** Network assignment and owner-only index operations. */
+import type { UserIdentity } from '../../protocol/schemas/identity.schema.js';
+import type { NetworkAssignmentMetadata } from '../../protocol/schemas/network-assignment.schema.js';
+import type { ActiveIntent, AssignmentNetworkMembership, Id, IntentNetworkFinalAssignmentResult, NetworkAssignmentContext, NetworkIntentDetails, NetworkMemberDetails, OwnedNetwork, UpdateNetworkSettingsData } from './entities.js';
+/** Network assignment and owner-only network operations. */
 export interface DatabaseNetworkQueries {
     /**
-     * Intent fields needed for index appropriateness evaluation.
+     * Intent fields needed for network appropriateness evaluation.
      */
     getIntentForIndexing(intentId: string): Promise<{
         id: string;
@@ -17,19 +17,18 @@ export interface DatabaseNetworkQueries {
         sourceId: string | null;
     } | null>;
     /**
-     * Index + member prompts for a user in an index (only when member has autoAssign).
+     * Network + member prompts for a user in a network (only when member has autoAssign).
      * Returns null if user is not a member or autoAssign is false.
      */
     getNetworkMemberContext(networkId: string, userId: string): Promise<NetworkAssignmentContext | null>;
     /**
      * Network memberships that should be considered for assignment policy. Unlike
-     * getUserIndexIds, this is not gated by network_members.autoAssign and carries
-     * personal-index metadata so scoped writes can include the user's personal network.
+     * getUserNetworkIds, this is not gated by network_members.autoAssign.
      */
     getAssignmentNetworkMembershipsForUser(userId: string): Promise<AssignmentNetworkMembership[]>;
     /**
      * Network IDs that should be considered for assignment policy. Unlike
-     * getUserIndexIds, this is not gated by network_members.autoAssign.
+     * getUserNetworkIds, this is not gated by network_members.autoAssign.
      * @deprecated Prefer getAssignmentNetworkMembershipsForUser for scope-aware assignment.
      */
     getAssignmentNetworkIdsForUser(userId: string): Promise<string[]>;
@@ -39,11 +38,11 @@ export interface DatabaseNetworkQueries {
      */
     getNetworkAssignmentContext(networkId: string, userId: string): Promise<NetworkAssignmentContext | null>;
     /**
-     * Whether the intent is currently assigned to the index.
+     * Whether the intent is currently assigned to the network.
      */
-    isIntentAssignedToIndex(intentId: string, networkId: string): Promise<boolean>;
+    isIntentAssignedToNetwork(intentId: string, networkId: string): Promise<boolean>;
     /**
-     * Assigns an intent to an index (inserts intent_indexes row).
+     * Assigns an intent to a network (inserts intent_networks row).
      */
     assignIntentToNetwork(intentId: string, networkId: string, relevancyScore?: number, assignmentMetadata?: NetworkAssignmentMetadata): Promise<void>;
     /**
@@ -53,29 +52,29 @@ export interface DatabaseNetworkQueries {
      */
     assignIntentToNetworkIfMember(userId: string, intentId: string, networkId: string, relevancyScore?: number, assignmentMetadata?: NetworkAssignmentMetadata): Promise<IntentNetworkFinalAssignmentResult>;
     /**
-     * Returns per-index relevancy scores for an intent's index assignments.
+     * Returns per-network relevancy scores for an intent's network assignments.
      */
-    getIntentIndexScores(intentId: string): Promise<Array<{
+    getIntentNetworkScores(intentId: string): Promise<Array<{
         networkId: string;
         relevancyScore: number | null;
         assignmentMetadata?: NetworkAssignmentMetadata | null;
     }>>;
     /**
-     * Removes an intent from an index (deletes intent_indexes row).
+     * Removes an intent from a network (deletes intent_networks row).
      */
-    unassignIntentFromIndex(intentId: string, networkId: string): Promise<void>;
+    unassignIntentFromNetwork(intentId: string, networkId: string): Promise<void>;
     /**
      * Returns all network IDs that an intent is registered to.
      */
     getNetworkIdsForIntent(intentId: string): Promise<string[]>;
     /**
-     * Get indexes where the user has owner permissions.
-     * Returns full index details with member and intent counts.
+     * Get networks where the user has owner permissions.
+     * Returns full network details with member and intent counts.
      *
      * @param userId - The user ID to check ownership for
-     * @returns Array of owned indexes with counts
+     * @returns Array of owned networks with counts
      */
-    getOwnedIndexes(userId: string): Promise<OwnedIndex[]>;
+    getOwnedNetworks(userId: string): Promise<OwnedNetwork[]>;
     /**
      * Get public networks (joinPolicy 'anyone') that the user has not joined.
      * Used for discovering communities available to join.
@@ -83,7 +82,7 @@ export interface DatabaseNetworkQueries {
      * @param userId - The user ID to check memberships against
      * @returns Object containing array of public networks with owner info
      */
-    getPublicIndexesNotJoined(userId: string): Promise<{
+    getPublicNetworksNotJoined(userId: string): Promise<{
         networks: Array<{
             id: string;
             title: string;
@@ -97,59 +96,59 @@ export interface DatabaseNetworkQueries {
         }>;
     }>;
     /**
-     * Check if user is an owner of a specific index.
+     * Check if user is an owner of a specific network.
      *
-     * @param networkId - The index to check
+     * @param networkId - The network to check
      * @param userId - The user to verify ownership for
      * @returns True if user is an owner
      */
-    isIndexOwner(networkId: string, userId: string): Promise<boolean>;
+    isNetworkOwner(networkId: string, userId: string): Promise<boolean>;
     /**
-     * Check if user is a member of a specific index.
+     * Check if user is a member of a specific network.
      *
-     * @param networkId - The index to check
+     * @param networkId - The network to check
      * @param userId - The user to verify membership for
      * @returns True if user is a member
      */
     isNetworkMember(networkId: string, userId: string): Promise<boolean>;
     /**
-     * Get all members of an index with their details.
+     * Get all members of a network with their details.
      * **OWNER ONLY** - throws if user is not an owner.
      *
-     * @param networkId - The index to get members for
+     * @param networkId - The network to get members for
      * @param requestingUserId - The user requesting (must be owner)
      * @returns Array of member details with intent counts
      * @throws Error if requestingUserId is not an owner
      */
-    getNetworkMembersForOwner(networkId: string, requestingUserId: string): Promise<IndexMemberDetails[]>;
+    getNetworkMembersForOwner(networkId: string, requestingUserId: string): Promise<NetworkMemberDetails[]>;
     /**
-     * Get all members of an index with their details.
-     * **MEMBER ONLY** - any member of the index can list members (not just owners).
+     * Get all members of a network with their details.
+     * **MEMBER ONLY** - any member of the network can list members (not just owners).
      * Returns same shape as getNetworkMembersForOwner; email may be omitted for privacy.
      *
-     * @param networkId - The index to get members for
-     * @param requestingUserId - The user requesting (must be a member of the index)
+     * @param networkId - The network to get members for
+     * @param requestingUserId - The user requesting (must be a member of the network)
      * @returns Array of member details with intent counts
-     * @throws Error if requestingUserId is not a member of the index
+     * @throws Error if requestingUserId is not a member of the network
      */
-    getNetworkMembersForMember(networkId: string, requestingUserId: string): Promise<IndexMemberDetails[]>;
+    getNetworkMembersForMember(networkId: string, requestingUserId: string): Promise<NetworkMemberDetails[]>;
     /**
      * Get all members from every network the user is a member of (deduplicated).
-     * Used for mentionable-users: anyone who shares at least one index with the requesting user.
+     * Used for mentionable-users: anyone who shares at least one network with the requesting user.
      *
      * @param userId - The signed-in user
      * @returns Array of member summaries (id, name, avatar only; no email)
      */
-    getMembersFromUserIndexes(userId: Id<'users'>): Promise<{
+    getMembersFromUserNetworks(userId: Id<'users'>): Promise<{
         userId: Id<'users'>;
         name: string;
         avatar: string | null;
     }[]>;
     /**
-     * Get all indexed intents for an index.
+     * Get all assigned intents for a network.
      * **OWNER ONLY** - throws if user is not an owner.
      *
-     * @param networkId - The index to get intents for
+     * @param networkId - The network to get intents for
      * @param requestingUserId - The user requesting (must be owner)
      * @param options - Pagination options
      * @returns Array of intent details with owner info
@@ -158,60 +157,60 @@ export interface DatabaseNetworkQueries {
     getNetworkIntentsForOwner(networkId: string, requestingUserId: string, options?: {
         limit?: number;
         offset?: number;
-    }): Promise<IndexedIntentDetails[]>;
+    }): Promise<NetworkIntentDetails[]>;
     /**
-     * Get all indexed intents for an index.
-     * **MEMBER ONLY** - any member of the index can list intents (not just owners).
+     * Get all assigned intents for a network.
+     * **MEMBER ONLY** - any member of the network can list intents (not just owners).
      *
-     * @param networkId - The index to get intents for
-     * @param requestingUserId - The user requesting (must be a member of the index)
+     * @param networkId - The network to get intents for
+     * @param requestingUserId - The user requesting (must be a member of the network)
      * @param options - Pagination options
      * @returns Array of intent details with owner info
-     * @throws Error if requestingUserId is not a member of the index
+     * @throws Error if requestingUserId is not a member of the network
      */
     getNetworkIntentsForMember(networkId: string, requestingUserId: string, options?: {
         limit?: number;
         offset?: number;
-    }): Promise<IndexedIntentDetails[]>;
+    }): Promise<NetworkIntentDetails[]>;
     /**
-     * Get the caller's own active intents across a set of indexes.
+     * Get the caller's own active intents across a set of networks.
      * Returns intents owned by `userId` that are linked (via intent_networks)
-     * to at least one of `indexIds`. Used by network-scoped agents to honor
-     * indexScope without falling back to global getActiveIntents (which would
-     * include intents in indexes outside scope).
+     * to at least one of `networkIds`. Used by network-scoped agents to honor
+     * networkScope without falling back to global getActiveIntents (which would
+     * include intents in networks outside scope).
      *
      * @param userId - The intent owner (always the caller).
-     * @param indexIds - The set of network IDs to filter on. Empty → empty result.
-     * @returns Active intents owned by userId in any of indexIds, deduped by intent id.
+     * @param networkIds - The set of network IDs to filter on. Empty → empty result.
+     * @returns Active intents owned by userId in any of networkIds, deduped by intent id.
      */
-    getActiveIntentsAcrossIndexes(userId: string, indexIds: string[]): Promise<ActiveIntent[]>;
+    getActiveIntentsAcrossNetworks(userId: string, networkIds: string[]): Promise<ActiveIntent[]>;
     /**
-     * Update index settings.
+     * Update network settings.
      * **OWNER ONLY** - throws if user is not an owner.
      *
-     * @param networkId - The index to update
+     * @param networkId - The network to update
      * @param requestingUserId - The user requesting (must be owner)
      * @param data - The settings to update
-     * @returns The updated index
+     * @returns The updated network
      * @throws Error if requestingUserId is not an owner
      */
-    updateIndexSettings(networkId: string, requestingUserId: string, data: UpdateIndexSettingsData): Promise<OwnedIndex>;
+    updateNetworkSettings(networkId: string, requestingUserId: string, data: UpdateNetworkSettingsData): Promise<OwnedNetwork>;
     /**
      * Soft-delete a network (set deletedAt).
-     * Caller must ensure network is not personal and has no other members.
+     * Caller must ensure the network has no other members.
      *
      * @param networkId - The network to soft-delete
      */
     softDeleteNetwork(networkId: string): Promise<void>;
     /**
      * Delete a user's profile (removes profile row).
-     * Used after confirmation in chat tools.
+     * Used after the owner confirms the assignment.
      *
      * @param userId - User whose profile to delete
      */
     deleteProfile(userId: string): Promise<void>;
     /**
-     * Get a user's profile including its row id (for update_user_context validation).
+     * Get a user's profile including its row id.
      *
      * @param userId - The user whose profile to fetch
      * @returns Profile with id, or null if not found
@@ -220,7 +219,7 @@ export interface DatabaseNetworkQueries {
         id: string;
     }) | null>;
     /**
-     * Create a new index and return its record.
+     * Create a new network and return its record.
      *
      * @param data - Title, optional prompt, optional imageUrl, optional joinPolicy
      * @returns The created network with id, title, prompt, imageUrl, permissions
@@ -243,9 +242,9 @@ export interface DatabaseNetworkQueries {
         };
     }>;
     /**
-     * Count members in an index (for delete guard).
+     * Count members in a network (for delete guard).
      *
-     * @param networkId - The index to count
+     * @param networkId - The network to count
      * @returns Number of members
      */
     getNetworkMemberCount(networkId: string): Promise<number>;
@@ -262,14 +261,14 @@ export interface DatabaseNetworkQueries {
         alreadyMember?: boolean;
     }>;
     /**
-     * Removes a user from an index.
+     * Removes a user from a network.
      * Only the network owner can remove members. Cannot remove the owner.
      *
-     * @param networkId - The index to remove from
+     * @param networkId - The network to remove from
      * @param userId - The user to remove
      * @returns success, or wasOwner/notMember if removal failed
      */
-    removeMemberFromIndex(networkId: string, userId: string): Promise<{
+    removeMemberFromNetwork(networkId: string, userId: string): Promise<{
         success: boolean;
         wasOwner?: boolean;
         notMember?: boolean;

package/dist/platform/database/network-queries.js

@@ -0,0 +1,4 @@
+/**
+ * Database operations for intent-network assignment and network ownership.
+ */
+export {};