@indexnetwork/protocol 6.12.1-rc.404.1 → 6.14.0-rc.406.1

package/dist/questions/ports/question.tools.port.d.ts

@@ -0,0 +1,15 @@
+/**
+ * questions/ports/question.tools.port — host capabilities injected into question tools.
+ *
+ * Declares the narrow port types consumed by the foreground adapter tools
+ * (question delivery and chat-inline ask_user_question) without importing
+ * the full ToolRegistryCompositionDeps interface.
+ *
+ * IND-547: canonical home — previously capabilities/questions.tools.port.ts.
+ * Legacy path is a thin compatibility shim pointing here.
+ */
+import type { ToolRegistryCompositionDeps } from "../../shared/agent/tool.helpers.js";
+/** Host capabilities consumed by asynchronous question delivery tools. */
+export type QuestionerToolDeps = Pick<ToolRegistryCompositionDeps, "answerPendingQuestion" | "findPendingQuestions" | "reportToolError">;
+/** Host capabilities consumed by the blocking, chat-only question tool. */
+export type AskUserQuestionToolDeps = Pick<ToolRegistryCompositionDeps, "chatQuestions" | "chatSession" | "getUserContextText">;

package/dist/questions/ports/question.tools.port.js

@@ -0,0 +1 @@
+export {};

package/dist/questions/public/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * questions/public — curated public surface of the questions capability.
+ *
+ * Re-exports stable contracts from domain, application, and ports.
+ * Runtime adapter creation (tool factories, agent) is accessible here for
+ * package consumers; internal module details (presets, prompt builders, qud
+ * taxonomy) remain private to the application layer.
+ *
+ * ## Boundary
+ *
+ * References only questions/domain, questions/application, and questions/ports.
+ * Never imports from runtime/foreground, host implementations, or other
+ * capability internals.
+ *
+ * ## Intentionally excluded from public surface
+ *
+ * The following are application-internal:
+ * - getPreset, QuestionerPreset — LLM preset internals; import from
+ *   questions/application/ when needed for testing overrides.
+ * - QUD_UNDERSPECIFICATION_RULES — prompt composition detail.
+ * - buildDiscoveryQuestionPrompt, DISCOVERY_SYSTEM_PROMPT — prompt internals.
+ * - chatQuestionWaitTimeoutMs, CHAT_QUESTION_WAIT_TIMEOUT_MS_DEFAULT — only
+ *   needed inside the ask tool itself.
+ * - setQuestionerAgentForTesting — test seam, not for consumers.
+ *
+ * ## Foreground vs ambient delivery
+ *
+ * **Foreground adapters** (authenticated, participant-directed):
+ * - `createQuestionerTools` — MCP tools for read/answer/dismiss.
+ * - `createAskUserQuestionTools` — blocking inline chat questions.
+ *
+ * **Ambient adapters** (background generation, not exported here):
+ * - Recovery, pool, uptake, inflight, and push generation are scheduled by
+ *   QuestionerQueue (backend) via `QuestionerEnqueueFn`. The queue calls
+ *   `QuestionerAgent.invoke()` with the appropriate mode context.
+ *
+ * IND-547: canonical public surface for the questions capability.
+ * Legacy paths (capabilities/questions.facade.ts) re-export from here.
+ */
+export * from "../domain/index.js";
+export { QuestionerAgent } from "../application/index.js";
+export type { QuestionerAgentConfig } from "../application/index.js";
+export { isQuestionerEnabled, isDiscoveryQuestionsEnabled, isUptakeGuardEnabled, uptakeAuthorityThreshold, discoveryQuestionsInputMode, discoveryQuestionsTimeoutMs, DISCOVERY_QUESTIONS_TIMEOUT_MS_DEFAULT, UPTAKE_AUTHORITY_THRESHOLD_DEFAULT, } from "../application/index.js";
+export { isValidQuestionerInputContract, } from "../application/index.js";
+export type { QuestionerInput, QuestionerEnqueuePayload, QuestionerEnqueueFn, PoolDiscoveryContext, RecoveryQuestionerInput, UptakeQuestionerInput, PostStallQuestionerInput, InflightQuestionerInput, } from "../application/index.js";
+export { createQuestionerTools, createAskUserQuestionTools } from "../application/index.js";
+export type { QuestionerToolDeps, AskUserQuestionToolDeps } from "../ports/index.js";

