@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

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

@@ -1,56 +1,10 @@
+import type { NegotiationOpening, NegotiationOpeningDecision } from '../../protocol/negotiation.rules.js';
 /**
- * Database operations for HyDE documents and the opportunity lifecycle.
+ * Database operations for the opportunity lifecycle.
  */
-import type { OutcomeOutbox } from './database.capabilities.js';
-import type { CreateHydeDocumentData, CreateOpportunityData, HydeDocument, HydeSourceType, IntentScopedOpportunityPersistenceResult, Opportunity, OpportunityActor, OpportunityNetworkEligibility, OpportunityQueryOptions, OpportunityStatus } from './database.entities.js';
-/** HyDE document and opportunity persistence operations. */
+import type { CreateIntentCounterpartyData, CreateOpportunityData, IntentScopedOpportunityPersistenceResult, OpenedNegotiation, Opportunity, OpportunityActor, OpportunityNetworkEligibility, OpportunityQueryOptions, OpportunityStatus } from './entities.js';
+/** Opportunity persistence operations. */
 export interface DatabaseOpportunityQueries {
-    /**
-     * Get a HyDE document by source and strategy/lens hash.
-     * Returns the first matching document when multiple target corpuses exist.
-     *
-     * @param sourceType - 'intent' | 'query'
-     * @param sourceId - Source entity ID (e.g. intent ID, user ID)
-     * @param strategy - Lens hash (SHA-256 of lens label) or legacy strategy name
-     * @returns The HyDE document or null if not found
-     */
-    getHydeDocument(sourceType: HydeSourceType, sourceId: string, strategy: string): Promise<HydeDocument | null>;
-    /**
-     * Get all HyDE documents for a source (all strategies).
-     *
-     * @param sourceType - 'intent' | 'query'
-     * @param sourceId - Source entity ID
-     * @returns Array of HyDE documents for that source
-     */
-    getHydeDocumentsForSource(sourceType: HydeSourceType, sourceId: string): Promise<HydeDocument[]>;
-    /**
-     * Save a HyDE document (upsert by sourceType + sourceId + strategy/lensHash + targetCorpus).
-     *
-     * @param data - HyDE document data
-     * @returns The saved HyDE document
-     */
-    saveHydeDocument(data: CreateHydeDocumentData): Promise<HydeDocument>;
-    /**
-     * Delete all HyDE documents for a source (e.g. when intent archived).
-     *
-     * @param sourceType - 'intent' | 'query'
-     * @param sourceId - Source entity ID
-     * @returns Number of documents deleted
-     */
-    deleteHydeDocumentsForSource(sourceType: HydeSourceType, sourceId: string): Promise<number>;
-    /**
-     * Delete expired HyDE documents (expires_at <= now). Used by maintenance jobs.
-     *
-     * @returns Number of documents deleted
-     */
-    deleteExpiredHydeDocuments(): Promise<number>;
-    /**
-     * Get stale HyDE documents for refresh (e.g. createdAt < threshold).
-     *
-     * @param threshold - Date threshold; documents created before this are considered stale
-     * @returns Array of stale HyDE documents
-     */
-    getStaleHydeDocuments(threshold: Date): Promise<HydeDocument[]>;
     /**
      * Create a new opportunity.
      *
@@ -58,6 +12,16 @@ export interface DatabaseOpportunityQueries {
      * @returns The created opportunity
      */
     createOpportunity(data: CreateOpportunityData): Promise<Opportunity>;
+    /**
+     * Turn every pair discovery scored into an opportunity with a negotiation
+     * record beside it, and hand back the ones that were newly opened.
+     *
+     * There is no open decision to make: whether a match is worth pursuing is
+     * the initiator's first turn. Implementations key on `pairKey`, so a pair the
+     * counterparty's run already opened is skipped and the result is exactly the
+     * set the caller still owes a `negotiation.turn`.
+     */
+    openCounterparties(pairs: CreateIntentCounterpartyData[], decide: (pair: NegotiationOpening) => NegotiationOpeningDecision): Promise<OpenedNegotiation[]>;
     /**
      * Atomically create only while every actor still has an active membership on
      * the actor's network. Implementations lock the membership rows through the
@@ -66,13 +30,13 @@ export interface DatabaseOpportunityQueries {
     createOpportunityIfNetworkEligible?(data: CreateOpportunityData, eligibility: OpportunityNetworkEligibility): Promise<Opportunity | null>;
     /**
      * Intent-scoped discovery persistence boundary. Implementations serialize on
-     * normalized participant pair + trigger intent, re-check same-trigger recent
-     * duplicates and pair-global active negotiations, then create/expire while
-     * the existing network eligibility locks remain held.
+     * the normalized intent pair, reject any existing opportunity for that exact
+     * pair, then create/expire while the existing network eligibility locks
+     * remain held. Other intents remain fully independent.
      */
     persistIntentScopedOpportunityIfNetworkEligible?(data: CreateOpportunityData, expireIds: string[], eligibility: OpportunityNetworkEligibility & {
         triggerIntentId: string;
-    }, dedupWindowMs: number): Promise<IntentScopedOpportunityPersistenceResult | null>;
+    }): Promise<IntentScopedOpportunityPersistenceResult | null>;
     /**
      * Atomically update status only while the supplied participant anchors remain
      * active and, when supplied, the opportunity still has `expectedStatus`.
@@ -138,7 +102,7 @@ export interface DatabaseOpportunityQueries {
      */
     getLivePoolOpportunitiesForIntent(recipientUserId: string, intentId: string): Promise<Opportunity[]>;
     /**
-     * Get opportunities in an index (for index admins).
+     * Get opportunities in a network (for network admins).
      *
      * @param networkId - Network ID
      * @param options - Optional filters and pagination
@@ -150,45 +114,9 @@ export interface DatabaseOpportunityQueries {
      *
      * @param id - Opportunity ID
      * @param status - New status
-     * @param acceptedBy - Required when `status === 'accepted'`
-     * @param outbox - Optional IND-434 atomic outcome-capture (same-txn insert)
      * @returns The updated opportunity or null if not found
      */
