@indexnetwork/protocol 14.3.2-rc.477.1 → 16.1.1-rc.478.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": "16.1.1-rc.478.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/opportunities/application/opportunity.card-presentation.d.ts

@@ -1,44 +0,0 @@
-/**
- * Minimal shape consumed by buildOpportunityPresentation for prose rendering.
- * Card data objects in the codebase carry additional frontend-only fields;
- * only these are surfaced to MCP agents.
- */
-export type OpportunityCardLike = Record<string, unknown> & {
-    opportunityId: string;
-    userId?: string | undefined;
-    name?: string | undefined;
-    mainText?: string | undefined;
-    digestSummary?: string | undefined;
-    status?: string | undefined;
-    feedCategory?: string | undefined;
-    profileUrl?: string | undefined;
-    /** Universal link that opens this opportunity's card (`/o/<id>`). */
-    appUrl?: string | undefined;
-    /** Deep-link to the A2A negotiation trace that produced this opportunity. */
-    negotiationUrl?: string | undefined;
-    score?: number | undefined;
-    /** Digest-mode cooldown re-show — the user has seen this card before. */
-    redelivery?: boolean | undefined;
-};
-/**
- * Format opportunity cards into the "opportunities" portion of a tool response.
- *
- * Web chat (`isMcp=false`): emits ```opportunity``` code fences with an
- * "include EXACTLY as-is" directive so the frontend card renderer can parse
- * and render interactive cards.
- *
- * MCP (`isMcp=true`): emits prose (name, reason, status, appUrl and profileUrl
- * when present, feedCategory when present) and includes `opportunityId` for
- * every card so the agent can act via the tools. The trailing instruction
- * reminds the agent to synthesize in natural language, to surface the `appUrl`
- * verbatim as the one link that opens the card, and to fabricate no other URL.
- * MCP clients have no card renderer, so code fences would surface as raw JSON
- * to end users.
- */
-export declare function buildOpportunityPresentation(inputCards: OpportunityCardLike[], opts: {
-    isMcp: boolean;
-    leadIn: string;
-    label?: 'opportunity' | 'opportunities';
-    /** Include hidden digest metadata markers so scheduled brief tooling can confirm delivery. */
-    includeDigestMarkers?: boolean;
-}): string;

package/dist/opportunities/application/opportunity.card-presentation.js

@@ -1,93 +0,0 @@
-import { stripUnsupportedOpportunityClaims } from '../../shared/utils/claim-safety.js';
-import { stripUuids } from '../domain/opportunity.presentation.js';
-const CODE_FENCE = String.fromCharCode(96, 96, 96);
-function sanitizeJsonForCodeFence(json) {
-    return json.replace(/`/g, '\\u0060');
-}
-function sanitizeOpportunityCardProse(card) {
-    const sanitized = { ...card };
-    for (const key of ['mainText', 'digestSummary', 'headline', 'cta', 'mutualIntentsLabel']) {
-        const value = card[key];
-        if (typeof value === 'string') {
-            sanitized[key] = stripUnsupportedOpportunityClaims(stripUuids(value)) || 'A suggested connection.';
-        }
-    }
-    const narratorChip = card.narratorChip;
-    if (narratorChip && typeof narratorChip === 'object' && !Array.isArray(narratorChip)) {
-        const narrator = narratorChip;
-        if (typeof narrator.text === 'string') {
-            sanitized.narratorChip = {
-                ...narrator,
-                text: stripUnsupportedOpportunityClaims(stripUuids(narrator.text)) || 'A potential connection worth exploring.',
-            };
-        }
-    }
-    return sanitized;
-}
-/**
- * Format opportunity cards into the "opportunities" portion of a tool response.
- *
- * Web chat (`isMcp=false`): emits ```opportunity``` code fences with an
- * "include EXACTLY as-is" directive so the frontend card renderer can parse
- * and render interactive cards.
- *
- * MCP (`isMcp=true`): emits prose (name, reason, status, appUrl and profileUrl
- * when present, feedCategory when present) and includes `opportunityId` for
- * every card so the agent can act via the tools. The trailing instruction
- * reminds the agent to synthesize in natural language, to surface the `appUrl`
- * verbatim as the one link that opens the card, and to fabricate no other URL.
- * MCP clients have no card renderer, so code fences would surface as raw JSON
- * to end users.
- */
-export function buildOpportunityPresentation(inputCards, opts) {
-    const cards = inputCards.map(sanitizeOpportunityCardProse);
-    if (cards.length === 0)
-        return opts.leadIn;
-    if (opts.isMcp) {
-        const prose = cards
-            .map((card, i) => {
-            const lines = [`${i + 1}. ${card.name ?? "Unknown"}`];
-            if (opts.includeDigestMarkers) {
-                const markerId = String(card.opportunityId).replace(/[\s>]/g, "");
-                if (markerId)
-                    lines.push(`   <!-- digest-opportunity:id=${markerId} -->`);
-            }
-            if (opts.includeDigestMarkers && card.digestSummary) {
-                lines.push(`   ${card.digestSummary}`);
-            }
-            else if (card.mainText) {
-                lines.push(`   ${card.mainText}`);
-            }
-            if (card.status)
-                lines.push(`   status: ${card.status}`);
-            if (card.appUrl)
-                lines.push(`   appUrl: ${card.appUrl}`);
-            if (card.profileUrl)
-                lines.push(`   profileUrl: ${card.profileUrl}`);
-            if (opts.includeDigestMarkers && card.negotiationUrl)
-                lines.push(`   negotiationUrl: ${card.negotiationUrl}`);
-            if (card.feedCategory)
-                lines.push(`   feedCategory: ${card.feedCategory}`);
-            if (opts.includeDigestMarkers && card.score != null)
-                lines.push(`   confidence: ${Math.round(card.score * 100)}`);
-            if (opts.includeDigestMarkers && card.redelivery)
-                lines.push(`   redelivery: true`);
-            lines.push(`   opportunityId: ${card.opportunityId}`);
-            return lines.join("\n");
-        })
-            .join("\n\n");
-        const idInstructions = `Use opportunityId values only when calling update_opportunity (send/accept/reject) or confirm_opportunity_delivery.`;
-        return (`${opts.leadIn}\n\n${prose}\n\n` +
-            `Summarize these for the user in natural prose — mention first names and a brief match reason per connection. ` +
-            `For each card that has a profileUrl, link the person's name to it. Some cards may have no URL — render those as plain text and never fabricate URLs for them. ` +
-            `For each card that has an appUrl, show that link so the user can open the opportunity: it opens the card in the Index app when installed, and an Index web page otherwise. Show only an appUrl a tool returned — never assemble one from an opportunityId. ` +
-            `No link accepts on the user's behalf: accepting happens in the Index app (or via update_opportunity) — never invent an accept URL. ` +
-            `Do NOT print raw JSON, field labels, or opportunityIds. ` +
-            `${idInstructions}`);
-    }
-    const label = opts.label ?? (cards.length === 1 ? "opportunity" : "opportunities");
-    const blocks = cards
-        .map((card) => CODE_FENCE + "opportunity\n" + sanitizeJsonForCodeFence(JSON.stringify(card)) + "\n" + CODE_FENCE)
-        .join("\n\n");
-    return (`${opts.leadIn} IMPORTANT: Include the following ${CODE_FENCE}${label} code blocks EXACTLY as-is in your response (they render as interactive cards):\n\n${blocks}`);
-}