package/dist/questions/public/index.js

@@ -0,0 +1,49 @@
+/**
+ * questions/public — curated public surface of the questions capability.
+ *
+ * Re-exports stable contracts from domain, application, and ports.
+ * Runtime adapter creation (tool factories, agent) is accessible here for
+ * package consumers; internal module details (presets, prompt builders, qud
+ * taxonomy) remain private to the application layer.
+ *
+ * ## Boundary
+ *
+ * References only questions/domain, questions/application, and questions/ports.
+ * Never imports from runtime/foreground, host implementations, or other
+ * capability internals.
+ *
+ * ## Intentionally excluded from public surface
+ *
+ * The following are application-internal:
+ * - getPreset, QuestionerPreset — LLM preset internals; import from
+ *   questions/application/ when needed for testing overrides.
+ * - QUD_UNDERSPECIFICATION_RULES — prompt composition detail.
+ * - buildDiscoveryQuestionPrompt, DISCOVERY_SYSTEM_PROMPT — prompt internals.
+ * - chatQuestionWaitTimeoutMs, CHAT_QUESTION_WAIT_TIMEOUT_MS_DEFAULT — only
+ *   needed inside the ask tool itself.
+ * - setQuestionerAgentForTesting — test seam, not for consumers.
+ *
+ * ## Foreground vs ambient delivery
+ *
+ * **Foreground adapters** (authenticated, participant-directed):
+ * - `createQuestionerTools` — MCP tools for read/answer/dismiss.
+ * - `createAskUserQuestionTools` — blocking inline chat questions.
+ *
+ * **Ambient adapters** (background generation, not exported here):
+ * - Recovery, pool, uptake, inflight, and push generation are scheduled by
+ *   QuestionerQueue (backend) via `QuestionerEnqueueFn`. The queue calls
+ *   `QuestionerAgent.invoke()` with the appropriate mode context.
+ *
+ * IND-547: canonical public surface for the questions capability.
+ * Legacy paths (capabilities/questions.facade.ts) re-export from here.
+ */
+// ── Domain schemas and types ──────────────────────────────────────────────────
+export * from "../domain/index.js";
+// ── Application: agent ────────────────────────────────────────────────────────
+export { QuestionerAgent } from "../application/index.js";
+// ── Application: env accessors ────────────────────────────────────────────────
+export { isQuestionerEnabled, isDiscoveryQuestionsEnabled, isUptakeGuardEnabled, uptakeAuthorityThreshold, discoveryQuestionsInputMode, discoveryQuestionsTimeoutMs, DISCOVERY_QUESTIONS_TIMEOUT_MS_DEFAULT, UPTAKE_AUTHORITY_THRESHOLD_DEFAULT, } from "../application/index.js";
+// ── Application: input types and validation ───────────────────────────────────
+export { isValidQuestionerInputContract, } from "../application/index.js";
+// ── Application: foreground adapter tools ─────────────────────────────────────
+export { createQuestionerTools, createAskUserQuestionTools } from "../application/index.js";

package/dist/runtime/background/index.d.ts

@@ -0,0 +1,14 @@
+export {};
+/**
+ * runtime/background — IND-543 outer shell.
+ *
+ * Entry point for ambient / background workflow adapters: maintenance graphs,
+ * enrichment runners, negotiation schedulers, and other non-interactive
+ * entry points that operate without a live participant session.
+ *
+ * Boundary: ambient-background.  May import from any capability via its
+ * capabilities/*.facade.ts contract.  Must not import host implementations.
+ *
+ * Shell is intentionally empty at this phase (IND-543 outer seam only).
+ * Domain-level adapter relocations follow in subsequent issues.
+ */