-    updateOpportunityStatus(id: string, status: OpportunityStatus, acceptedBy?: string, outbox?: OutcomeOutbox): Promise<Opportunity | null>;
-    /**
-     * Atomically restores a taskless negotiation attempt to its pre-negotiation status.
-     * Serializes with exact-attempt task creation, then transitions only the exact
-     * still-current `negotiating` version when no qualifying negotiation task exists.
-     *
-     * @param id - Opportunity ID
-     * @param expectedUpdatedAt - Persistence boundary for this negotiation attempt
-     * @param fallbackStatus - Status restored when the guarded transition succeeds
-     * @returns The compensated opportunity, or null on a status, version, or task race
-     */
-    compensateTasklessNegotiatingOpportunity(id: string, expectedUpdatedAt: Date, fallbackStatus: 'latent' | 'draft'): Promise<Opportunity | null>;
-    /**
-     * Stamp `actedAt` on the actor matching `actorUserId` and update the
-     * opportunity's status atomically (row-lock + JSONB merge in one txn).
-     *
-     * Used by `sendNode` (status → 'pending') and `updateNode` (status →
-     * 'accepted'). The self-accept guard is enforced in the caller, not here —
-     * this method blindly stamps. Callers must pre-check `actor.actedAt` before
-     * invocation when the semantics require it (i.e. accepting).
-     *
-     * @param id - Opportunity ID
-     * @param actorUserId - The user whose actor entry should be stamped
-     * @param status - New opportunity status
-     * @param acceptedBy - Required when `status === 'accepted'`
-     * @param outbox - Optional IND-434 atomic outcome-capture (same-txn insert)
-     * @returns The updated opportunity, or null if not found
-     */
-    stampOpportunityActorAction(id: string, actorUserId: string, status: OpportunityStatus, acceptedBy?: string, outbox?: OutcomeOutbox): Promise<Opportunity | null>;
-    /**
-     * Update the `approved` field on an opportunity's introducer actor.
-     * Fetches the opportunity, patches the matching actor in JS, and writes
-     * the updated actors JSONB back. Returns the updated opportunity or null.
-     */
-    updateOpportunityActorApproval(id: string, introducerUserId: string, approved: boolean): Promise<Opportunity | null>;
+    updateOpportunityStatus(id: string, status: OpportunityStatus): Promise<Opportunity | null>;
     /**
      * Create one opportunity and expire others in a single transaction.
      * Atomic: insert then update status to 'expired' for each id in expireIds.
@@ -208,7 +136,7 @@ export interface DatabaseOpportunityQueries {
         expired: Opportunity[];
     } | null>;
     /**
-     * Check if an opportunity already exists between the given actors in the index (deduplication).
+     * Check if an opportunity already exists between the given actors in the network (deduplication).
      *
      * @param actorIds - Array of user IDs that would be actors
      * @param networkId - Network ID
@@ -219,7 +147,7 @@ export interface DatabaseOpportunityQueries {
      * Find opportunities whose actors contain all the given user IDs.
      *
      * The `includeIntroducers` flag controls actor matching: when false (default), matching
-     * is restricted to non-introducer roles; when true, any role in `actors` counts.
+     * is restricted by role; when true, any role in `actors` counts.
      *
      * Index-agnostic. Ordered by updatedAt desc.
      *
@@ -236,7 +164,7 @@ export interface DatabaseOpportunityQueries {
      * IND-567 Rejection cool-down: returns the subset of `candidateUserIds` that
      * have at least one non-draft opportunity with `discovererId` whose `updatedAt`
      * falls within the last `windowMs` milliseconds AND whose status is `rejected`
-     * or `stalled`. Used by the evaluation node to apply a score penalty before
+     * `rejected`. Used by the evaluation node to apply a score penalty before
      * sending candidates to the LLM, suppressing cross-query re-surfacing of
      * recently-rejected pairs.
      *
@@ -246,7 +174,7 @@ export interface DatabaseOpportunityQueries {
      * @param discovererId - User running discovery
      * @param candidateUserIds - Candidate user IDs to check (may be empty — return [])
      * @param windowMs - Look-back window in milliseconds
-     * @returns Candidate user IDs (subset of input) with a recent rejected/stalled opp
+     * @returns Candidate user IDs (subset of input) with a recent rejected opp
      */
     getRecentlyRejectedOpportunityCounterparties?(discovererId: string, candidateUserIds: string[], windowMs: number): Promise<string[]>;
     /**
@@ -257,7 +185,7 @@ export interface DatabaseOpportunityQueries {
      */
     expireOpportunitiesByIntent(intentId: string): Promise<number>;
     /**
-     * Expire opportunities for a user removed from an index.
+     * Expire opportunities for a user removed from a network.
      *
      * @param networkId - Network ID
      * @param userId - User ID that was removed
@@ -270,16 +198,4 @@ export interface DatabaseOpportunityQueries {
      * @returns Number of opportunities updated to expired
      */
     expireStaleOpportunities(): Promise<number>;
