@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0-rc.604.2

package/dist/shared/agent/canonical-guidance.js

@@ -1,246 +0,0 @@
-/**
- * Canonical guidance for Index Network protocol operations.
- *
- * This is the single normative source for:
- * - Entity model and identity/context definitions
- * - Premise, signal, community, network, and opportunity concepts
- * - Negotiation semantics (owner approval vs A2A acceptance)
- * - H2A and A2A collaboration (H2H is never exposed)
- * - Retired vocabulary (no contact/Gmail/scrape/profile/ghost-user guidance)
- *
- * Wired into:
- * - MCP_INSTRUCTIONS (packages/protocol/src/mcp/mcp.server.ts)
- * - read_docs tool (packages/protocol/src/shared/agent/utility.tools.ts)
- *
- * IND-602, IND-603
- */
-export const CANONICAL_GUIDANCE_TOPICS = [
-    "identity-context",
-    "premises",
-    "signals",
-    "communities-networks",
-    "opportunities",
-    "negotiations",
-    "workflows",
-];
-/**
- * Summary of canonical entity model and protocol semantics.
- * Used in MCP_INSTRUCTIONS and as read_docs summary across all surfaces.
- * Never mentions retired contact/Gmail/scrape/profile/ghost-user guidance.
- * Optimized to ~1900 chars to leave room for MCP_INSTRUCTIONS context budget.
- */
-export const CANONICAL_GUIDANCE_SUMMARY = `# Index Network Protocol
-
-Index Network is a private, intent-driven discovery protocol. Users express signals (intents), agents find matches within shared networks, and decisions proceed through clear gates.
-
-## Core Concepts
-
-**Identity & Context** — Account and presentation metadata plus scoped runtime state (networks, signals, stage).
-
-**Premises** — Foundational facts: background, experience, stage, timeline, constraints.
-
-**Signals** — What users seek (intents, opportunities). Drive semantic matching.
-
-**Communities & Networks** — Private groups where members share signals and discover connections via shared membership.
-
-**Opportunities** — Discovered matches between users. Lifecycle: draft → pending → accepted/rejected/expired.
-
-**Negotiations** — Agents coordinate, users approve. **A2A acceptance is not owner approval.** These are separate gates.
-
-**Workflows** — H2A (users express signals → agents discover) and A2A (agents coordinate) over MCP. Further escalation via native surfaces (human-to-human threads do not cross MCP).
-
-## Canonical Topics
-
-Refer to these for detailed entity facts and lifecycle:
-
-- **identity-context** — Presentation identity, context scoping, matching inputs
-- **premises** — Background, stage, constraints
-- **signals** — Intent inference, classification
-- **communities-networks** — Membership, auto-assign
-- **opportunities** — Discovery, roles, reasoning
-- **negotiations** — Owner approval vs A2A, acceptance gates
-- **workflows** — H2A and A2A tool sequences`;
-/**
- * Detailed canonical topic content for read_docs.
- * Indexed by topic name; each contains current entity, capability, and lifecycle facts.
- */
-export const CANONICAL_GUIDANCE_TOPICS_CONTENT = {
-    "identity-context": `## Identity & Context
-
-**Identity** is account and presentation metadata: name, bio, location, skills, interests, and social links. It identifies and presents the user; it does not provide a profile-vector matching corpus.
-
-**Context** is scoped runtime state: network memberships, approved signals, lifecycle stage, and current opportunity or negotiation state. It determines the user's active scope and available workflow state.
-
-### Matching Inputs
-Matching uses approved signals, premises, shared network membership, and current opportunity or negotiation state. Premises supply the asserted background, constraints, and capabilities that ground relevant matches.
-
-### Context Scoping
-- Users can belong to multiple networks
-- Each network has a scope (open to all members or invite-only)
-- Matching is scoped to shared networks
-
-### Key Distinction
-Identity is account/presentation metadata. Context is dynamic, scoped runtime state for what the user is doing now.`,
-    premises: `## Premises
-
-**Premise** is the foundational context that shapes what matches will be relevant: a user's background, experience level, location, timeline, stage of life, constraints, and what they can actually commit to.
-
-### Premise Examples
-- "I'm a junior developer with 2 years of Python experience"
-- "I'm based in Berlin and can't relocate"
-- "I'm looking to start a company but can only contribute part-time until March"
-- "I've exited twice and have capital to invest"
-
-### Why Premises Matter
-Premises filter and prioritize candidates. Two opportunities with identical signal overlap will rank differently based on whose premises align. A senior engineer may look for "growing engineers" (premise: mentor/investor) vs "equal partners" (premise: cofounder).
-
-### Expressing Premises
-- In profile: bio section and skills/interests summarize professional premise
-- In intents: the description should include stage, timeline, and constraints
-- In context: shared network membership indicates domain interest
-
-### Premise Inference
-The system learns premises from:
-- Explicit user input (bio, intent descriptions)
-- Social enrichment (LinkedIn career history, GitHub project scale)
-- Behavioral signals (intents created, networks joined)`,
-    signals: `## Signals
-
-**Signal** is what a user is actively looking for — an intent, a need, a role they want to fill. Signals are the atoms of discovery.
-
-### Signal Properties
-- Description (free text: "Looking for a React developer for a 3-month contract in Berlin")
-- Summary (structured extract: role, domain, stage, geography, duration)
-- Confidence (0-1, how well the inference captured the user's intent)
-- Inference type (explicit = user stated directly; implicit = system inferred)
-- Embedding (semantic vector for matching)
-
-### Signal vs Premise
-- **Premise** is the user's foundational context ("I'm a senior engineer in Berlin")
-- **Signal** is what they're seeking right now ("I'm looking for co-founders to start an AI company")
-
-### Signal Lifecycle
-1. User creates intent (explicit signal) or system infers from behavior (implicit)
-2. Signal is embedded (converted to semantic vector)
-3. Signal is assigned to networks (via auto-assign rules)
-4. Signal participates in discovery (matched against other signals)
-
-### Signal Best Practices
-- Be specific: "Senior React developer, 3-month contract, Berlin" > "Need a developer"
-- One signal per need: don't combine multiple requests
-- Update signals when context changes (location, timeline, role requirements)`,
-    "communities-networks": `## Communities & Networks
-
-**Network** (also called "community") is a private group where members share signals and discover connections. Each network has:
-- Title and optional purpose prompt (describing what the network is for)
-- Membership list (with permissions and auto-assign settings)
-- Join policy (open to anyone or invite-only)
-- Scope for discovery (opportunities are found within shared networks)
-
-### Network Properties
-- Purpose prompt: Used to evaluate whether new signals belong in this network (signals with high relevance are auto-assigned)
-- Join policy: "anyone" (self-join) or "invite_only" (owner invites)
-- Owner: Can update settings, add/remove members, delete network
-- Auto-assign: Members can opt in/out of automatic signal assignment
-
-### Network Scope for Discovery
-- Opportunities are discovered only between members of shared networks
-- If two users share network A but not B, discovery in A will find them
-- Scoping discovery to a specific network (networkId parameter) narrows results to that community
-
-### Community Membership
-- Members see all signals in the network
-- Members can create signals (intents) that are auto-evaluated for relevance to the network
-- Members can discover within the network
-- Permissions track member type (owner, member, contact)
-
-### Key Constraint
-Discovery is networked — it only finds matches within shared networks. This privacy boundary is fundamental.`,
-    opportunities: `## Opportunities
-
-**Opportunity** is a discovered connection between two or more users based on complementary signals and shared network membership. Each opportunity has:
-- Parties (the people being connected)
-- Roles (introducer, party)
-- Status (draft → pending → accepted/rejected/expired)
-- Match reasoning (why they're a good fit)
-- Confidence score (0-1 from evaluation)
-
-### Opportunity Lifecycle
-1. **Draft**: Created locally, only visible to creator. Offer to send.
-2. **Pending**: Sent to recipient. They're notified and waiting.
-3. **Accepted**: Recipient accepted. Both parties see the match.
-4. **Rejected**: Recipient declined.
-5. **Expired**: Timed out without response.
-
-### Background Matching
-Approved signals are evaluated in the background. Use list_opportunities only to review persisted cards; it does not start matching.
-
-### Opportunity Evaluation
-- Candidate retrieval: Uses HyDE embeddings to find semantically related signals
-- LLM evaluation: Scores relevance, complementarity, and actionability
-- Reasoning: Each opportunity includes match reasoning for the user
-
-### Opportunity Acceptance
-Accepting an opportunity expresses interest in the connection. Owner acceptance (explicit user confirmation) is required for any escalation.`,
-    negotiations: `## Negotiations
-
-**Negotiation** is how agents and users coordinate to reach decisions about matches. Two distinct gates govern acceptance:
-
-### Agent-to-Agent (A2A) Acceptance
-When two agent services coordinate on behalf of their users, they may reach agreement that a match is worth pursuing. Agents veto, accept, or defer based on their user's context. This is A2A acceptance.
-
-### Owner Approval (Human Confirmation)
-When a human user explicitly confirms in conversation "Yes, I want to pursue this connection", that is owner approval. Owner approval is a separate, human-driven gate.
-
-### Critical Rule
-**A2A acceptance is not owner approval.** Agents can accept while humans have not yet approved. The system tracks these separately:
-- A2A acceptance: Agents vetted the match and recommend it
-- Owner approval: The human explicitly confirmed
-
-These gates are independent. Do not conflate them.
-
-### Negotiation Workflow
-1. Discovery creates draft opportunity
-2. A2A coordination (agents evaluate viability)
-3. A2A acceptance (agents agree to propose)
-4. Opportunity sent to recipient (pending)
-5. Owner review (human reads match reasoning)
-6. Owner approval (human confirms)
-7. Escalation (via native surfaces, not MCP)
-
-### Rules
-- Track A2A and owner approval separately
-- Never accept without explicit user approval
-- Always surface reasoning to owner
-- Human-to-human messaging is not MCP`,
-    workflows: `## Common Tool Workflows
-
-### H2A: Human→Agent Discovery
-User expresses signals (intents). Agent discovers matches and presents reasoning.
-
-1. User creates intents (signals)
-2. Background matching evaluates approved signals
-3. Agent uses list_opportunities to surface persisted matches
-4. User reviews and approves (owner approval)
-5. Escalation via native surfaces
-
-### A2A: Agent→Agent Coordination
-Two agents coordinate on behalf of users to identify, vet, and propose matches.
-
-1. Approved signals for User A are evaluated in the background
-2. Agent B vets match from User B side (A2A negotiation)
-3. Agents reach agreement (A2A acceptance)
-4. Both agents present to users with shared reasoning
-5. Both users approve (owner approval required)
-6. Escalation via native surfaces
-
-### MCP Scope
-The MCP protocol carries H2A and A2A workflows only. Escalation to direct messaging (web, Telegram, native surfaces) is outside MCP.
-
-### Best Practices
-- Call read_docs to understand the domain
-- Create or refine approved signals in relevant shared networks; list_opportunities reviews persisted results
-- Present matches and reasoning to users
-- Get explicit owner approval before any commitment
-- Escalation to direct messaging is not MCP`,
-};