package/dist/runtime/background/index.js

@@ -0,0 +1,14 @@
+export {};
+/**
+ * runtime/background — IND-543 outer shell.
+ *
+ * Entry point for ambient / background workflow adapters: maintenance graphs,
+ * enrichment runners, negotiation schedulers, and other non-interactive
+ * entry points that operate without a live participant session.
+ *
+ * Boundary: ambient-background.  May import from any capability via its
+ * capabilities/*.facade.ts contract.  Must not import host implementations.
+ *
+ * Shell is intentionally empty at this phase (IND-543 outer seam only).
+ * Domain-level adapter relocations follow in subsequent issues.
+ */

package/dist/runtime/foreground/composition/tool.factory.d.ts

@@ -0,0 +1,16 @@
+import { type ToolContext, type ResolvedToolContext } from "../../../shared/agent/tool.helpers.js";
+export type { ToolContext, ResolvedToolContext, ProtocolDeps } from "../../../shared/agent/tool.helpers.js";
+export type { ToolDeps } from "../../../shared/agent/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, preResolvedContext?: ResolvedToolContext): Promise<any[]>;
+/**
+ * Type for the tools array returned by createChatTools.
+ */
+export type ChatTools = Awaited<ReturnType<typeof createChatTools>>;

package/dist/runtime/foreground/composition/tool.factory.js