-    /**
-     * Accept all sibling opportunities between the same actor pair in one transaction.
-     * Selects opportunities where both userId and counterpartUserId are actors and status
-     * is not accepted/expired/rejected, excludes excludeOpportunityId, then bulk-updates status to accepted.
-     * Rolls back on any failure.
-     *
-     * @param userId - First actor user ID
-     * @param counterpartUserId - Second actor user ID
-     * @param excludeOpportunityId - Opportunity ID to exclude (the one already being accepted)
-     * @returns IDs of opportunities that were updated to accepted
-     */
-    acceptSiblingOpportunities(userId: string, counterpartUserId: string, excludeOpportunityId: string): Promise<string[]>;
 }

package/dist/{shared/interfaces/database.port.d.ts → platform/database/port.d.ts}

@@ -5,50 +5,18 @@
  * interfaces keeps each group readable without changing the type one bit —
  * every `Pick<Database, ...>` alias still resolves exactly as before.
  */
-import type { UserIdentity } from '../schemas/identity.schema.js';
-import type { NetworkAssignmentMetadata } from '../schemas/network-assignment.schema.js';
-import type { ActiveIntent, ArchiveResult, CreateHydeDocumentData, CreateIntentData, CreateOpportunityData, CreatedIntent, HydeDocument, HydeSourceType, Id, IndexMemberDetails, IndexedIntentDetails, IntentRecord, NetworkAssignmentContext, NetworkMembership, OnboardingState, Opportunity, OpportunityQueryOptions, OpportunityStatus, OwnedIndex, SimilarIntent, SimilarIntentSearchOptions, UpdateIndexSettingsData, UpdateIntentData, UserRecord, UserSocial } from './database.entities.js';
-import type { DatabaseIdentityQueries } from './database.identity-queries.js';
-import type { DatabaseMemberQueries } from './database.member-queries.js';
-import type { DatabaseNetworkQueries } from './database.network-queries.js';
-import type { DatabaseOpportunityQueries } from './database.opportunity-queries.js';
-/**
- * Abstract database interface for performing specific domain operations.
- * Decouples the protocol layer from the infrastructure layer.
- */
-export interface Database extends DatabaseIdentityQueries, DatabaseNetworkQueries, DatabaseOpportunityQueries, DatabaseMemberQueries {
-}
+import type { UserIdentity } from '../../protocol/schemas/identity.schema.js';
+import type { NetworkAssignmentMetadata } from '../../protocol/schemas/network-assignment.schema.js';
+import type { ActiveIntent, ArchiveResult, CreateIntentData, CreateOpportunityData, CreatedIntent, Id, IntentRecord, NetworkAssignmentContext, NetworkIntentDetails, NetworkMemberDetails, NetworkMembership, OnboardingState, Opportunity, OpportunityQueryOptions, OpportunityStatus, OwnedNetwork, SimilarIntent, SimilarIntentSearchOptions, UpdateIntentData, UpdateNetworkSettingsData, UserRecord, UserSocial } from './entities.js';
 /**
  * Context-bound database for accessing the authenticated user's own resources.
  * Created with authUserId bound at construction; no userId parameter needed on methods.
  *
- * **NOT network-scoped**: Returns ALL of the user's own resources regardless of index.
+ * **NOT network-scoped**: Returns ALL of the user's own resources regardless of network.
  * This is critical for the IntentReconciler which needs the full picture for deduplication.
  *
  * Use via `createUserDatabase(db, authUserId)` factory function.
  */
