@indexnetwork/protocol 14.3.2-rc.477.1 → 16.1.1-rc.478.1

package/dist/networks/application/network.graph.js

@@ -3,301 +3,272 @@ import { protocolLogger } from "../../shared/observability/protocol.logger.js";
 import { timed } from "../../shared/observability/performance.js";
 import { NetworkGraphState } from "../domain/index.js";
 const logger = protocolLogger("NetworkGraphFactory");
-/**
- * Factory class to build and compile the Network (community) lifecycle graph.
- *
- * Handles create, read, update, and delete operations for networks.
- * Membership and intent–network assignment operations are delegated to
- * NetworkMembershipGraphFactory and IntentNetworkGraphFactory respectively.
- *
- * ## Ownership policy
- *
- * - `create`: the calling user becomes the sole owner.  The owner–membership
- *   write is performed atomically after the network row is created; on failure
- *   the network is soft-deleted (rollback).  Rollback failures are logged but
- *   do NOT mutate the error response — the caller always receives the first
- *   meaningful failure, not a noisy rollback message.
- * - `update`: owner-only.  Any member field may be updated in one call.
- * - `delete`: owner-only; the network must have no other members.
- *
- * ## Scope semantics (read mode)
- *
- * When `networkId` is set and `showAll` is false, only the focused network and
- * the user's personal network (contacts) are returned.  This is the strict-scope
- * invariant for network-bound agents.  Set `showAll: true` to bypass.
- *
- * Flow:
- * START → routerNode → {createNode | readNode | updateNode | deleteNode} → END
- *
- * IND-546: canonical home — previously network/network.graph.ts.
- */
 export class NetworkGraphFactory {
     constructor(database) {
-        this.database = database;
+        this.deps = { database };
     }
     createGraph() {
-        // --- NODE DEFINITIONS ---
-        /**
-         * Read Node: List networks the user belongs to and owns.
-         */
-        const readNode = async (state) => {
-            return timed("NetworkGraph.read", async () => {
-                logger.verbose("Read networks", { userId: state.userId, networkId: state.networkId, showAll: state.showAll });
-                // Shared projections for both the scoped and unscoped read paths.
-                const projectMembership = (m) => ({
-                    networkId: m.networkId,
-                    title: m.networkTitle,
-                    prompt: m.indexPrompt,
-                    autoAssign: m.autoAssign,
-                    isPersonal: m.isPersonal,
-                    joinedAt: m.joinedAt,
-                });
-                const projectOwned = (o) => ({
-                    networkId: o.id,
-                    title: o.title,
-                    prompt: o.prompt,
-                    memberCount: o.memberCount,
-                    intentCount: o.intentCount,
-                    joinPolicy: o.permissions.joinPolicy,
-                });
-                try {
-                    const [allMemberships, ownedIndexes, publicIndexesResult] = await Promise.all([
-                        this.database.getNetworkMemberships(state.userId),
-                        this.database.getOwnedIndexes(state.userId),
-                        this.database.getPublicIndexesNotJoined(state.userId),
-                    ]);
-                    // If network-scoped and not showAll, return just that network plus the
-                    // user's personal network (their contacts).  The personal network is part
-                    // of every allowed-network reach calculation for network-bound agents,
-                    // and a user in a community-scoped chat still owns their contact list —
-                    // so surfacing it here keeps contact tools discoverable.  Other community
-                    // memberships are still hidden, and `publicNetworks` is omitted.
-                    const scopeToCurrentNetwork = state.networkId && !state.showAll;
-                    if (scopeToCurrentNetwork) {
-                        const networkId = state.networkId;
-                        const isMember = await this.database.isNetworkMember(networkId, state.userId);
-                        if (!isMember) {
-                            return {
-                                readResult: {
-                                    memberOf: [],
-                                    owns: [],
-                                    stats: { memberOfCount: 0, ownsCount: 0, scopeNote: "Network not found or you are not a member." },
-                                },
-                            };
-                        }
-                        const scopedMembership = allMemberships.find((m) => m.networkId === networkId);
-                        const personalMembership = scopedMembership?.isPersonal
-                            ? undefined
-                            : allMemberships.find((m) => m.isPersonal);
-                        const scopedOwned = ownedIndexes.find((o) => o.id === networkId);
-                        const personalOwned = personalMembership
-                            ? ownedIndexes.find((o) => o.id === personalMembership.networkId)
-                            : undefined;
-                        const memberOf = [
-                            ...(scopedMembership ? [projectMembership(scopedMembership)] : []),
-                            ...(personalMembership ? [projectMembership(personalMembership)] : []),
-                        ];
-                        const owns = [
-                            ...(scopedOwned ? [projectOwned(scopedOwned)] : []),
-                            ...(personalOwned ? [projectOwned(personalOwned)] : []),
-                        ];
-                        return {
-                            readResult: {
-                                memberOf,
-                                owns,
-                                stats: {
-                                    memberOfCount: memberOf.length,
-                                    ownsCount: owns.length,
-                                    scopeNote: "Showing current network and your personal network. Use showAll: true for all networks.",
-                                },
-                            },
-                        };
-                    }
-                    // Include public networks available to join
-                    const publicNetworks = publicIndexesResult.networks.map((idx) => ({
-                        networkId: idx.id,
-                        title: idx.title,
-                        prompt: idx.prompt,
-                        memberCount: idx.memberCount,
-                        owner: idx.owner,
-                    }));
+        const deps = this.deps;
+        // --- GRAPH ASSEMBLY ---
+        const workflow = new StateGraph(NetworkGraphState)
+            .addNode("read", (state) => readNode(state, deps))
+            .addNode("create", (state) => createNode(state, deps))
+            .addNode("update", (state) => updateNode(state, deps))
+            .addNode("delete_idx", (state) => deleteNode(state, deps))
+            .addConditionalEdges(START, routeByMode, {
+            read: "read",
+            create: "create",
+            update: "update",
+            delete_idx: "delete_idx",
+        })
+            .addEdge("read", END)
+            .addEdge("create", END)
+            .addEdge("update", END)
+            .addEdge("delete_idx", END);
+        return workflow.compile();
+    }
+}
+/**
+ * Read Node: List networks the user belongs to and owns.
+ */
+export async function readNode(state, deps) {
+    return timed("NetworkGraph.read", async () => {
+        logger.verbose("Read networks", { userId: state.userId, networkId: state.networkId, showAll: state.showAll });
+        // Shared projections for both the scoped and unscoped read paths.
+        const projectMembership = (m) => ({
+            networkId: m.networkId,
+            title: m.networkTitle,
+            prompt: m.indexPrompt,
+            autoAssign: m.autoAssign,
+            isPersonal: m.isPersonal,
+            joinedAt: m.joinedAt,
+        });
+        const projectOwned = (o) => ({
+            networkId: o.id,
+            title: o.title,
+            prompt: o.prompt,
+            memberCount: o.memberCount,
+            intentCount: o.intentCount,
+            joinPolicy: o.permissions.joinPolicy,
+        });
+        try {
+            const [allMemberships, ownedIndexes, publicIndexesResult] = await Promise.all([
+                deps.database.getNetworkMemberships(state.userId),
+                deps.database.getOwnedIndexes(state.userId),
+                deps.database.getPublicIndexesNotJoined(state.userId),
+            ]);
+            // If network-scoped and not showAll, return just that network plus the
+            // user's personal network (their contacts).  The personal network is part
+            // of every allowed-network reach calculation for network-bound agents,
+            // and a user in a community-scoped chat still owns their contact list —
+            // so surfacing it here keeps contact tools discoverable.  Other community
+            // memberships are still hidden, and `publicNetworks` is omitted.
+            const scopeToCurrentNetwork = state.networkId && !state.showAll;
+            if (scopeToCurrentNetwork) {
+                const networkId = state.networkId;
+                const isMember = await deps.database.isNetworkMember(networkId, state.userId);
+                if (!isMember) {
                     return {
                         readResult: {
-                            memberOf: allMemberships.map(projectMembership),
-                            owns: ownedIndexes.map(projectOwned),
-                            publicNetworks,
-                            stats: { memberOfCount: allMemberships.length, ownsCount: ownedIndexes.length, publicNetworksCount: publicNetworks.length },
+                            memberOf: [],
+                            owns: [],
+                            stats: { memberOfCount: 0, ownsCount: 0, scopeNote: "Network not found or you are not a member." },
                         },
                     };
                 }
-                catch (err) {
-                    logger.error("Read networks failed", { error: err });
-                    return { error: "Failed to fetch network information." };
-                }
-            });
-        };
-        /**
-         * Create Node: Create a new network and add user as owner.
-         *
-         * Atomicity contract:
-         * 1. Create the network row.
-         * 2. Add the calling user as owner.
-         * 3. On step-2 failure: soft-delete the network (rollback).
-         * 4. Rollback failures are logged at error level but never override the
-         *    primary failure message returned to the caller.
-         */
-        const createNode = async (state) => {
-            return timed("NetworkGraph.create", async () => {
-                logger.verbose("Create network", { userId: state.userId, createInput: state.createInput });
-                if (!state.createInput?.title?.trim()) {
-                    return { mutationResult: { success: false, error: "Title is required." } };
-                }
-                let createdNetworkId;
-                try {
-                    const network = await this.database.createNetwork({
-                        title: state.createInput.title.trim(),
-                        prompt: state.createInput.prompt?.trim() || undefined,
-                        imageUrl: state.createInput.imageUrl ?? undefined,
-                        joinPolicy: state.createInput.joinPolicy,
-                    });
-                    createdNetworkId = network.id;
-                    const added = await this.database.addMemberToNetwork(network.id, state.userId, 'owner');
-                    if (!added.success) {
-                        logger.error("addMemberToNetwork failed; cleaning up orphaned network", { networkId: network.id });
-                        try {
-                            await this.database.softDeleteNetwork(network.id);
-                        }
-                        catch (rollbackError) {
-                            logger.error("Network create rollback failed", {
-                                networkId: network.id,
-                                rollbackFor: "owner_membership",
-                                rollbackErrorKind: rollbackError instanceof Error ? "error" : "non_error",
-                            });
-                        }
-                        return { mutationResult: { success: false, error: "Failed to set you as owner. Network was not created." } };
-                    }
-                    return {
-                        mutationResult: {
-                            success: true,
-                            networkId: network.id,
-                            title: network.title,
-                            message: `Network "${network.title}" created. You are the owner.`,
-                        },
-                    };
-                }
-                catch (err) {
-                    logger.error("Create network failed", { error: err });
-                    if (createdNetworkId) {
-                        try {
-                            await this.database.softDeleteNetwork(createdNetworkId);
-                        }
-                        catch (rollbackError) {
-                            logger.error("Network create rollback failed", {
-                                networkId: createdNetworkId,
-                                rollbackFor: "create_operation",
-                                rollbackErrorKind: rollbackError instanceof Error ? "error" : "non_error",
-                            });
-                        }
-                    }
-                    return {
-                        mutationResult: {
-                            success: false,
-                            error: err instanceof Error ? err.message : "Failed to create network.",
+                const scopedMembership = allMemberships.find((m) => m.networkId === networkId);
+                const personalMembership = scopedMembership?.isPersonal
+                    ? undefined
+                    : allMemberships.find((m) => m.isPersonal);
+                const scopedOwned = ownedIndexes.find((o) => o.id === networkId);
+                const personalOwned = personalMembership
+                    ? ownedIndexes.find((o) => o.id === personalMembership.networkId)
+                    : undefined;
+                const memberOf = [
+                    ...(scopedMembership ? [projectMembership(scopedMembership)] : []),
+                    ...(personalMembership ? [projectMembership(personalMembership)] : []),
+                ];
+                const owns = [
+                    ...(scopedOwned ? [projectOwned(scopedOwned)] : []),
+                    ...(personalOwned ? [projectOwned(personalOwned)] : []),
+                ];
+                return {
+                    readResult: {
+                        memberOf,
+                        owns,
+                        stats: {
+                            memberOfCount: memberOf.length,
+                            ownsCount: owns.length,
+                            scopeNote: "Showing current network and your personal network. Use showAll: true for all networks.",
                         },
-                    };
-                }
+                    },
+                };
+            }
+            // Include public networks available to join
+            const publicNetworks = publicIndexesResult.networks.map((idx) => ({
+                networkId: idx.id,
+                title: idx.title,
+                prompt: idx.prompt,
+                memberCount: idx.memberCount,
+                owner: idx.owner,
+            }));
+            return {
+                readResult: {
+                    memberOf: allMemberships.map(projectMembership),
+                    owns: ownedIndexes.map(projectOwned),
+                    publicNetworks,
+                    stats: { memberOfCount: allMemberships.length, ownsCount: ownedIndexes.length, publicNetworksCount: publicNetworks.length },
+                },
+            };
+        }
+        catch (err) {
+            logger.error("Read networks failed", { error: err });
+            return { error: "Failed to fetch network information." };
+        }
+    });
+}
+/**
+ * Create Node: Create a new network and add user as owner.
+ *
+ * Atomicity contract:
+ * 1. Create the network row.
+ * 2. Add the calling user as owner.
+ * 3. On step-2 failure: soft-delete the network (rollback).
+ * 4. Rollback failures are logged at error level but never override the
+ *    primary failure message returned to the caller.
+ */
+export async function createNode(state, deps) {
+    return timed("NetworkGraph.create", async () => {
+        logger.verbose("Create network", { userId: state.userId, createInput: state.createInput });
+        if (!state.createInput?.title?.trim()) {
+            return { mutationResult: { success: false, error: "Title is required." } };
+        }
+        let createdNetworkId;
+        try {
+            const network = await deps.database.createNetwork({
+                title: state.createInput.title.trim(),
+                prompt: state.createInput.prompt?.trim() || undefined,
+                imageUrl: state.createInput.imageUrl ?? undefined,
+                joinPolicy: state.createInput.joinPolicy,
             });
-        };
-        /**
-         * Update Node: Update network settings (owner only).
-         */
-        const updateNode = async (state) => {
-            return timed("NetworkGraph.update", async () => {
-                const networkId = state.networkId;
-                logger.verbose("Update network", { userId: state.userId, networkId, updateInput: state.updateInput });
-                if (!networkId) {
-                    return { mutationResult: { success: false, error: "networkId is required for update." } };
-                }
+            createdNetworkId = network.id;
+            const added = await deps.database.addMemberToNetwork(network.id, state.userId, 'owner');
+            if (!added.success) {
+                logger.error("addMemberToNetwork failed; cleaning up orphaned network", { networkId: network.id });
                 try {
-                    const isOwner = await this.database.isIndexOwner(networkId, state.userId);
-                    if (!isOwner) {
-                        return { mutationResult: { success: false, error: "You can only modify networks you own." } };
-                    }
-                    await this.database.updateIndexSettings(networkId, state.userId, state.updateInput ?? {});
-                    return {
-                        mutationResult: {
-                            success: true,
-                            networkId,
-                            message: "Network settings updated.",
-                        },
-                    };
-                }
-                catch (err) {
-                    logger.error("Update network failed", { error: err });
-                    return { mutationResult: { success: false, error: "Failed to update network." } };
+                    await deps.database.softDeleteNetwork(network.id);
                 }
-            });
-        };
-        /**
-         * Delete Node: Soft-delete a network (owner only, sole member).
-         */
-        const deleteNode = async (state) => {
-            return timed("NetworkGraph.delete", async () => {
-                const networkId = state.networkId;
-                logger.verbose("Delete network", { userId: state.userId, networkId });
-                if (!networkId) {
-                    return { mutationResult: { success: false, error: "networkId is required for delete." } };
+                catch (rollbackError) {
+                    logger.error("Network create rollback failed", {
+                        networkId: network.id,
+                        rollbackFor: "owner_membership",
+                        rollbackErrorKind: rollbackError instanceof Error ? "error" : "non_error",
+                    });
                 }
+                return { mutationResult: { success: false, error: "Failed to set you as owner. Network was not created." } };
+            }
+            return {
+                mutationResult: {
+                    success: true,
+                    networkId: network.id,
+                    title: network.title,
+                    message: `Network "${network.title}" created. You are the owner.`,
+                },
+            };
+        }
+        catch (err) {
+            logger.error("Create network failed", { error: err });
+            if (createdNetworkId) {
                 try {
-                    const isOwner = await this.database.isIndexOwner(networkId, state.userId);
-                    if (!isOwner) {
-                        return { mutationResult: { success: false, error: "You can only delete networks you own." } };
-                    }
-                    const count = await this.database.getNetworkMemberCount(networkId);
-                    if (count > 1) {
-                        return { mutationResult: { success: false, error: "Cannot delete network with other members. Remove members first." } };
-                    }
-                    await this.database.softDeleteNetwork(networkId);
-                    return {
-                        mutationResult: {
-                            success: true,
-                            networkId,
-                            message: "Network deleted.",
-                        },
-                    };
+                    await deps.database.softDeleteNetwork(createdNetworkId);
                 }
-                catch (err) {
-                    logger.error("Delete network failed", { error: err });
-                    return { mutationResult: { success: false, error: "Failed to delete network." } };
+                catch (rollbackError) {
+                    logger.error("Network create rollback failed", {
+                        networkId: createdNetworkId,
+                        rollbackFor: "create_operation",
+                        rollbackErrorKind: rollbackError instanceof Error ? "error" : "non_error",
+                    });
                 }
-            });
-        };
-        // --- CONDITIONAL ROUTING ---
-        const routeByMode = (state) => {
-            switch (state.operationMode) {
-                case 'create': return 'create';
-                case 'read': return 'read';
-                case 'update': return 'update';
-                case 'delete': return 'delete_idx';
-                default: return 'read';
             }
-        };
-        // --- GRAPH ASSEMBLY ---
-        const workflow = new StateGraph(NetworkGraphState)
-            .addNode("read", readNode)
-            .addNode("create", createNode)
-            .addNode("update", updateNode)
-            .addNode("delete_idx", deleteNode)
-            .addConditionalEdges(START, routeByMode, {
-            read: "read",
-            create: "create",
-            update: "update",
-            delete_idx: "delete_idx",
-        })
-            .addEdge("read", END)
-            .addEdge("create", END)
-            .addEdge("update", END)
-            .addEdge("delete_idx", END);
-        return workflow.compile();
+            return {
+                mutationResult: {
+                    success: false,
+                    error: err instanceof Error ? err.message : "Failed to create network.",
+                },
+            };
+        }
+    });
+}
+/**
+ * Update Node: Update network settings (owner only).
+ */
+export async function updateNode(state, deps) {
+    return timed("NetworkGraph.update", async () => {
+        const networkId = state.networkId;
+        logger.verbose("Update network", { userId: state.userId, networkId, updateInput: state.updateInput });
+        if (!networkId) {
+            return { mutationResult: { success: false, error: "networkId is required for update." } };
+        }
+        try {
+            const isOwner = await deps.database.isIndexOwner(networkId, state.userId);
+            if (!isOwner) {
+                return { mutationResult: { success: false, error: "You can only modify networks you own." } };
+            }
+            await deps.database.updateIndexSettings(networkId, state.userId, state.updateInput ?? {});
+            return {
+                mutationResult: {
+                    success: true,
+                    networkId,
+                    message: "Network settings updated.",
+                },
+            };
+        }
+        catch (err) {
+            logger.error("Update network failed", { error: err });
+            return { mutationResult: { success: false, error: "Failed to update network." } };
+        }
+    });
+}
+/**
+ * Delete Node: Soft-delete a network (owner only, sole member).
+ */
+export async function deleteNode(state, deps) {
+    return timed("NetworkGraph.delete", async () => {
+        const networkId = state.networkId;
+        logger.verbose("Delete network", { userId: state.userId, networkId });
+        if (!networkId) {
+            return { mutationResult: { success: false, error: "networkId is required for delete." } };
+        }
+        try {
+            const isOwner = await deps.database.isIndexOwner(networkId, state.userId);
+            if (!isOwner) {
+                return { mutationResult: { success: false, error: "You can only delete networks you own." } };
+            }
+            const count = await deps.database.getNetworkMemberCount(networkId);
+            if (count > 1) {
+                return { mutationResult: { success: false, error: "Cannot delete network with other members. Remove members first." } };
+            }
+            await deps.database.softDeleteNetwork(networkId);
+            return {
+                mutationResult: {
+                    success: true,
+                    networkId,
+                    message: "Network deleted.",
+                },
+            };
+        }
+        catch (err) {
+            logger.error("Delete network failed", { error: err });
+            return { mutationResult: { success: false, error: "Failed to delete network." } };
+        }
+    });
+}
+export function routeByMode(state) {
+    switch (state.operationMode) {
+        case 'create': return 'create';
+        case 'read': return 'read';
+        case 'update': return 'update';
+        case 'delete': return 'delete_idx';
+        default: return 'read';
     }
 }

package/dist/networks/domain/membership.state.d.ts

@@ -30,7 +30,7 @@ export declare const NetworkMembershipGraphState: import("@langchain/langgraph")
         Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
     };
     /** Operation mode. */
-    operationMode: import("@langchain/langgraph").BaseChannel<"delete" | "create" | "read", "delete" | "create" | "read" | import("@langchain/langgraph").OverwriteValue<"delete" | "create" | "read">, unknown>;
+    operationMode: import("@langchain/langgraph").BaseChannel<"create" | "delete" | "read", "create" | "delete" | "read" | import("@langchain/langgraph").OverwriteValue<"create" | "delete" | "read">, unknown>;
     /** For create/delete: the user being added/removed. */
     targetUserId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
     /** Output for read mode: list of members. */

package/dist/networks/domain/network.state.d.ts

@@ -23,7 +23,7 @@ export declare const NetworkGraphState: import("@langchain/langgraph").Annotatio
     /** Target network ID. Required for read/update/delete. From ChatGraph or tool arg. */
     networkId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
     /** Operation mode. */
-    operationMode: import("@langchain/langgraph").BaseChannel<"delete" | "update" | "create" | "read", "delete" | "update" | "create" | "read" | import("@langchain/langgraph").OverwriteValue<"delete" | "update" | "create" | "read">, unknown>;
+    operationMode: import("@langchain/langgraph").BaseChannel<"update" | "create" | "delete" | "read", "update" | "create" | "delete" | "read" | import("@langchain/langgraph").OverwriteValue<"update" | "create" | "delete" | "read">, unknown>;
     /** For create mode: network creation data. */
     createInput: import("@langchain/langgraph").BaseChannel<{
         title: string;

package/dist/opportunities/application/delivery-card.cache.d.ts

@@ -1,5 +1,5 @@
 import type { Cache } from '../../shared/interfaces/cache.interface.js';
-import type { OpportunityPresenter, PresenterDatabase } from './opportunity.presenter.js';
+import type { OpportunityPresenter, PresenterDatabase } from './opportunity.presentation.js';
 export interface CachedDeliveryCard {
     opportunityId: string;
     headline: string;

package/dist/opportunities/application/delivery-card.cache.js

@@ -1,5 +1,5 @@
-import { gatherPresenterContext } from './opportunity.presenter.js';
-import { buildDeliveryCardPresentationCacheKey } from '../domain/opportunity.presentation-cache.js';
+import { gatherPresenterContext } from './opportunity.presentation.js';
+import { buildDeliveryCardPresentationCacheKey } from './opportunity.presentation.js';
 export const DELIVERY_CARD_CACHE_TTL = 24 * 60 * 60; // 24 hours
 export async function getOrCreateDeliveryCardBatch(cache, presenter, presenterDb, opportunities, viewerId, options) {
     if (opportunities.length === 0) {

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

@@ -38,11 +38,11 @@ export * from "./opportunity.persistence-admission.js";
 export * from "./opportunity.update-admission.js";
 export * from "./opportunity.newborn-stamping.js";
 export * from "./opportunity.evaluator.js";
-export * from "./opportunity.presenter.js";
+export * from "./opportunity.presentation.js";
 export * from "./opportunity.introducer.js";
 export * from "./opportunity.existing-negotiation.js";
 export * from "./opportunity.graph.js";
-export * from "./opportunity.card-presentation.js";
+export * from "./opportunity.presentation.js";
 export * from "./opportunity.discovery-negotiation-summary.js";
 export * from "./negotiation-context.loader.js";
 export * from "./opportunity.feed-selection.js";

package/dist/opportunities/application/index.js

@@ -39,11 +39,11 @@ export * from "./opportunity.persistence-admission.js";
 export * from "./opportunity.update-admission.js";
 export * from "./opportunity.newborn-stamping.js";
 export * from "./opportunity.evaluator.js";
-export * from "./opportunity.presenter.js";
+export * from "./opportunity.presentation.js";
 export * from "./opportunity.introducer.js";
 export * from "./opportunity.existing-negotiation.js";
 export * from "./opportunity.graph.js";
-export * from "./opportunity.card-presentation.js";
+export * from "./opportunity.presentation.js";
 export * from "./opportunity.discovery-negotiation-summary.js";
 export * from "./negotiation-context.loader.js";
 export * from "./opportunity.feed-selection.js";

package/dist/opportunities/application/opportunity.evaluator.js

@@ -12,7 +12,7 @@ import { tool } from "@langchain/core/tools";
 import { z } from "zod";
 import { protocolLogger } from "../../shared/observability/protocol.logger.js";
 import { Timed } from "../../shared/observability/performance.js";
-import { stripUuids } from "../domain/opportunity.presentation.js";
+import { stripUuids } from "./opportunity.presentation.js";
 import { createStructuredModel } from "../../shared/agent/model.config.js";
 import { invokeWithAbortSignal } from "../../shared/agent/model-signal.js";
 import { renderOpportunityEvidenceForPrompt } from '../domain/opportunity.evidence.js';