@@ -0,0 +1,224 @@
+import { tool } from "@langchain/core/tools";
+import { IntentGraphFactory } from "../../../signals/application/intent.graph.js";
+import { EnrichmentGraphFactory } from "../../../enrichment/enrichment.graph.js";
+import { OpportunityGraphFactory } from "../../../capabilities/opportunities.facade.js";
+import { HydeGraphFactory } from "../../../shared/hyde/hyde.graph.js";
+import { HydeGenerator } from "../../../shared/hyde/hyde.generator.js";
+import { LensInferrer } from "../../../shared/hyde/lens.inferrer.js";
+import { NetworkGraphFactory, NetworkMembershipGraphFactory, IntentNetworkGraphFactory } from "../../../capabilities/communities.facade.js";
+import { IntentIndexer } from "../../../signals/application/intent.indexer.js";
+import { NegotiationGraphFactory } from "../../../capabilities/negotiation.facade.js";
+import { PremiseGraphFactory } from "../../../premise/premise.graph.js";
+import { protocolLogger } from "../../../shared/observability/protocol.logger.js";
+import { resolveChatContext, error, redactSensitiveFields } from "../../../shared/agent/tool.helpers.js";
+import { deriveAllowedNetworkIds, scopeFromNetworkId } from "../../../shared/agent/tool.scope.js";
+import { invokeToolRuntime, toolRuntimeErrorToResult } from "../../../shared/agent/tool.runtime.js";
+import { createEnrichmentTools } from "../../../enrichment/enrichment.tools.js";
+import { createIntentTools } from "../signals/intent.tools.js";
+import { createNetworkTools } from "../../../capabilities/communities.facade.js";
+import { createOpportunityTools } from "../../../capabilities/opportunities.facade.js";
+import { createUtilityTools } from "../../../shared/agent/utility.tools.js";
+import { createIntegrationTools } from "../../../capabilities/integrations.facade.js";
+import { createContactTools } from "../../../capabilities/contacts.facade.js";
+import { createAgentTools } from "../../../capabilities/participant-agents.tools.facade.js";
+import { createNegotiationTools } from "../../../capabilities/negotiation.facade.js";
+import { createPremiseTools } from "../../../premise/premise.tools.js";
+import { createQuestionerTools, createAskUserQuestionTools } from "../../../capabilities/questions.facade.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,
+            contactsEnabled: deps.contactsEnabled,
+            actionToolsEnabled: deps.actionToolsEnabled,
+        }));
+    if (!preResolvedContext && explicitScope.scopeType && explicitScope.scopeId) {
+        resolvedContext.scopeType = explicitScope.scopeType;
+        resolvedContext.scopeId = explicitScope.scopeId;
+    }
+    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/session context when available.
+    const sessionAwareEnqueue = deps.questionerEnqueue
+        ? (input) => deps.questionerEnqueue({
+            ...input,
+            ...(resolvedContext.scopeType && resolvedContext.scopeId && !input.scopeId
+                ? { scopeType: resolvedContext.scopeType, scopeId: resolvedContext.scopeId }
+                : {}),
+            ...(resolvedContext.sessionId && !input.conversationId ? { conversationId: resolvedContext.sessionId } : {}),
+        })
+        : undefined;
+    const intentGraph = new IntentGraphFactory(database, embedder, deps.intentQueue, sessionAwareEnqueue).createGraph();
+    const premiseGraph = new PremiseGraphFactory(database, embedder).createGraph();
+    const profileGraph = new EnrichmentGraphFactory(database, scraper, deps.enricher, sessionAwareEnqueue, 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 networkGraph = new NetworkGraphFactory(database).createGraph();
+    const networkMembershipGraph = new NetworkMembershipGraphFactory(database).createGraph();
+    const intentNetworkGraph = new IntentNetworkGraphFactory(database, new IntentIndexer()).createGraph();
+    // ─── 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 integration = deps.integration;
+    const toolDeps = {
+        database,
+        userDb,
+        systemDb,
+        scraper,
+        embedder,
+        cache,
+        integration,
+        contactService: deps.contactService,
+        contactsEnabled: deps.contactsEnabled,
+        integrationImporter: deps.integrationImporter,
+        enricher: deps.enricher,
+        negotiationDatabase: deps.negotiationDatabase,
+        negotiationTimeoutQueue: deps.negotiationTimeoutQueue,
+        agentDatabase: deps.agentDatabase,
+        grantDefaultSystemPermissions: deps.grantDefaultSystemPermissions,
+        agentDispatcher: deps.agentDispatcher,
+        stampNewbornOpportunities: deps.stampNewbornOpportunities,
+        deliveryLedger: deps.deliveryLedger,
+        discoveryRuns: deps.discoveryRuns,
+        discoveryRunQueue: deps.discoveryRunQueue,
+        enrichmentRuns: deps.enrichmentRuns,
+        enrichmentRunQueue: deps.enrichmentRunQueue,
+        mintConnectToken: deps.mintConnectToken,
+        mintConnectLink: deps.mintConnectLink,
+        frontendUrl: deps.frontendUrl,
+        apiBaseUrl: deps.apiBaseUrl,
+        ...(deps.chatSummary && { chatSummary: deps.chatSummary }),
+        ...(deps.questionGenerator && { questionGenerator: deps.questionGenerator }),
+        ...(sessionAwareEnqueue && { questionerEnqueue: sessionAwareEnqueue }),
+        ...(deps.findPendingQuestions && { findPendingQuestions: deps.findPendingQuestions }),
+        ...(deps.answerPendingQuestion && { answerPendingQuestion: deps.answerPendingQuestion }),
+        ...(deps.negotiationSummary && { negotiationSummary: deps.negotiationSummary }),
+        ...(deps.chatQuestions && { chatQuestions: deps.chatQuestions }),
+        ...(deps.chatSession && { chatSession: deps.chatSession }),
+        ...(deps.getUserContextText && { getUserContextText: deps.getUserContextText }),
+        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 = createIntentTools(defineTool, toolDeps);
+    const networkTools = createNetworkTools(defineTool, toolDeps);
+    const opportunityTools = createOpportunityTools(defineTool, toolDeps);
+    const utilityTools = createUtilityTools(defineTool, toolDeps);
+    const contactTools = createContactTools(defineTool, toolDeps);
+    const agentTools = createAgentTools(defineTool, toolDeps);
+    const integrationTools = createIntegrationTools(defineTool, toolDeps);
+    const negotiationTools = deps.agentDispatcher
+        ? createNegotiationTools(defineTool, toolDeps)
+        : [];
+    const premiseTools = createPremiseTools(defineTool, toolDeps);
+    const questionerTools = createQuestionerTools(defineTool, toolDeps);
+    // Blocking mid-conversation questions — chat-only (never in the MCP registry),
+    // and only when the host provides the ChatQuestionsHost bridge.
+    const askUserQuestionTools = deps.chatQuestions
+        ? createAskUserQuestionTools(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,
+        ...intentTools,
+        ...networkTools,
+        ...opportunityToolsForChat,
+        ...utilityTools,
+        ...integrationTools,
+        ...contactTools,
+        ...agentTools,
+        ...negotiationTools,
+        ...premiseTools,
+        ...questionerTools,
+        ...askUserQuestionTools,
+    ];
+}

package/dist/runtime/foreground/composition/tool.registry.d.ts

@@ -0,0 +1,11 @@
+import type { ToolDeps, ToolRegistry } from '../../../shared/agent/tool.helpers.js';
+/**
+ * Creates a tool registry containing all tool handlers indexed by name.
+ * Handlers are raw async functions (not LangChain tool() wrappers) that
+ * accept { context, query } and return a JSON string.
+ *
+ * @param deps - Shared tool dependencies (graphs, database, embedder, etc.)
+ * @param context - Resolved user context for this request.
+ * @returns Map of tool name to raw tool definition.
+ */
+export declare function createToolRegistry(deps: ToolDeps): ToolRegistry;

package/dist/runtime/foreground/composition/tool.registry.js

@@ -0,0 +1,106 @@
+import { error, redactSensitiveFields } from '../../../shared/agent/tool.helpers.js';
+import { createEnrichmentTools } from '../../../enrichment/enrichment.tools.js';
+import { createIntentTools } from '../signals/intent.tools.js';
+import { createNetworkTools } from '../../../capabilities/communities.facade.js';
+import { createOpportunityTools } from '../../../capabilities/opportunities.facade.js';
+import { createUtilityTools } from '../../../shared/agent/utility.tools.js';
+import { createIntegrationTools } from '../../../capabilities/integrations.facade.js';
+import { createContactTools } from '../../../capabilities/contacts.facade.js';
+import { createAgentTools } from '../../../capabilities/participant-agents.tools.facade.js';
+import { createNegotiationTools } from '../../../capabilities/negotiation.facade.js';
+import { createChatTools } from '../../../chat/chat.tools.js';
+import { createPremiseTools } from '../../../premise/premise.tools.js';
+import { createQuestionerTools } from '../../../capabilities/questions.facade.js';
+import { protocolLogger } from '../../../shared/observability/protocol.logger.js';
+import { requestContext } from '../../../shared/observability/request-context.js';
+const logger = protocolLogger('ToolRegistry');
+/**
+ * Creates a tool registry containing all tool handlers indexed by name.
+ * Handlers are raw async functions (not LangChain tool() wrappers) that
+ * accept { context, query } and return a JSON string.
+ *
+ * @param deps - Shared tool dependencies (graphs, database, embedder, etc.)
+ * @param context - Resolved user context for this request.
+ * @returns Map of tool name to raw tool definition.
+ */
+export function createToolRegistry(deps) {
+    const registry = new Map();
+    // defineTool that captures raw handlers into the registry
+    function defineTool(opts) {
+        const entry = {
+            name: opts.name,
+            description: opts.description,
+            schema: opts.querySchema,
+            handler: async (input) => {
+                logger.verbose('Tool invoked', {
+                    toolName: opts.name,
+                    context: { userId: input.context.userId, scopeType: input.context.scopeType, scopeId: input.context.scopeId },
+                    query: redactSensitiveFields(input.query),
+                });
+                try {
+                    return await opts.handler({ context: input.context, query: input.query });
+                }
+                catch (err) {
+                    const abortSignal = requestContext.getStore()?.abortSignal;
+                    if (abortSignal?.aborted) {
+                        throw err;
+                    }
+                    logger.error('Tool failed', {
+                        toolName: opts.name,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                    return error(`Failed to execute ${opts.name}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            },
+        };
+        registry.set(opts.name, entry);
+        // Return a dummy — create*Tools functions collect return values into arrays,
+        // but for the registry path we only need the side-effect on the Map.
+        return null;
+    }
+    // Create all tool domains -- each one calls defineTool() which populates the registry.
+    // The local defineTool is compatible with DefineTool (which returns any).
+    const dt = defineTool;
+    createEnrichmentTools(dt, deps);
+    createIntentTools(dt, deps);
+    createNetworkTools(dt, deps);
+    createOpportunityTools(dt, deps);
+    createUtilityTools(dt, deps);
+    createIntegrationTools(dt, deps);
+    createContactTools(dt, deps);
+    createAgentTools(dt, deps);
+    createNegotiationTools(dt, deps);
+    createPremiseTools(dt, deps);
+    createQuestionerTools(dt, deps);
+    if (deps.chatSession) {
+        createChatTools(dt, deps);
+    }
+    // Deprecated tool-name aliases (IND-371). The canonical implementations are now
+    // registered under their *_user_context / *_enrichment_run names; we expose the
+    // legacy *_user_profile / *_profile_run names as thin aliases that delegate to the
+    // exact same handler + schema, so existing MCP clients keep working while they
+    // migrate. The old names are removed in IND-373.
+    const DEPRECATED_TOOL_ALIASES = [
+        ["read_user_profiles", "read_user_contexts"],
+        ["create_user_profile", "create_user_context"],
+        ["update_user_profile", "update_user_context"],
+        ["confirm_user_profile", "confirm_user_context"],
+        ["preview_user_profile", "preview_user_context"],
+        ["get_profile_run", "get_enrichment_run"],
+        ["cancel_profile_run", "cancel_enrichment_run"],
+    ];
+    for (const [oldName, canonicalName] of DEPRECATED_TOOL_ALIASES) {
+        const canonical = registry.get(canonicalName);
+        if (!canonical) {
+            logger.warn('Cannot register deprecated alias: canonical tool not found', { alias: oldName, canonicalName });
+            continue;
+        }
+        registry.set(oldName, {
+            ...canonical,
+            name: oldName,
+            description: `[DEPRECATED — use \`${canonicalName}\` instead; this alias is retained for backward compatibility and will be removed.] ${canonical.description}`,
+        });
+    }
+    logger.verbose('Tool registry created', { toolCount: registry.size });
+    return registry;
+}

package/dist/runtime/foreground/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * runtime/foreground — IND-543 outer shell.
+ *
+ * Entry point for participant-directed (foreground) interaction composition:
+ * tool registry assembly, chat adapters, MCP adapters, persona adapters.
+ *
+ * Boundary: interaction-composition.  May import from any capability via its
+ * capabilities/*.facade.ts contract.  Must not import host implementations.
+ *
+ * Curated temporary alias — the canonical implementation lives here;
+ * shared/agent/tool.registry.ts is a backward-compat shim that delegates here.
+ */
+export { createToolRegistry } from './composition/tool.registry.js';

package/dist/runtime/foreground/index.js

@@ -0,0 +1,13 @@
+/**
+ * runtime/foreground — IND-543 outer shell.
+ *
+ * Entry point for participant-directed (foreground) interaction composition:
+ * tool registry assembly, chat adapters, MCP adapters, persona adapters.
+ *
+ * Boundary: interaction-composition.  May import from any capability via its
+ * capabilities/*.facade.ts contract.  Must not import host implementations.
+ *
+ * Curated temporary alias — the canonical implementation lives here;
+ * shared/agent/tool.registry.ts is a backward-compat shim that delegates here.
+ */
+export { createToolRegistry } from './composition/tool.registry.js';

package/dist/runtime/foreground/signals/intent.tools.d.ts

@@ -0,0 +1,13 @@
+/**
+ * runtime/foreground/signals/intent.tools — foreground signals-adapter seam.
+ *
+ * Canonical runtime registration point for intent/signal tools in the
+ * participant-facing (foreground) interaction layer.  Re-exports the tool
+ * factory from the signals application layer so the foreground tool registry
+ * consumes the adapter rather than reaching directly into the signals
+ * implementation directory.
+ *
+ * Boundary: interaction-composition.  Imports signals only via the signals
+ * application contracts; must not import host implementations.
+ */
+export { createIntentTools, setIntentClarifierForTesting, describeIntentUpdateFailure, } from "../../../signals/application/intent.tools.js";

package/dist/runtime/foreground/signals/intent.tools.js

@@ -0,0 +1,13 @@
+/**
+ * runtime/foreground/signals/intent.tools — foreground signals-adapter seam.
+ *
+ * Canonical runtime registration point for intent/signal tools in the
+ * participant-facing (foreground) interaction layer.  Re-exports the tool
+ * factory from the signals application layer so the foreground tool registry
+ * consumes the adapter rather than reaching directly into the signals
+ * implementation directory.
+ *
+ * Boundary: interaction-composition.  Imports signals only via the signals
+ * application contracts; must not import host implementations.
+ */
+export { createIntentTools, setIntentClarifierForTesting, describeIntentUpdateFailure, } from "../../../signals/application/intent.tools.js";

package/dist/shared/agent/model-signal.d.ts

@@ -12,4 +12,3 @@ export declare function invokeWithAbortSignal<TInput, TOutput>(runnable: {
         signal?: AbortSignal;
     }): Promise<TOutput>;
 }, input: TInput, signal?: AbortSignal): Promise<TOutput>;
-//# sourceMappingURL=model-signal.d.ts.map

package/dist/shared/agent/model-signal.js

@@ -36,4 +36,3 @@ export async function invokeWithAbortSignal(runnable, input, signal) {
     const config = getAbortSignalConfig(signal);
     return config ? runnable.invoke(input, config) : runnable.invoke(input);
 }
-//# sourceMappingURL=model-signal.js.map

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

@@ -214,4 +214,3 @@ export declare function createStructuredModel<RunOutput extends Record<string, a
  */
 export declare function createResilientModel(agent: ModelAgent, config?: ModelConfig): Runnable<BaseLanguageModelInput, AIMessageChunk>;
 export {};
-//# sourceMappingURL=model.config.d.ts.map

package/dist/shared/agent/model.config.js

@@ -184,4 +184,3 @@ export function createStructuredModel(agent, outputSchema, options, config) {
 export function createResilientModel(agent, config) {
     return withResilience(createModel(agent, config), createFallbackModel(agent, config));
 }
-//# sourceMappingURL=model.config.js.map

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

@@ -1,17 +1,6 @@
-import { type ToolContext, type ResolvedToolContext } from "./tool.helpers.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.
+ * @deprecated Canonical location: runtime/foreground/composition/tool.factory
+ * Retained for backward compatibility during IND-544 migration.
+ * Import createChatTools from @indexnetwork/protocol instead.
  */
-export declare function createChatTools(deps: ToolContext, preResolvedContext?: ResolvedToolContext): Promise<any[]>;
-/**
- * Type for the tools array returned by createChatTools.
- */
-export type ChatTools = Awaited<ReturnType<typeof createChatTools>>;
-//# sourceMappingURL=tool.factory.d.ts.map
+export { createChatTools, type ChatTools, type ToolContext, type ResolvedToolContext, type ProtocolDeps, type ToolDeps, } from "../../runtime/foreground/composition/tool.factory.js";