@indexnetwork/protocol 14.3.2-rc.477.1 → 17.0.0-rc.479.1

package/dist/shared/interfaces/database.port.d.ts

@@ -0,0 +1,322 @@
+/**
+ * The database port itself, plus the two access-scoped views over it.
+ *
+ * `Database` is the union of the four query groups; splitting it into composed
+ * 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 {
+}
+/**
+ * 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.
+ * 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;
+    /** Get the authenticated user's profile. */
+    getProfile(): Promise<UserIdentity | null>;
+    /** Get the authenticated user's profile with row ID. */
+    getProfileByUserId(): Promise<(UserIdentity & {
+        id: string;
+    }) | null>;
+    /** Save/update the authenticated user's profile. */
+    saveProfile(profile: UserIdentity): Promise<void>;
+    /** Delete the authenticated user's profile. */
+    deleteProfile(): Promise<void>;
+    /** Get the authenticated user's basic record (name, email, socials). */
+    getUser(): Promise<UserRecord | null>;
+    /** Update the authenticated user's account fields. */
+    updateUser(data: {
+        name?: string;
+        intro?: string;
+        location?: string;
+        onboarding?: OnboardingState;
+    }): Promise<UserRecord | null>;
+    getUserSocials(): Promise<UserSocial[]>;
+    setUserSocials(socials: {
+        label: string;
+        value: string;
+    }[]): Promise<void>;
+    /** Get ALL active intents for the authenticated user (not index-filtered). */
+    getActiveIntents(): Promise<ActiveIntent[]>;
+    /**
+     * Case-insensitive substring search over the authenticated user's own
+     * active intents. Matches against `payload` and `summary`. Most recent first.
+     */
+    searchOwnIntents(q: string, limit: number): Promise<Array<{
+        id: string;
+        payload: string;
+        summary: string | null;
+        createdAt: Date;
+    }>>;
+    /** Get a single intent by ID (ownership enforced). */
+    getIntent(intentId: string): Promise<IntentRecord | null>;
+    /** Create a new intent for the authenticated user. */
+    createIntent(data: Omit<CreateIntentData, 'userId'>): Promise<CreatedIntent>;
+    /** Update an intent owned by the authenticated user. */
+    updateIntent(intentId: string, data: UpdateIntentData): Promise<CreatedIntent | null>;
+    /** Archive an intent owned by the authenticated user. */
+    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). */
+    getIntentForIndexing(intentId: string): Promise<{
+        id: string;
+        payload: string;
+        userId: string;
+        sourceType: string | null;
+        sourceId: string | null;
+    } | null>;
+    /** Associate an intent with networks. */
+    associateIntentWithNetworks(intentId: string, networkIds: string[]): Promise<void>;
+    /** Assign an intent to an index. */
+    assignIntentToNetwork(intentId: string, networkId: string, relevancyScore?: number, assignmentMetadata?: NetworkAssignmentMetadata): Promise<void>;
+    /** Unassign an intent from an index. */
+    unassignIntentFromIndex(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>;
+    /** 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[]>;
+    /** 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). */
+    getNetworkMemberContext(networkId: string): Promise<NetworkAssignmentContext | null>;
+    /** Get index + member context for the authenticated user without auto-assign gating. */
+    getNetworkAssignmentContext?(networkId: string): Promise<NetworkAssignmentContext | null>;
+    /** Create a new index (user becomes owner). */
+    createNetwork(data: {
+        title: string;
+        prompt?: string | null;
+        imageUrl?: string | null;
+        joinPolicy?: 'anyone' | 'invite_only';
+    }): Promise<{
+        id: string;
+        title: string;
+        prompt: string | null;
+        imageUrl: string | null;
+        permissions: {
+            joinPolicy: 'anyone' | 'invite_only';
+            invitationLink: {
+                code: string;
+            } | null;
+        };
+    }>;
+    /** Update index settings (owner only). */
+    updateIndexSettings(networkId: string, data: UpdateIndexSettingsData): Promise<OwnedIndex>;
+    /** Soft-delete a network (owner only). */
+    softDeleteNetwork(networkId: string): Promise<void>;
+    /** Get public networks (joinPolicy 'anyone') that the user has not joined. */
+    getPublicIndexesNotJoined(): Promise<{
+        networks: Array<{
+            id: string;
+            title: string;
+            prompt: string | null;
+            memberCount: number;
+            owner: {
+                id: string;
+                name: string;
+                avatar: string | null;
+            } | null;
+        }>;
+    }>;
+    /** Join a public network (validates joinPolicy === 'anyone'). */
+    joinPublicNetwork(networkId: string): Promise<{
+        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. */
+    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.
+ *
+ * **Network-scoped**: All cross-user operations are restricted to users/resources
+ * within the bound indexScope[]. This prevents the LLM from accessing arbitrary users' data.
+ *
+ * Use via `createSystemDatabase(db, authUserId, indexScope)` 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[];
+    /** 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?: {
+        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[]>;
+    /**
+     * Get the caller's own active intents across a set of indexes.
+     * 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).
+     *
+     * @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.
+     */
+    getActiveIntentsAcrossIndexes(userId: string, indexIds: 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. */
+    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[]>;
+    /** 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). */
+    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<{
+        success: boolean;
+        wasOwner?: boolean;
+        notMember?: boolean;
+    }>;
+    /** Get index info by ID with core fields (requires scope). */
+    getNetwork(networkId: string): Promise<{
+        id: string;
+        title: string;
+        prompt?: string | null;
+        type?: string;
+        metadata?: Record<string, unknown> | null;
+        permissions?: Record<string, unknown> | null;
+    } | null>;
+    /** Get index with permissions (requires scope). */
+    getNetworkWithPermissions(networkId: string): Promise<{
+        id: string;
+        title: string;
+        permissions: {
+            joinPolicy: 'anyone' | 'invite_only';
+        };
+    } | null>;
+    /** Get member count for an index (requires scope). */
+    getNetworkMemberCount(networkId: string): Promise<number>;
+    /** Create an opportunity (cross-user). */
+    createOpportunity(data: CreateOpportunityData): Promise<Opportunity>;
+    /** Create opportunity and expire overlapping ones atomically. */
+    createOpportunityAndExpireIds(data: CreateOpportunityData, expireIds: string[]): Promise<{
+        created: Opportunity;
+        expired: Opportunity[];
+    }>;
+    /** Get an opportunity by ID (for system processing). */
+    getOpportunity(id: string): Promise<Opportunity | null>;
+    /** Get opportunities for an index (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. */
+    opportunityExistsBetweenActors(actorIds: string[], networkId: string): Promise<boolean>;
+    /** Find opportunities by actor IDs with optional include/exclude status filters. */
+    findOpportunitiesByActors(actorIds: string[], options?: {
+        includeIntroducers?: boolean;
+        statuses?: OpportunityStatus[];
+        excludeStatuses?: OpportunityStatus[];
+    }): Promise<Opportunity[]>;
+    /** Expire opportunities referencing an intent. */
+    expireOpportunitiesByIntent(intentId: string): Promise<number>;
+    /** Expire opportunities for a removed member. */
+    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

@@ -0,0 +1,29 @@
+/**
+ * The database port itself, plus the two access-scoped views over it.
+ *
+ * `Database` is the union of the four query groups; splitting it into composed
+ * interfaces keeps each group readable without changing the type one bit —
+ * every `Pick<Database, ...>` alias still resolves exactly as before.
+ */
+export {};
+// ═══════════════════════════════════════════════════════════════════════════════
+// NARROWED DATABASE INTERFACES (Interface Segregation)
+// ═══════════════════════════════════════════════════════════════════════════════
+//
+// These narrowed types are Pick types from the raw Database interface.
+// 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)
+// - 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
+// 3. These types ensure graphs only depend on methods they actually use
+// ═══════════════════════════════════════════════════════════════════════════════

package/dist/shared/schemas/discovery-question.schema.d.ts

@@ -131,17 +131,7 @@ export declare const DiscoveryNegotiationSchema: z.ZodObject<{
     }>;
     seedAssessmentScore: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    counterpartyId: string;
-    counterpartyHint: string;
     indexContext: string;
-    turns: {
-        reasoning: string;
-        action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline" | "ask_user";
-        suggestedRoles: {
-            ownUser: "agent" | "patient" | "peer";
-            otherUser: "agent" | "patient" | "peer";
-        };
-    }[];
     outcome: {
         reasoning: string;
         hasOpportunity: boolean;
@@ -151,11 +141,8 @@ export declare const DiscoveryNegotiationSchema: z.ZodObject<{
             role: "agent" | "patient" | "peer";
         }[] | undefined;
     };
-    seedAssessmentScore?: number | undefined;
-}, {
-    counterpartyId: string;
     counterpartyHint: string;
-    indexContext: string;
+    counterpartyId: string;
     turns: {
         reasoning: string;
         action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline" | "ask_user";
@@ -164,6 +151,9 @@ export declare const DiscoveryNegotiationSchema: z.ZodObject<{
             otherUser: "agent" | "patient" | "peer";
         };
     }[];
+    seedAssessmentScore?: number | undefined;
+}, {
+    indexContext: string;
     outcome: {
         reasoning: string;
         hasOpportunity: boolean;
@@ -173,6 +163,16 @@ export declare const DiscoveryNegotiationSchema: z.ZodObject<{
             role: "agent" | "patient" | "peer";
         }[] | undefined;
     };
+    counterpartyHint: string;
+    counterpartyId: string;
+    turns: {
+        reasoning: string;
+        action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline" | "ask_user";
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    }[];
     seedAssessmentScore?: number | undefined;
 }>;
 export type DiscoveryNegotiation = z.infer<typeof DiscoveryNegotiationSchema>;

package/dist/shared/schemas/negotiation-digest.schema.d.ts

@@ -39,8 +39,8 @@ export declare const DiscoveryNegotiationDigestSchema: z.ZodObject<{
         ownUser: "agent" | "patient" | "peer";
         otherUser: "agent" | "patient" | "peer";
     } | null;
-    counterpartyHint: string;
     indexContext: string;
+    counterpartyHint: string;
     outcomeRole: "opportunity" | "no-opportunity";
     outcomeReason: "timeout" | "stalled" | "rejected" | "turn_cap" | "screened_out" | null;
     keyTake: string;
@@ -51,8 +51,8 @@ export declare const DiscoveryNegotiationDigestSchema: z.ZodObject<{
     } | null;
     outcomeRole: "opportunity" | "no-opportunity";
     outcomeReason: "timeout" | "stalled" | "rejected" | "turn_cap" | "screened_out" | null;
-    counterpartyHint?: unknown;
     indexContext?: unknown;
+    counterpartyHint?: unknown;
     keyTake?: unknown;
 }>;
 export type DiscoveryNegotiationDigest = z.infer<typeof DiscoveryNegotiationDigestSchema>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indexnetwork/protocol",
-  "version": "14.3.2-rc.477.1",
+  "version": "17.0.0-rc.479.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -28,20 +28,7 @@
     "architecture:capabilities": "bun scripts/architecture/capability-boundaries.ts",
     "architecture:check": "bun run architecture:host-isolation && bun run architecture:capabilities && bun run test:architecture",
     "prepublishOnly": "bun run build",
-    "prepack": "bun run build:package",
-    "eval:matching": "bun --env-file=../../.env.test ./eval/matching/matching.eval.ts",
-    "eval:hyde": "bun --env-file=../../.env.test ./eval/hyde/hyde.eval.ts",
-    "eval:premise": "bun --env-file=../../.env.test ./eval/premise/premise.eval.ts",
-    "eval:profile": "bun --env-file=../../.env.test ./eval/profile/profile.eval.ts",
-    "eval:opportunity": "bun --env-file=../../.env.test ./eval/opportunity/opportunity.eval.ts",
-    "eval:clarification": "bun --env-file=../../.env.test ./eval/clarification/clarification.eval.ts",
-    "eval:intake": "bun --env-file=../../.env.test ./eval/intake/intake.eval.ts",
-    "eval:discovery-retrieval": "bun --env-file=../../.env.test ./eval/discovery-retrieval/discovery-retrieval.eval.ts",
-    "eval:canary": "bun --env-file=../../.env.test ./eval/canary/canary.eval.ts",
-    "eval:stance": "bun --env-file=../../.env.test ./eval/stance/stance.eval.ts",
-    "eval:view": "bun ./eval/viewer/viewer.eval.ts",
-    "eval:web": "bun --env-file=../../.env.test ./eval/ops/ops.serve.ts",
-    "eval:verify": "bun ./eval/verify.ts"
+    "prepack": "bun run build:package"
   },
   "dependencies": {
     "@langchain/core": "1.1.48",

package/dist/contacts/application/contact.inviter.d.ts

@@ -1,49 +0,0 @@
-/**
- * contacts/application — generateInviteMessage canonical implementation.
- *
- * Invite Generator Agent: generates contextual, editable invite messages for
- * ghost users. Produces warm, concise messages (~2-3 sentences) referencing
- * why two users were matched, with optional referrer mention.
- *
- * IND-549: moved from contact/contact.inviter.ts into the canonical
- * contacts/application layer.
- */
-import { z } from "zod";
-declare const InviteInputSchema: z.ZodObject<{
-    recipientName: z.ZodString;
-    senderName: z.ZodString;
-    opportunityInterpretation: z.ZodString;
-    senderIntents: z.ZodArray<z.ZodString, "many">;
-    recipientIntents: z.ZodArray<z.ZodString, "many">;
-    referrerName: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    recipientName: string;
-    senderName: string;
-    opportunityInterpretation: string;
-    senderIntents: string[];
-    recipientIntents: string[];
-    referrerName?: string | undefined;
-}, {
-    recipientName: string;
-    senderName: string;
-    opportunityInterpretation: string;
-    senderIntents: string[];
-    recipientIntents: string[];
-    referrerName?: string | undefined;
-}>;
-declare const InviteOutputSchema: z.ZodObject<{
-    message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    message: string;
-}, {
-    message: string;
-}>;
-export type InviteInput = z.infer<typeof InviteInputSchema>;
-export type InviteOutput = z.infer<typeof InviteOutputSchema>;
-/**
- * Generates a contextual invite message for a ghost user.
- * @param input - Context about sender, recipient, and opportunity
- * @returns Generated invite message text
- */
-export declare function generateInviteMessage(input: InviteInput): Promise<InviteOutput>;
-export {};

package/dist/contacts/application/contact.inviter.js

@@ -1,64 +0,0 @@
-/**
- * contacts/application — generateInviteMessage canonical implementation.
- *
- * Invite Generator Agent: generates contextual, editable invite messages for
- * ghost users. Produces warm, concise messages (~2-3 sentences) referencing
- * why two users were matched, with optional referrer mention.
- *
- * IND-549: moved from contact/contact.inviter.ts into the canonical
- * contacts/application layer.
- */
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { z } from "zod";
-import { createStructuredModel } from "../../shared/agent/model.config.js";
-import { stripUnsupportedOpportunityClaims } from "../../shared/utils/claim-safety.js";
-const InviteInputSchema = z.object({
-    recipientName: z.string(),
-    senderName: z.string(),
-    opportunityInterpretation: z.string(),
-    senderIntents: z.array(z.string()),
-    recipientIntents: z.array(z.string()),
-    referrerName: z.string().optional(),
-});
-const InviteOutputSchema = z.object({
-    message: z.string().describe("The invite message text, ready to edit and send"),
-});
-const SYSTEM_PROMPT = `You generate brief, casual invite messages for a discovery platform called Index.
-
-The sender wants to reach out to someone they were matched with. Write a short, human message (2-3 sentences max) that:
-- Sounds like a real person texting, not a LinkedIn outreach or AI email
-- References one concrete, specific detail from the opportunity context — something actual, like a specific project, technology, or goal they share. Not "we have similar interests" or "I noticed we're both in this space" — name the actual thing.
-- If a referrer is provided, casually drops that they were introduced
-- Ends naturally — no formal CTAs, no "Would you be open to..." closings
-
-Tone: casual, direct, human. Think how you'd actually message someone you just got introduced to.
-Do NOT use a generic opener like "Hi [Name], I'm [Sender]." Just get to the point.
-Do NOT summarize the person's background. Pick one real, specific overlap from the context and mention it.
-Do NOT include a subject line. This is a chat message.
-Do NOT use placeholder brackets like [Name]. Use the actual names provided.
-Network assignment, network title/type, and event/network metadata are retrieval context only. They are NEVER proof that either person attended or will attend, belongs to a group, resides in a place, knows anyone from the network, or shared a session, time, place, or location. Do not make co-attendance, membership, residence, shared-session, or same-place/same-time claims from network co-membership.`;
-/**
- * Generates a contextual invite message for a ghost user.
- * @param input - Context about sender, recipient, and opportunity
- * @returns Generated invite message text
- */
-export async function generateInviteMessage(input) {
-    const validated = InviteInputSchema.parse(input);
-    const structuredModel = createStructuredModel("inviteGenerator", InviteOutputSchema);
-    const safeInterpretation = stripUnsupportedOpportunityClaims(validated.opportunityInterpretation) ||
-        "Their current goals may be relevant to each other.";
-    const userPrompt = `Generate an invite message with this context:
-- Sender: ${validated.senderName}
-- Recipient: ${validated.recipientName}
-- Why they matched: ${safeInterpretation}
-- Sender's interests: ${validated.senderIntents.join(', ') || 'Not specified'}
-- Recipient's interests: ${validated.recipientIntents.join(', ') || 'Not specified'}${validated.referrerName ? `\n- Referred by: ${validated.referrerName}` : ''}`;
-    const result = InviteOutputSchema.parse(await structuredModel.invoke([
-        new SystemMessage(SYSTEM_PROMPT),
-        new HumanMessage(userPrompt),
-    ]));
-    const safeMessage = stripUnsupportedOpportunityClaims(result.message);
-    return {
-        message: safeMessage || "Thought it could be useful for us to compare notes on what we're working on.",
-    };
-}

package/dist/integrations/application/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * integrations/application — foreground adapters for the integrations capability.
- *
- * ## Exports
- *
- * ### Tool factory
- * - `createIntegrationTools` — creates integration MCP tools (import_gmail_contacts).
- *   The tool is gated behind deps.contactsEnabled; when disabled, returns [].
- *
- * IND-549: canonical application layer for the integrations capability.
- * Legacy path:
- *   - integration/integration.tools.ts → thin compatibility shim pointing here
- */
-export { createIntegrationTools } from "./integration.tools.js";

package/dist/integrations/application/index.js

@@ -1,14 +0,0 @@
-/**
- * integrations/application — foreground adapters for the integrations capability.
- *
- * ## Exports
- *
- * ### Tool factory
- * - `createIntegrationTools` — creates integration MCP tools (import_gmail_contacts).
- *   The tool is gated behind deps.contactsEnabled; when disabled, returns [].
- *
- * IND-549: canonical application layer for the integrations capability.
- * Legacy path:
- *   - integration/integration.tools.ts → thin compatibility shim pointing here
- */
-export { createIntegrationTools } from "./integration.tools.js";

package/dist/integrations/application/integration.tools.d.ts

@@ -1,27 +0,0 @@
-/**
- * integrations/application — createIntegrationTools canonical implementation.
- *
- * Creates integration tools for the chat agent. Exposes `import_gmail_contacts`
- * which authenticates via the integration adapter, fetches all Gmail contacts
- * (paginated), and imports them as ghost users into the network.
- *
- * Feature gating: import_gmail_contacts creates ghost users, so it is gated
- * behind the CONTACTS_ENABLED flag (deps.contactsEnabled). When disabled,
- * the tool is not registered at all (defineTool registers as a side effect).
- *
- * IND-549: moved from integration/integration.tools.ts into the canonical
- * integrations/application layer.
- */
-import type { DefineTool } from '../../shared/agent/tool.helpers.js';
-import type { IntegrationToolDeps } from '../ports/index.js';
-/**
- * Creates integration tools for the chat agent.
- *
- * Exposes `import_gmail_contacts` which authenticates via the integration adapter,
- * fetches all Gmail contacts (paginated), and imports them as ghost users into the network.
- *
- * @param defineTool - Tool definition helper injected by the tool registry.
- * @param deps - Shared tool dependencies including the integration adapter.
- * @returns An array of tool definitions to register with the chat agent.
- */
-export declare function createIntegrationTools(defineTool: DefineTool, deps: IntegrationToolDeps): any[];