package/dist/shared/agent/model.resolver.d.ts

@@ -1,48 +0,0 @@
-/**
- * Canonical model-assignment authority for every protocol agent.
- *
- * The resolver is pure: callers provide the complete environment projection it
- * may read. Historical eval planning uses the returned all-agent map so an
- * unmentioned agent cannot drift behind an implicit runtime default.
- */
-export declare const CANONICAL_AGENT_MODEL_DEFAULTS: Readonly<{
-    readonly intentInferrer: "google/gemini-2.5-flash";
-    readonly intentIndexer: "google/gemini-2.5-flash";
-    readonly intentVerifier: "google/gemini-2.5-flash";
-    readonly intentReconciler: "google/gemini-2.5-flash";
-    readonly intentClarifier: "google/gemini-2.5-flash";
-    readonly profileGenerator: "google/gemini-2.5-flash";
-    readonly hydeGenerator: "google/gemini-2.5-flash";
-    readonly hydeValidator: "google/gemini-2.5-flash";
-    readonly lensInferrer: "google/gemini-2.5-flash";
-    readonly opportunityEvaluator: "google/gemini-2.5-flash";
-    readonly opportunityPresenter: "google/gemini-2.5-flash";
-    readonly negotiator: "google/gemini-2.5-flash";
-    readonly negotiationScreener: "google/gemini-2.5-flash";
-    readonly negotiationReflector: "google/gemini-2.5-flash";
-    readonly homeCategorizer: "google/gemini-2.5-flash";
-    readonly suggestionGenerator: "google/gemini-2.5-flash";
-    readonly chatTitleGenerator: "google/gemini-2.5-flash";
-    readonly negotiationInsights: "google/gemini-2.5-flash";
-    readonly chatContextSummarizer: "google/gemini-2.5-flash";
-    readonly questioner: "google/gemini-2.5-flash";
-    readonly signalIntakePack: "google/gemini-2.5-flash";
-    readonly negotiationSummarizer: "google/gemini-2.5-flash";
-    readonly poolDiscriminatorMiner: "google/gemini-2.5-flash";
-    readonly poolDiscriminatorAssigner: "google/gemini-2.5-flash";
-    readonly negotiationEvidenceMiner: "google/gemini-2.5-flash";
-    readonly inviteGenerator: "google/gemini-2.5-flash";
-    readonly premiseAnalyzer: "google/gemini-2.5-flash";
-    readonly premiseDecomposer: "google/gemini-2.5-flash";
-    readonly premiseIndexer: "google/gemini-2.5-flash";
-    readonly userContextGenerator: "google/gemini-2.5-flash";
-    readonly networkRecommender: "google/gemini-2.5-flash";
-    readonly interruptClassifier: "google/gemini-2.5-flash";
-    readonly chat: "google/gemini-3-pro-preview";
-}>;
-export type CanonicalModelAgent = keyof typeof CANONICAL_AGENT_MODEL_DEFAULTS;
-export type CanonicalAllAgentModels = Readonly<Record<CanonicalModelAgent, string>>;
-export declare const CANONICAL_MODEL_AGENTS: readonly ("intentInferrer" | "intentIndexer" | "intentVerifier" | "intentReconciler" | "intentClarifier" | "profileGenerator" | "hydeGenerator" | "hydeValidator" | "lensInferrer" | "opportunityEvaluator" | "opportunityPresenter" | "negotiator" | "negotiationScreener" | "negotiationReflector" | "homeCategorizer" | "suggestionGenerator" | "chatTitleGenerator" | "negotiationInsights" | "chatContextSummarizer" | "questioner" | "signalIntakePack" | "negotiationSummarizer" | "poolDiscriminatorMiner" | "poolDiscriminatorAssigner" | "negotiationEvidenceMiner" | "inviteGenerator" | "premiseAnalyzer" | "premiseDecomposer" | "premiseIndexer" | "userContextGenerator" | "networkRecommender" | "interruptClassifier" | "chat")[];
-export declare function resolveCanonicalAllAgentModels(environment: Readonly<Record<string, string | undefined>>, options?: {
-    applyEvalOverrides?: boolean;
-}): CanonicalAllAgentModels;