-export interface AgentActivitySummary {
-    /** The requested reporting window, in hours. */
-    sinceHours: number;
-    /** Number of the user's own non-archived ACTIVE intents. */
-    liveSignalsWatched: number;
-    /** Opportunities created in the window and linked to one of the user's intents. */
-    opportunitiesSurfaced: number;
-    /** Opportunity counts grouped by the user's own signal. */
-    opportunitiesBySignal: Array<{
-        intentId: string;
-        title: string;
-        count: number;
-    }>;
-    /** Current, non-expired questions waiting for the user, grouped by affected mode (QuestionMode values). Meta-network. */
-    pendingQuestionsByMode: Record<string, number>;
-    /** Questions answered by the user during the window, grouped by affected mode (QuestionMode values). Meta-network. */
-    answeredQuestionsByMode: Record<string, number>;
-    /** Distinct opportunity negotiations started during the window. */
-    negotiationsStarted: number;
-    /** Distinct opportunity negotiations completed during the window. */
-    negotiationsCompleted: number;
-}
 export interface UserDatabase {
     /** The bound authenticated user ID */
     readonly authUserId: string;
@@ -76,7 +44,7 @@ export interface UserDatabase {
         label: string;
         value: string;
     }[]): Promise<void>;
-    /** Get ALL active intents for the authenticated user (not index-filtered). */
+    /** Get ALL active intents for the authenticated user (not network-filtered). */
     getActiveIntents(): Promise<ActiveIntent[]>;
     /**
      * Case-insensitive substring search over the authenticated user's own
@@ -98,7 +66,7 @@ export interface UserDatabase {
     archiveIntent(intentId: string): Promise<ArchiveResult>;
     /** Find similar intents among the user's own intents (for deduplication). */
     findSimilarIntents(embedding: number[], options?: SimilarIntentSearchOptions): Promise<SimilarIntent[]>;