package/dist/shared/agent/tool.factory.d.ts

@@ -1,17 +0,0 @@
-import { type ToolContext, type ResolvedToolContext } from "./tool.helpers.js";
-import type { OpportunityOwnerApprovalDeps } from "../../opportunities/opportunity.tools.port.js";
-export type { ToolContext, ResolvedToolContext, ProtocolDeps } from "./tool.helpers.js";
-export type { ToolDeps } from "./tool.helpers.js";
-/**
- * Creates all chat tools bound to a specific user context.
- * Resolves user/network identity from DB at init time.
- * Tools are created fresh for each user session to ensure proper isolation.
- *
- * All external dependencies (cache, integration, queue, etc.) are provided
- * via the `deps` parameter — the protocol lib never imports concrete adapters.
- */
-export declare function createChatTools(deps: ToolContext & OpportunityOwnerApprovalDeps, preResolvedContext?: ResolvedToolContext): Promise<any[]>;
-/**
- * Type for the tools array returned by createChatTools.
- */
-export type ChatTools = Awaited<ReturnType<typeof createChatTools>>;

package/dist/shared/agent/tool.factory.js

@@ -1,221 +0,0 @@
-import { tool } from "@langchain/core/tools";
-import { Intents } from "../../intents/intent.module.js";
-import { EnrichmentGraphFactory } from "../../enrichment/enrichment.graph.js";
-import { OpportunityGraphFactory } from "../../opportunities/opportunity.module.js";
-import { HydeGraphFactory } from "../../discovery/hyde.graph.js";
-import { HydeGenerator } from "../../discovery/hyde.generator.js";
-import { LensInferrer } from "../../discovery/lens.inferrer.js";
-import { Networks } from "../../networks/network.module.js";
-import { NegotiationGraphFactory } from "../../negotiations/negotiation.module.js";
-import { PremiseGraphFactory } from "../../premises/premise.graph.js";
-import { protocolLogger } from "../observability/protocol.logger.js";
-import { resolveChatContext, error, redactSensitiveFields } from "./tool.helpers.js";
-import { deriveAllowedNetworkIds, focusedIntentId, scopeFromNetworkId } from "./tool.scope.js";
-import { invokeToolRuntime, toolRuntimeErrorToResult } from "./tool.runtime.js";
-import { createEnrichmentTools } from "../../enrichment/enrichment.tools.js";
-import { createOpportunityTools } from "../../opportunities/opportunity.module.js";
-import { createUtilityTools } from "./utility.tools.js";
-import { createContactTools } from "../../contacts/contact.module.js";
-// The composition root reaches the leaf directly (it is exempt from the barrel
-// rule by design): importing agents/agent.module.js here would pull in the
-// chat personas, which import this module back -- a runtime cycle.
-import { createAgentTools } from "../../agents/agent.tools.js";
-import { createNegotiationTools } from "../../negotiations/negotiation.module.js";
-import { createPremiseTools } from "../../premises/premise.tools.js";
-import { bindOwnerApprovalProvenance } from "../../opportunities/opportunity.owner-provenance.js";
-const logger = protocolLogger("ChatTools");
-// ═══════════════════════════════════════════════════════════════════════════════
-// TOOL FACTORY
-// ═══════════════════════════════════════════════════════════════════════════════
-/**
- * Creates all chat tools bound to a specific user context.
- * Resolves user/network identity from DB at init time.
- * Tools are created fresh for each user session to ensure proper isolation.
- *
- * All external dependencies (cache, integration, queue, etc.) are provided
- * via the `deps` parameter — the protocol lib never imports concrete adapters.
- */
-export async function createChatTools(deps, preResolvedContext) {
-    const { database, embedder, scraper } = deps;
-    const explicitScope = deps.scopeType && deps.scopeId
-        ? { scopeType: deps.scopeType, scopeId: deps.scopeId }
-        : scopeFromNetworkId(deps.networkId);
-    // ─── Resolve context from DB ───────────────────────────────────────────────
-    // resolveChatContext still accepts a networkId because it loads scoped index
-    // presentation metadata; the canonical request scope is explicitScope.
-    const resolvedContext = preResolvedContext ??
-        (await resolveChatContext({
-            database,
-            userId: deps.userId,
-            networkId: explicitScope.scopeType === 'network' ? explicitScope.scopeId : deps.networkId,
-            sessionId: deps.sessionId,
-        }));
-    if (!preResolvedContext && explicitScope.scopeType && explicitScope.scopeId) {
-        resolvedContext.scopeType = explicitScope.scopeType;
-        resolvedContext.scopeId = explicitScope.scopeId;
-    }
-    // This factory is an orchestrated chat surface, never a direct owner request.
-    // Bind that fact at composition time rather than inferring it from a session
-    // id or a caller-controlled tool argument inside the opportunity handler.
-    bindOwnerApprovalProvenance(resolvedContext, {
-        surface: 'chat',
-        sessionAuthenticated: false,
-    });
-    const allowedNetworkIds = deriveAllowedNetworkIds({
-        memberships: resolvedContext.userNetworks,
-        ...(resolvedContext.scopeType && resolvedContext.scopeId
-            ? { scopeType: resolvedContext.scopeType, scopeId: resolvedContext.scopeId }
-            : {}),
-    });
-    // ─── Tool wrapper ──────────────────────────────────────────────────────────
-    /**
-     * Standardized tool factory. Auto-injects resolved context and
-     * provides uniform logging / error handling for every tool.
-     */
-    function defineTool(opts) {
-        return tool(async (query) => {
-            logger.info('Tool invoked', {
-                toolName: opts.name,
-                context: { userId: resolvedContext.userId, scopeType: resolvedContext.scopeType, scopeId: resolvedContext.scopeId },
-                query: redactSensitiveFields(query),
-            });
-            try {
-                return await invokeToolRuntime({
-                    toolName: opts.name,
-                    tool: { handler: async ({ context, query }) => opts.handler({ context, query: query }) },
-                    context: resolvedContext,
-                    query,
-                });
-            }
-            catch (err) {
-                logger.error('Tool failed', {
-                    toolName: opts.name,
-                    error: err instanceof Error ? err.message : String(err),
-                });
-                const runtimeResult = toolRuntimeErrorToResult(err);
-                if (runtimeResult)
-                    return runtimeResult;
-                const reason = err instanceof Error ? err.message : String(err);
-                return error(`Failed to execute ${opts.name}: ${reason}`);
-            }
-        }, { name: opts.name, description: opts.description, schema: opts.querySchema });
-    }
-    // ─── Compile subgraphs ─────────────────────────────────────────────────────
-    // Wrap questionerEnqueue to include scoped context when available. (The
-    // chat-session conversationId defaulting went with the retired chat-mode
-    // generator; park payloads carry their own recipient routing.)
-    const sessionAwareEnqueue = deps.questionerEnqueue
-        ? (input) => deps.questionerEnqueue({
-            ...input,
-            ...(resolvedContext.scopeType && resolvedContext.scopeId && !input.scopeId
-                ? { scopeType: resolvedContext.scopeType, scopeId: resolvedContext.scopeId }
-                : {}),
-        })
-        : undefined;
-    const intents = new Intents({
-        database,
-        embedder,
-        queue: deps.intentQueue,
-    });
-    const intentGraph = intents.createGraph();
-    const premiseGraph = new PremiseGraphFactory(database, embedder).createGraph();
-    const profileGraph = new EnrichmentGraphFactory(database, scraper, deps.enricher, premiseGraph).createGraph();
-    const hydeCache = deps.hydeCache;
-    const lensInferrer = new LensInferrer();
-    const hydeGenerator = new HydeGenerator();
-    const compiledHydeGraph = new HydeGraphFactory(database, embedder, hydeCache, lensInferrer, hydeGenerator).createGraph();
-    const negotiationGraph = deps.agentDispatcher
-        ? new NegotiationGraphFactory(deps.negotiationDatabase, deps.agentDispatcher, deps.negotiationTimeoutQueue, sessionAwareEnqueue).createGraph()
-        : undefined;
-    const opportunityGraph = new OpportunityGraphFactory(database, embedder, compiledHydeGraph, undefined, // evaluator (default)
-    undefined, // queueNotification
-    negotiationGraph, deps.agentDispatcher, deps.queueNegotiateExisting, deps.stampNewbornOpportunities).createGraph();
-    const networks = new Networks({ database, indexer: intents });
-    const networkGraph = networks.createGraph();
-    const networkMembershipGraph = networks.createMembershipGraph();
-    const intentNetworkGraph = networks.createAssignmentGraph();
-    // ─── Create context-bound databases ────────────────────────────────────────
-    // Use injected instances when provided (e.g. tests). Otherwise create from the same
-    // database used for graphs so that scope checks (e.g. ensureScopedMembership, opportunity
-    // update) use the same adapter as the rest of the tool pipeline.
-    //
-    // The systemDb's DB-level clamp derives concrete allowed network IDs from the
-    // focused scope envelope plus memberships, rather than consuming a transported
-    // legacy indexScope array.
-    const userDb = deps.userDb ?? deps.createUserDatabase(database, resolvedContext.userId);
-    const systemDb = deps.systemDb ?? deps.createSystemDatabase(database, resolvedContext.userId, allowedNetworkIds, embedder);
-    // ─── Assemble dependencies ─────────────────────────────────────────────────
-    const cache = deps.cache;
-    const toolDeps = {
-        database,
-        userDb,
-        systemDb,
-        scraper,
-        embedder,
-        cache,
-        contactService: deps.contactService,
-        enricher: deps.enricher,
-        negotiationDatabase: deps.negotiationDatabase,
-        negotiationTimeoutQueue: deps.negotiationTimeoutQueue,
-        agentDatabase: deps.agentDatabase,
-        grantDefaultSystemPermissions: deps.grantDefaultSystemPermissions,
-        agentDispatcher: deps.agentDispatcher,
-        stampNewbornOpportunities: deps.stampNewbornOpportunities,
-        deliveryLedger: deps.deliveryLedger,
-        ...(deps.opportunityOwnerApproval && { opportunityOwnerApproval: deps.opportunityOwnerApproval }),
-        enrichmentRuns: deps.enrichmentRuns,
-        enrichmentRunQueue: deps.enrichmentRunQueue,
-        frontendUrl: deps.frontendUrl,
-        apiBaseUrl: deps.apiBaseUrl,
-        ...(deps.chatSummary && { chatSummary: deps.chatSummary }),
-        ...(sessionAwareEnqueue && { questionerEnqueue: sessionAwareEnqueue }),
-        ...(deps.negotiationSummary && { negotiationSummary: deps.negotiationSummary }),
-        ...(deps.chatSession && { chatSession: deps.chatSession }),
-        ...(deps.getUserContextText && { getUserContextText: deps.getUserContextText }),
-        ...(deps.intentProposalStore && { intentProposalStore: deps.intentProposalStore }),
-        graphs: {
-            profile: profileGraph,
-            intent: intentGraph,
-            index: networkGraph,
-            networkMembership: networkMembershipGraph,
-            intentIndex: intentNetworkGraph,
-            opportunity: opportunityGraph,
-            premise: premiseGraph,
-        },
-    };
-    // ─── Create domain tools ──────────────────────────────────────────────────
-    const profileTools = createEnrichmentTools(defineTool, toolDeps);
-    const intentTools = Intents.createTools(defineTool, toolDeps);
-    // An intent-scoped conversation exists to refine its selected signal. Keep
-    // creation out of the model-visible registry; the update handler separately
-    // clamps writes to the exact scoped intent as a runtime backstop.
-    const intentToolsForChat = focusedIntentId(resolvedContext)
-        ? intentTools.filter((candidate) => candidate.name !== "create_intent")
-        : intentTools;
-    const networkTools = Networks.createTools(defineTool, toolDeps);
-    const opportunityTools = createOpportunityTools(defineTool, toolDeps);
-    const utilityTools = createUtilityTools(defineTool, toolDeps);
-    const contactTools = createContactTools(defineTool, toolDeps);
-    const agentTools = createAgentTools(defineTool, toolDeps);
-    const negotiationTools = deps.agentDispatcher
-        ? createNegotiationTools(defineTool, toolDeps)
-        : [];
-    const premiseTools = createPremiseTools(defineTool, toolDeps);
-    // confirm_opportunity_delivery is an OpenClaw-delivery ledger write and must not be
-    // callable from regular chat sessions.
-    const chatOpportunityToolExclusions = new Set([
-        "confirm_opportunity_delivery",
-    ]);
-    const opportunityToolsForChat = opportunityTools.filter((t) => !chatOpportunityToolExclusions.has(t.name));
-    return [
-        ...profileTools,
-        ...intentToolsForChat,
-        ...networkTools,
-        ...opportunityToolsForChat,
-        ...utilityTools,
-        ...contactTools,
-        ...agentTools,
-        ...negotiationTools,
-        ...premiseTools,
-    ];
-}