-    /** Get intent fields for indexing (own intent). */
+    /** Get intent fields for network assignment (own intent). */
     getIntentForIndexing(intentId: string): Promise<{
         id: string;
         payload: string;
@@ -108,27 +76,27 @@ export interface UserDatabase {
     } | null>;
     /** Associate an intent with networks. */
     associateIntentWithNetworks(intentId: string, networkIds: string[]): Promise<void>;
-    /** Assign an intent to an index. */
+    /** Assign an intent to a network. */
     assignIntentToNetwork(intentId: string, networkId: string, relevancyScore?: number, assignmentMetadata?: NetworkAssignmentMetadata): Promise<void>;
-    /** Unassign an intent from an index. */
-    unassignIntentFromIndex(intentId: string, networkId: string): Promise<void>;
+    /** Unassign an intent from a network. */
+    unassignIntentFromNetwork(intentId: string, networkId: string): Promise<void>;
     /** Get network IDs for an intent. */
     getNetworkIdsForIntent(intentId: string): Promise<string[]>;
-    /** Check if intent is assigned to index. */
-    isIntentAssignedToIndex(intentId: string, networkId: string): Promise<boolean>;
+    /** Check if intent is assigned to network. */
+    isIntentAssignedToNetwork(intentId: string, networkId: string): Promise<boolean>;
     /** Get all network memberships for the authenticated user. */
     getNetworkMemberships(): Promise<NetworkMembership[]>;
     /** Get network IDs with auto-assign enabled for the authenticated user. */
-    getUserIndexIds(): Promise<string[]>;
-    /** Get indexes owned by the authenticated user. */
-    getOwnedIndexes(): Promise<OwnedIndex[]>;
+    getUserNetworkIds(): Promise<string[]>;
+    /** Get networks owned by the authenticated user. */
+    getOwnedNetworks(): Promise<OwnedNetwork[]>;
     /** Get a specific network membership for the authenticated user. */
     getNetworkMembership(networkId: string): Promise<NetworkMembership | null>;
-    /** Get index + member context for the authenticated user (for auto-assign). */
+    /** Get network + member context for the authenticated user (for auto-assign). */
     getNetworkMemberContext(networkId: string): Promise<NetworkAssignmentContext | null>;
-    /** Get index + member context for the authenticated user without auto-assign gating. */
+    /** Get network + member context for the authenticated user without auto-assign gating. */
     getNetworkAssignmentContext?(networkId: string): Promise<NetworkAssignmentContext | null>;
-    /** Create a new index (user becomes owner). */
+    /** Create a new network (user becomes owner). */
     createNetwork(data: {
         title: string;
         prompt?: string | null;
@@ -146,12 +114,12 @@ export interface UserDatabase {
             } | null;
         };
     }>;
-    /** Update index settings (owner only). */
-    updateIndexSettings(networkId: string, data: UpdateIndexSettingsData): Promise<OwnedIndex>;
+    /** Update network settings (owner only). */
+    updateNetworkSettings(networkId: string, data: UpdateNetworkSettingsData): Promise<OwnedNetwork>;
     /** Soft-delete a network (owner only). */
     softDeleteNetwork(networkId: string): Promise<void>;
     /** Get public networks (joinPolicy 'anyone') that the user has not joined. */
-    getPublicIndexesNotJoined(): Promise<{
+    getPublicNetworksNotJoined(): Promise<{
         networks: Array<{
             id: string;
             title: string;
@@ -169,99 +137,78 @@ export interface UserDatabase {
         success: boolean;
         alreadyMember?: boolean;
     }>;
-    /**
-     * Summarize the authenticated user's own agent activity without counterparty rows.
-     * When `networkId` is present (a network agent's bound community), the
-     * network-bound aggregates (opportunity and negotiation counts) are narrowed
-     * to that community inside the query; own-signal and question aggregates are
-     * meta-network and stay global.
-     */
-    getAgentActivitySummary(input: {
-        sinceHours: number;
-        networkId?: string;
-    }): Promise<AgentActivitySummary>;
     /** Get opportunities where the authenticated user is an actor. */
     getOpportunitiesForUser(options?: OpportunityQueryOptions): Promise<Opportunity[]>;
     /** Get a specific opportunity (if user is an actor). */
     getOpportunity(id: string): Promise<Opportunity | null>;
-    /** Update an opportunity's status (if user is an actor). acceptedBy is derived from the auth context. */
+    /** Update an opportunity's status (if user is an actor). */
     updateOpportunityStatus(id: string, status: OpportunityStatus): Promise<Opportunity | null>;
-    /** Accept sibling opportunities between the authenticated user and another actor. */
-    acceptSiblingOpportunities(counterpartUserId: string, excludeOpportunityId: string): Promise<string[]>;
-    /** Get a HyDE document for the user's own source. */
-    getHydeDocument(sourceType: HydeSourceType, sourceId: string, strategy: string): Promise<HydeDocument | null>;
-    /** Get all HyDE documents for the user's own source. */
-    getHydeDocumentsForSource(sourceType: HydeSourceType, sourceId: string): Promise<HydeDocument[]>;
-    /** Save a HyDE document for the user's own source. */
-    saveHydeDocument(data: CreateHydeDocumentData): Promise<HydeDocument>;
-    /** Delete HyDE documents for the user's own source. */
-    deleteHydeDocumentsForSource(sourceType: HydeSourceType, sourceId: string): Promise<number>;
 }
 /**
  * Context-bound database for LLM/system operations that access cross-user resources.
- * Created with authUserId + indexScope[]; validates membership before access.
+ * Created with authUserId + networkScope[]; validates membership before access.
  *
  * **Network-scoped**: All cross-user operations are restricted to users/resources
- * within the bound indexScope[]. This prevents the LLM from accessing arbitrary users' data.
+ * within the bound networkScope[]. This prevents the LLM from accessing arbitrary users' data.
  *
- * Use via `createSystemDatabase(db, authUserId, indexScope)` factory function.
+ * Use via `createSystemDatabase(db, authUserId, networkScope)` factory function.
  */
 export interface SystemDatabase {
     /** The bound authenticated user ID */
     readonly authUserId: string;
-    /** The indexes the authenticated user has access to (determines cross-user scope) */
-    readonly indexScope: string[];
+    /** The networks the authenticated user has access to (determines cross-user scope) */
+    readonly networkScope: string[];
     /** Get a user's profile (requires shared network membership). */
     getProfile(userId: string): Promise<UserIdentity | null>;
     /** Get a user's basic record (requires shared network membership). */
     getUser(userId: string): Promise<UserRecord | null>;
-    /** Get all intents in an index (cross-user, requires membership). */
-    getIntentsInIndex(networkId: string, options?: {
+    /** Get all intents in a network (cross-user, requires membership). */
+    getIntentsInNetwork(networkId: string, options?: {
         limit?: number;
         offset?: number;
-    }): Promise<IndexedIntentDetails[]>;
-    /** Get a specific user's intents in an index (requires shared membership). */
-    getUserIntentsInIndex(userId: string, networkId: string): Promise<ActiveIntent[]>;
+    }): Promise<NetworkIntentDetails[]>;
+    /** Get a specific user's intents in a network (requires shared membership). */
+    getUserIntentsInNetwork(userId: string, networkId: string): Promise<ActiveIntent[]>;
     /**
-     * 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[]>;
     /** Get a single intent by ID (if in scope). */
     getIntent(intentId: string): Promise<IntentRecord | null>;
     /** Find similar intents across users within the network scope. */
     findSimilarIntentsInScope(embedding: number[], options?: SimilarIntentSearchOptions): Promise<SimilarIntent[]>;
-    /** Check if a user is a member of an index. */
+    /** Check if a user is a member of a network. */
     isNetworkMember(networkId: string, userId: string): Promise<boolean>;
-    /** Check if a user is an owner of an index. */
-    isIndexOwner(networkId: string, userId: string): Promise<boolean>;
-    /** Get all members of an index (requires membership). */
-    getNetworkMembers(networkId: string): Promise<IndexMemberDetails[]>;
+    /** Check if a user is an owner of a network. */
+    isNetworkOwner(networkId: string, userId: string): Promise<boolean>;
+    /** Get all members of a network (requires membership). */
+    getNetworkMembers(networkId: string): Promise<NetworkMemberDetails[]>;
     /** Get all members across all networks in scope (deduplicated). */
     getMembersFromScope(): Promise<{
         userId: Id<'users'>;
         name: string;
         avatar: string | null;
     }[]>;
-    /** Add a user to an index (requires ownership or 'anyone' policy). */
+    /** Add a user to a network (requires ownership or 'anyone' policy). */
     addMemberToNetwork(networkId: string, userId: string, role: 'owner' | 'member'): Promise<{
         success: boolean;
         alreadyMember?: boolean;
     }>;
-    /** Remove a user from an index (requires ownership). Cannot remove the owner. */
-    removeMemberFromIndex(networkId: string, userId: string): Promise<{
+    /** Remove a user from a network (requires ownership). Cannot remove the owner. */
+    removeMemberFromNetwork(networkId: string, userId: string): Promise<{
         success: boolean;
         wasOwner?: boolean;
         notMember?: boolean;
     }>;
-    /** Get index info by ID with core fields (requires scope). */
+    /** Get network info by ID with core fields (requires scope). */
     getNetwork(networkId: string): Promise<{
         id: string;
         title: string;
@@ -270,7 +217,7 @@ export interface SystemDatabase {
         metadata?: Record<string, unknown> | null;
         permissions?: Record<string, unknown> | null;
     } | null>;
-    /** Get index with permissions (requires scope). */
+    /** Get network with permissions (requires scope). */
     getNetworkWithPermissions(networkId: string): Promise<{
         id: string;
         title: string;
@@ -278,7 +225,7 @@ export interface SystemDatabase {
             joinPolicy: 'anyone' | 'invite_only';
         };
     } | null>;
-    /** Get member count for an index (requires scope). */
+    /** Get member count for a network (requires scope). */
     getNetworkMemberCount(networkId: string): Promise<number>;
     /** Create an opportunity (cross-user). */
     createOpportunity(data: CreateOpportunityData): Promise<Opportunity>;
@@ -289,13 +236,11 @@ export interface SystemDatabase {
     }>;
     /** Get an opportunity by ID (for system processing). */
     getOpportunity(id: string): Promise<Opportunity | null>;
-    /** Get opportunities for an index (requires membership). */
+    /** Get opportunities for a network (requires membership). */
     getOpportunitiesForNetwork(networkId: string, options?: OpportunityQueryOptions): Promise<Opportunity[]>;
     /** Update an opportunity's status (system-level). */
-    updateOpportunityStatus(id: string, status: OpportunityStatus, acceptedBy?: string): Promise<Opportunity | null>;
-    /** Stamp actor `actedAt` + update status atomically (system-level). */
-    stampOpportunityActorAction(id: string, actorUserId: string, status: OpportunityStatus, acceptedBy?: string): Promise<Opportunity | null>;
-    /** Check if opportunity exists between actors in an index. */
+    updateOpportunityStatus(id: string, status: OpportunityStatus): Promise<Opportunity | null>;
+    /** Check if opportunity exists between actors in a network. */
     opportunityExistsBetweenActors(actorIds: string[], networkId: string): Promise<boolean>;
     /** Find opportunities by actor IDs with optional include/exclude status filters. */
     findOpportunitiesByActors(actorIds: string[], options?: {
@@ -309,14 +254,4 @@ export interface SystemDatabase {
     expireOpportunitiesForRemovedMember(networkId: string, userId: string): Promise<number>;
     /** Expire stale opportunities (maintenance). */
     expireStaleOpportunities(): Promise<number>;
-    /** Get a HyDE document (cross-user for matching). */
-    getHydeDocument(sourceType: HydeSourceType, sourceId: string, strategy: string): Promise<HydeDocument | null>;
-    /** Get all HyDE documents for a source (cross-user). */
-    getHydeDocumentsForSource(sourceType: HydeSourceType, sourceId: string): Promise<HydeDocument[]>;
-    /** Save a HyDE document (system-level). */
-    saveHydeDocument(data: CreateHydeDocumentData): Promise<HydeDocument>;
-    /** Delete expired HyDE documents (maintenance). */
-    deleteExpiredHydeDocuments(): Promise<number>;
-    /** Get stale HyDE documents for refresh (maintenance). */
-    getStaleHydeDocuments(threshold: Date): Promise<HydeDocument[]>;
 }

package/dist/{shared/interfaces/database.port.js → platform/database/port.js}

@@ -14,16 +14,14 @@ export {};
 // They are used by graph factories to enforce interface segregation at compile time.
 //
 // Access control relationship to UserDatabase/SystemDatabase:
-// - EnrichmentGraphDatabase → maps to UserDatabase (user's own profile operations)
 // - IntentGraphDatabase → maps to UserDatabase (mutations) + SystemDatabase (reads)
-// - OpportunityGraphDatabase → maps to SystemDatabase (cross-user operations)
-// - NetworkGraphDatabase → maps to UserDatabase (own indexes)
+// - OpportunityDatabase → maps to SystemDatabase (cross-user operations)
+// - NetworkGraphDatabase → maps to UserDatabase (own networks)
 // - IntentNetworkGraphDatabase → maps to both (own intent ↔ shared network)
 // - NetworkMembershipGraphDatabase → maps to SystemDatabase (cross-user)
-// - HydeGraphDatabase → maps to both (own HyDE vs cross-user matching)
 //
 // Graphs continue to use these narrowed types because:
 // 1. They receive the raw database adapter with userId passed per method
-// 2. Access control is enforced at the tool/factory layer via createUserDatabase/createSystemDatabase
+// 2. Access control is enforced by the host via createUserDatabase/createSystemDatabase
 // 3. These types ensure graphs only depend on methods they actually use
 // ═══════════════════════════════════════════════════════════════════════════════

package/dist/platform/database.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The database port: a stable host contract, not a database implementation.
+ *
+ * The declarations moved into sibling modules — entities, the four query
+ * groups that compose `Database`, the access-scoped views, negotiation
+ * persistence, and the capability-narrowed aliases. Importers keep using this
+ * path; nothing about the types changed.
+ */
+import type { DatabaseIdentityQueries } from "./database/identity-queries.js";
+import type { DatabaseMemberQueries } from "./database/member-queries.js";
+import type { DatabaseNetworkQueries } from "./database/network-queries.js";
+import type { DatabaseOpportunityQueries } from "./database/opportunity-queries.js";
+/** The complete persistence contract a host may implement. */
+export interface Database extends DatabaseIdentityQueries, DatabaseNetworkQueries, DatabaseOpportunityQueries, DatabaseMemberQueries {
+}
+export type * from './database/entities.js';
+export type * from './database/identity-queries.js';
+export type * from './database/network-queries.js';
+export type * from './database/opportunity-queries.js';
+export type * from './database/member-queries.js';
+export type * from './database/port.js';
+export type * from './database/capabilities.js';
+export type * from './database/negotiation.js';

package/dist/{shared/interfaces/database.interface.js → platform/database.js}

@@ -1,5 +1,5 @@
 /**
- * The database port, re-exported as one surface.
+ * The database port: a stable host contract, not a database implementation.
  *
  * The declarations moved into sibling modules — entities, the four query
  * groups that compose `Database`, the access-scoped views, negotiation

package/dist/{shared/interfaces/cache.interface.d.ts → platform/discovery/cache.d.ts}

@@ -1,5 +1,5 @@
 /**
- * Cache interface for protocol layer (HyDE, opportunities).
+ * Cache interface for protocol layer (opportunities).
  * Implementations live in src/adapters (e.g. Redis).
  */
 export interface CacheOptions {
@@ -31,12 +31,10 @@ export interface Cache {
      */
     mget<T>(keys: string[]): Promise<(T | null)[]>;
     /**
-     * Delete all keys matching pattern (e.g. "hyde:intent:*").
+     * Delete all keys matching pattern (e.g. "opportunity:intent:*").
      * @returns Number of keys deleted
      */
     deleteByPattern(pattern: string): Promise<number>;
 }
-/** Cache interface for HyDE Graph operations. */
-export type HydeCache = Pick<Cache, 'get' | 'set' | 'delete' | 'exists'>;
 /** Cache interface for Opportunity Graph operations. */
 export type OpportunityCache = Pick<Cache, 'get' | 'set' | 'mget'>;

package/dist/{shared/interfaces/cache.interface.js → platform/discovery/cache.js}

@@ -1,5 +1,5 @@
 /**
- * Cache interface for protocol layer (HyDE, opportunities).
+ * Cache interface for protocol layer (opportunities).
  * Implementations live in src/adapters (e.g. Redis).
  */
 export {};

package/dist/platform/discovery/embedder.d.ts

@@ -0,0 +1,31 @@
+export interface EmbeddingGenerateOptions {
+    signal?: AbortSignal;
+}
+export interface EmbeddingGenerator {
+    generate(text: string | string[], dimensions?: number, options?: EmbeddingGenerateOptions): Promise<number[] | number[][]>;
+}
+export interface VectorSearchResult<T> {
+    item: T;
+    score: number;
+}
+export type VectorStoreOption<T> = {
+    limit?: number;
+    filter?: Record<string, unknown>;
+    candidates?: (T & {
+        embedding?: number[] | null;
+    })[];
+    minScore?: number;
+};
+export interface VectorStore {
+    /**
+     * Search for similar items in the vector store.
+     *
+     * @param queryVector - The embedding vector to search for
+     * @param collection - The logical name of the collection (e.g., 'profiles', 'intents')
+     * @param options - generic options including limit, filter, and candidates
+     */
+    search<T>(queryVector: number[], collection: string, options?: VectorStoreOption<T>): Promise<VectorSearchResult<T>[]>;
+}
+/** Embedding generation and vector search for protocol capabilities. */
+export interface Embedder extends EmbeddingGenerator, VectorStore {
+}

package/dist/platform/runtime/errors.d.ts

@@ -0,0 +1,6 @@
+/** A stable access error a host can map without importing protocol internals. */
+export declare class ChatContextAccessError extends Error {
+    readonly statusCode: number;
+    readonly code: "USER_NOT_FOUND" | "NETWORK_NOT_FOUND" | "NETWORK_MEMBERSHIP_REQUIRED";
+    constructor(message: string, statusCode: number, code: "USER_NOT_FOUND" | "NETWORK_NOT_FOUND" | "NETWORK_MEMBERSHIP_REQUIRED");
+}