@sellable/mcp 0.1.769 → 0.1.770

package/dist/agent-integration-request-context.d.ts

@@ -38,6 +38,16 @@
  */
 export declare const AGENT_INTEGRATION_CONTEXT_TOOL_NAMES: readonly ["integrations_list_tools", "integrations_describe_tool", "integrations_call_tool"];
 export type AgentIntegrationContextToolName = (typeof AGENT_INTEGRATION_CONTEXT_TOOL_NAMES)[number];
+/**
+ * Plan 142-05's connect trio, in a SECOND frozen set rather than appended to the
+ * one above: two suites pin `AGENT_INTEGRATION_CONTEXT_TOOL_NAMES` to exactly
+ * the three `integrations_*` names 141-06 registers, and those pins are correct
+ * — they guard 141's registration, not 142's. `isAgentIntegrationContextTool`
+ * spans both sets, so the fail-closed dispatch guard in `server.ts` covers the
+ * connect tools with no change to the switch-side plumbing.
+ */
+export declare const AGENT_INTEGRATION_CONNECT_TOOL_NAMES: readonly ["search_available_integrations", "start_integration_connection", "get_integration_connection_status"];
+export type AgentIntegrationConnectToolName = (typeof AGENT_INTEGRATION_CONNECT_TOOL_NAMES)[number];
 /** The trusted actor triple a managed-integration call forwards to the backend. */
 export type AgentIntegrationRequestContext = {
     requesterId: string;

package/dist/agent-integration-request-context.js

@@ -41,9 +41,23 @@ export const AGENT_INTEGRATION_CONTEXT_TOOL_NAMES = Object.freeze([
     "integrations_describe_tool",
     "integrations_call_tool",
 ]);
+/**
+ * Plan 142-05's connect trio, in a SECOND frozen set rather than appended to the
+ * one above: two suites pin `AGENT_INTEGRATION_CONTEXT_TOOL_NAMES` to exactly
+ * the three `integrations_*` names 141-06 registers, and those pins are correct
+ * — they guard 141's registration, not 142's. `isAgentIntegrationContextTool`
+ * spans both sets, so the fail-closed dispatch guard in `server.ts` covers the
+ * connect tools with no change to the switch-side plumbing.
+ */
+export const AGENT_INTEGRATION_CONNECT_TOOL_NAMES = Object.freeze([
+    "search_available_integrations",
+    "start_integration_connection",
+    "get_integration_connection_status",
+]);
 export const AGENT_INTEGRATION_CONTEXT_REQUIRED_ERROR = "agent_request_context_required";
 export function isAgentIntegrationContextTool(name) {
-    return AGENT_INTEGRATION_CONTEXT_TOOL_NAMES.includes(name);
+    return (AGENT_INTEGRATION_CONTEXT_TOOL_NAMES.includes(name) ||
+        AGENT_INTEGRATION_CONNECT_TOOL_NAMES.includes(name));
 }
 /**
  * Resolves the trusted actor for a managed-integration tool call.

package/dist/agent-tool-names.d.ts

@@ -3,7 +3,7 @@
  * manifests. Keep this free of tool implementation imports so Next can bundle
  * it; registry parity is enforced in sellable-agent-tool-policy.test.ts.
  */
-export declare const SELLABLE_MCP_TOOL_NAMES: readonly ["add_column", "add_on_demand_leads", "add_rubric_item", "add_teammate", "add_to_comment_campaign", "add_to_connection_campaign", "add_to_inmail_campaign", "archive_campaign", "attach_recommended_sequence", "attach_sequence", "bootstrap_create_campaign", "bootstrap_engage", "bootstrap_engage_multi", "bootstrap_find_leads", "bulk_enrich_with_prospeo", "calculate_linkedin_hook_preview", "cancel_campaign_message_preparation", "cancel_find_leads", "cancel_lead_import", "capture_post_idea", "check_inbox_reply_eligibility", "check_rubric", "commit_blueprint", "complete_sender_research", "confirm_harvest_job_companies", "confirm_lead_list", "confirm_prospeo_company_accounts", "copy_sender_config", "create_campaign", "create_on_demand_campaign", "create_on_demand_table", "create_workflow_table", "create_workspace", "delete_column", "delete_rubric_item", "draft_rubrics", "duplicate_campaign", "enrich_with_prospeo", "export_table_csv", "export_workspace_csv", "fetch_company", "fetch_company_posts", "fetch_linkedin_posts", "fetch_linkedin_profile", "fetch_post_engagers", "fill_campaign_horizon", "get_active_workspace", "get_auth_status", "get_campaign", "get_campaign_context", "get_campaign_framework", "get_campaign_message_preparation_status", "get_campaign_messages_preview", "get_campaign_navigation_state", "get_campaign_refill_state", "get_campaign_table_schema", "get_campaign_waterfall", "get_campaigns", "get_column_schema", "get_company_info", "get_engage_memory", "get_engage_state", "get_engaged_posts", "get_find_leads_run", "get_inbox_thread", "get_linkedin_profile", "get_or_create_direct_campaign_table", "get_post_draft", "get_post_find_leads_scout_registry", "get_post_idea", "get_prospeo_credits", "get_provider_prompt", "get_published_post", "get_refill_target_plan", "get_rows", "get_rows_minimal", "get_runtime_identity", "get_scheduler_fill_capacity", "get_sender", "get_sender_routing", "get_source_scout_registry", "get_subskill_asset", "get_subskill_prompt", "get_table_rows", "get_user_posts", "get_workspace", "import_leads", "init_on_demand_sequence", "integrations_call_tool", "integrations_describe_tool", "integrations_list_tools", "list_column_types", "list_dnc_entries", "list_post_draft_iterations", "list_post_drafts", "list_post_ideas", "list_published_posts", "list_senders", "list_subskill_prompts", "list_tables", "list_workspaces", "load_csv_dnc_entries", "load_csv_domains", "load_csv_linkedin_leads", "lookup_sales_nav_filter", "mark_post_published", "migrate_flat_configs", "pause_campaign", "pause_direct_campaign", "pause_on_demand_campaign", "preflight_find_leads_provider", "prepare_campaign_ab_test", "queue_campaign_cells", "queue_cells", "record_campaign_review_batch", "record_engage_proven_search", "refill_sends", "refresh_paid_inmail_credits", "refresh_sender_engagement", "reissue_find_leads_watch_link", "render_linkedin_post_preview", "reorder_columns", "resolve_campaign_fill_route", "revise_message_template_and_rerun", "run_scheduler_sweep", "save_domain_filters", "save_hook_research", "save_post_draft", "save_rubrics", "search_apollo", "search_engagement_posts", "search_harvest_jobs", "search_inbox_threads", "search_prospeo", "search_prospeo_companies", "search_sales_nav", "search_signals", "search_subskill_prompts", "select_campaign_cells", "select_necessary_rubrics", "select_promising_posts", "send_inbox_draft", "send_inbox_manual_reply", "set_active_workspace", "set_campaign_waterfall_order", "set_company_info", "set_engage_state", "set_engage_style_guide", "set_headline_icp_criteria", "set_sender_calendar_link", "set_sender_routing", "setup_evergreen_campaigns", "start_campaign", "start_campaign_message_preparation", "start_cli_login", "start_direct_campaign", "start_on_demand_campaign", "update_campaign", "update_campaign_brief", "update_cell", "update_column", "update_find_leads_run", "update_inbox_draft", "update_post_draft", "update_published_post_metrics", "update_rubric_item", "upsert_engage_tracked_person", "upsert_rubric", "validate_campaign1_kickoff_handoff", "verify_table_row", "wait_for_campaign_processing", "wait_for_campaign_table_ready", "wait_for_cli_login", "wait_for_find_leads_run", "wait_for_lead_list_ready", "wait_for_rubric_results"];
+export declare const SELLABLE_MCP_TOOL_NAMES: readonly ["add_column", "add_on_demand_leads", "add_rubric_item", "add_teammate", "add_to_comment_campaign", "add_to_connection_campaign", "add_to_inmail_campaign", "archive_campaign", "attach_recommended_sequence", "attach_sequence", "bootstrap_create_campaign", "bootstrap_engage", "bootstrap_engage_multi", "bootstrap_find_leads", "bulk_enrich_with_prospeo", "calculate_linkedin_hook_preview", "cancel_campaign_message_preparation", "cancel_find_leads", "cancel_lead_import", "capture_post_idea", "check_inbox_reply_eligibility", "check_rubric", "commit_blueprint", "complete_sender_research", "confirm_harvest_job_companies", "confirm_lead_list", "confirm_prospeo_company_accounts", "copy_sender_config", "create_campaign", "create_on_demand_campaign", "create_on_demand_table", "create_workflow_table", "create_workspace", "delete_column", "delete_rubric_item", "draft_rubrics", "duplicate_campaign", "enrich_with_prospeo", "export_table_csv", "export_workspace_csv", "fetch_company", "fetch_company_posts", "fetch_linkedin_posts", "fetch_linkedin_profile", "fetch_post_engagers", "fill_campaign_horizon", "get_active_workspace", "get_auth_status", "get_campaign", "get_campaign_context", "get_campaign_framework", "get_campaign_message_preparation_status", "get_campaign_messages_preview", "get_campaign_navigation_state", "get_campaign_refill_state", "get_campaign_table_schema", "get_campaign_waterfall", "get_campaigns", "get_column_schema", "get_company_info", "get_engage_memory", "get_engage_state", "get_engaged_posts", "get_find_leads_run", "get_inbox_thread", "get_integration_connection_status", "get_linkedin_profile", "get_or_create_direct_campaign_table", "get_post_draft", "get_post_find_leads_scout_registry", "get_post_idea", "get_prospeo_credits", "get_provider_prompt", "get_published_post", "get_refill_target_plan", "get_rows", "get_rows_minimal", "get_runtime_identity", "get_scheduler_fill_capacity", "get_sender", "get_sender_routing", "get_source_scout_registry", "get_subskill_asset", "get_subskill_prompt", "get_table_rows", "get_user_posts", "get_workspace", "import_leads", "init_on_demand_sequence", "integrations_call_tool", "integrations_describe_tool", "integrations_list_tools", "list_column_types", "list_dnc_entries", "list_post_draft_iterations", "list_post_drafts", "list_post_ideas", "list_published_posts", "list_senders", "list_subskill_prompts", "list_tables", "list_workspaces", "load_csv_dnc_entries", "load_csv_domains", "load_csv_linkedin_leads", "lookup_sales_nav_filter", "mark_post_published", "migrate_flat_configs", "pause_campaign", "pause_direct_campaign", "pause_on_demand_campaign", "preflight_find_leads_provider", "prepare_campaign_ab_test", "queue_campaign_cells", "queue_cells", "record_campaign_review_batch", "record_engage_proven_search", "refill_sends", "refresh_paid_inmail_credits", "refresh_sender_engagement", "reissue_find_leads_watch_link", "render_linkedin_post_preview", "reorder_columns", "resolve_campaign_fill_route", "revise_message_template_and_rerun", "run_scheduler_sweep", "save_domain_filters", "save_hook_research", "save_post_draft", "save_rubrics", "search_apollo", "search_available_integrations", "search_engagement_posts", "search_harvest_jobs", "search_inbox_threads", "search_prospeo", "search_prospeo_companies", "search_sales_nav", "search_signals", "search_subskill_prompts", "select_campaign_cells", "select_necessary_rubrics", "select_promising_posts", "send_inbox_draft", "send_inbox_manual_reply", "set_active_workspace", "set_campaign_waterfall_order", "set_company_info", "set_engage_state", "set_engage_style_guide", "set_headline_icp_criteria", "set_sender_calendar_link", "set_sender_routing", "setup_evergreen_campaigns", "start_campaign", "start_campaign_message_preparation", "start_cli_login", "start_direct_campaign", "start_integration_connection", "start_on_demand_campaign", "update_campaign", "update_campaign_brief", "update_cell", "update_column", "update_find_leads_run", "update_inbox_draft", "update_post_draft", "update_published_post_metrics", "update_rubric_item", "upsert_engage_tracked_person", "upsert_rubric", "validate_campaign1_kickoff_handoff", "verify_table_row", "wait_for_campaign_processing", "wait_for_campaign_table_ready", "wait_for_cli_login", "wait_for_find_leads_run", "wait_for_lead_list_ready", "wait_for_rubric_results"];
 /**
  * Explicit mutation classification lives beside (but outside) the flat tool
  * registry. Neither this list nor `isMutatingTool` is an input to

package/dist/agent-tool-names.js

@@ -69,6 +69,7 @@ export const SELLABLE_MCP_TOOL_NAMES = [
     "get_engaged_posts",
     "get_find_leads_run",
     "get_inbox_thread",
+    "get_integration_connection_status",
     "get_linkedin_profile",
     "get_or_create_direct_campaign_table",
     "get_post_draft",
@@ -134,6 +135,7 @@ export const SELLABLE_MCP_TOOL_NAMES = [
     "save_post_draft",
     "save_rubrics",
     "search_apollo",
+    "search_available_integrations",
     "search_engagement_posts",
     "search_harvest_jobs",
     "search_inbox_threads",
@@ -160,6 +162,7 @@ export const SELLABLE_MCP_TOOL_NAMES = [
     "start_campaign_message_preparation",
     "start_cli_login",
     "start_direct_campaign",
+    "start_integration_connection",
     "start_on_demand_campaign",
     "update_campaign",
     "update_campaign_brief",

package/dist/server.js

@@ -41,6 +41,7 @@ import { bootstrapFindLeads, cancelFindLeads, getFindLeadsRun, reissueFindLeadsW
 import { getCampaignFramework } from "./tools/framework.js";
 import { confirmHarvestJobCompanies, searchHarvestJobs, } from "./tools/harvest-jobs.js";
 import { checkInboxReplyEligibility, getInboxThread, searchInboxThreads, sendInboxDraft, sendInboxManualReply, updateInboxDraft, } from "./tools/inbox.js";
+import { getIntegrationConnectionStatus, searchAvailableIntegrations, startIntegrationConnection, } from "./tools/integration-connect.js";
 import { integrationsCallTool, integrationsDescribeTool, integrationsListTools, } from "./tools/integrations.js";
 import { cancelLeadImport, confirmLeadList, confirmProspeoCompanyAccounts, getProviderPrompt, importLeads, listDncEntriesTool, loadCsvDncEntriesTool, loadCsvDomains, loadCsvLinkedinLeads, lookupSalesNavFilter, saveDomainFilters, searchApollo, searchProspeo, searchProspeoCompanies, searchSalesNav, searchSignals, selectPromisingPosts, setHeadlineICPCriteria, } from "./tools/leads.js";
 import { fetchCompany, fetchCompanyPosts, fetchLinkedInPosts, fetchLinkedInProfile, fetchPostEngagers, getLinkedInProfile, getUserPosts, } from "./tools/linkedin.js";
@@ -697,6 +698,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "integrations_call_tool":
                 result = await integrationsCallTool(args, integrationActor.context, agentEffectId);
                 break;
+            // Plan 142-05's connect trio. The same fail-closed actor guard above runs
+            // for these names via `isAgentIntegrationContextTool`'s second frozen set,
+            // so `integrationActor.context` is verified before any of these arms.
+            case "search_available_integrations":
+                result = await searchAvailableIntegrations(args, integrationActor.context, agentEffectId);
+                break;
+            case "start_integration_connection":
+                result = await startIntegrationConnection(args, integrationActor.context, agentEffectId);
+                break;
+            case "get_integration_connection_status":
+                result = await getIntegrationConnectionStatus(args, integrationActor.context, agentEffectId);
+                break;
             case "get_company_info":
                 result = await getCompanyInfoTool();
                 if (boundary.mode === "agent_service" &&

package/dist/tool-result-envelope.js

@@ -18,6 +18,15 @@ function isPlainObject(value) {
 export function toMcpToolResult(name, result) {
     const safeResult = sanitizeWatchUrlsForMcpResult(result);
     if (isStructuredToolResult(safeResult)) {
+        if (OUTPUT_SCHEMA_TOOL_NAMES.has(name) &&
+            safeResult.structuredContent === undefined &&
+            !safeResult.isError) {
+            // A HAND-BUILT `{ content }` is the one remaining way to reproduce the
+            // deviation, and nothing here can infer the payload it should have carried.
+            // FAIL CLOSED: `isError` is exempt from the client's validation, so the text
+            // is still delivered instead of the whole response being discarded.
+            return { ...safeResult, isError: true };
+        }
         return safeResult;
     }
     const content = [

package/dist/tools/integration-connect.d.ts

@@ -0,0 +1,23 @@
+import type { AgentIntegrationRequestContext } from "../agent-integration-request-context.js";
+import { type IntegrationsResultEnvelope } from "./integrations.js";
+type IntegrationConnectToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema: Record<string, unknown>;
+    annotations: Record<string, unknown>;
+};
+export declare const integrationConnectToolDefinitions: IntegrationConnectToolDefinition[];
+export declare function searchAvailableIntegrations(input?: {
+    query?: unknown;
+}, actor?: AgentIntegrationRequestContext | null, agentEffectId?: string): Promise<IntegrationsResultEnvelope>;
+export declare function startIntegrationConnection(input?: {
+    appSlug?: unknown;
+    trigger?: unknown;
+}, actor?: AgentIntegrationRequestContext | null, agentEffectId?: string): Promise<IntegrationsResultEnvelope>;
+type StatusInput = {
+    attemptId?: unknown;
+    appSlug?: unknown;
+};
+export declare function getIntegrationConnectionStatus(input?: StatusInput, actor?: AgentIntegrationRequestContext | null, agentEffectId?: string): Promise<IntegrationsResultEnvelope>;
+export {};

package/dist/tools/integration-connect.js

@@ -0,0 +1,570 @@
+import { getApi, SellableApiError } from "../api.js";
+import { envelope, INTEGRATIONS_ENVELOPE_OUTPUT_SCHEMA, toolError, } from "./integrations.js";
+/**
+ * 142-05 — the THREE Slack-facing connect tools: search, start, status.
+ *
+ * ## Why a second trio instead of extending the first
+ *
+ * At the moment a user says "connect Grain" there is no connection and no policy
+ * record to route a provider call through, so `integrations_list_tools` and its two
+ * siblings have nothing to act on. These three exist for exactly that gap, and they
+ * hand off to Phase 141's trio the instant a connection is real.
+ *
+ * ## ONE ENVELOPE ACROSS BOTH TRIOS (SA142-52)
+ *
+ * The modal conversation is "connect grain.com" -> connected -> "what can I do with
+ * it" -> list -> call, all in ONE Slack thread. A second envelope would make the
+ * Agent translate between two shapes mid-conversation. So this module IMPORTS Phase
+ * 141's published `INTEGRATIONS_ENVELOPE_OUTPUT_SCHEMA` and its `envelope()` /
+ * `toolError()` / `normalizeRouteResult()` builders rather than declaring
+ * look-alikes. The two `outcome` and `attribution` enums are CLOSED and validated by
+ * the MCP CLIENT, so a second copy that gained a member would make one trio's
+ * refusals unvalidatable while the other's passed.
+ *
+ * ## THE ATTRIBUTION MAPPING LIVES SERVER-SIDE, ON PURPOSE
+ *
+ * This phase's human-facing vocabulary has THREE members (`app`, `configuration`,
+ * `policy`); Phase 141's shipped envelope has FOUR (`provider`, `configuration`,
+ * `policy`, `sellable`) and says `provider` where this phase says `app`. The routes
+ * forward through `integrationConnectAttributionToEnvelope` in
+ * `src/lib/sellable-agent/integration-connect-contract.ts` BEFORE answering, because
+ * the MCP package cannot import `src/`. That is not a detail: an unmapped `app`
+ * arrives off-enum, `envelope()` clamps it fail-closed to `sellable`, and the
+ * operator loses WHO refused. This module therefore forwards `attribution` verbatim
+ * and does not re-derive it — there is exactly one mapping and it is not here.
+ *
+ * ## THE ACTOR IS NOT A TOOL INPUT
+ *
+ * No `inputSchema` below carries a requester, channel, or actor field, and this
+ * module DESIGNS NO ACTOR MECHANISM — it CONSUMES plan 141-04 T2's. The trusted
+ * triple arrives from `boundary.context` (which the MCP context proxy injects only
+ * after REJECTING any model-supplied `_meta` with `model_metadata_rejected`) and
+ * `server.ts` passes it here, where it becomes an explicit request BODY field the
+ * route re-verifies against `WorkspaceSlackIdentity`. A model-supplied actor claim
+ * is worthless, so the model is never offered a place to put one, and an absent
+ * actor is a REFUSAL rather than a default.
+ *
+ * ## NO MCP-SIDE ERROR-CODE LIST
+ *
+ * `toolError()` forwards the route's `error` string verbatim, so a hand-copied
+ * constant enumerating every connect error code would be a second maintained list
+ * the MCP never produces — the only possible source of drift. None is exported,
+ * and a source scan asserts the absence of any such constant by name.
+ *
+ * ## POLICY (142-05 T4), recorded where the tools are, not only in the plan
+ *
+ * These three use REGISTRY-FALLBACK AUTO and add NO `DEFAULT_AGENT_TOOL_CATALOGUE`
+ * entry, because `policyHash` is persisted on every `AgentServicePrincipal` and
+ * `AgentServiceCredentialVersion` and a catalogue entry would ROTATE EVERY LIVE
+ * CUSTOMER CREDENTIAL. The trade-off accepted: registry-fallback AUTO means no
+ * `REQUESTER_CONFIRM` gate on the tool call itself. That is defensible because the
+ * real consent gate is the OAuth screen the human completes in their OWN browser,
+ * on a link delivered by DM to exactly one principal, and because the derived
+ * binding is read-only-only with mutating tools DENY by default. These tools cannot
+ * themselves grant a provider action. If a future decision DOES want a gate on
+ * `start_integration_connection`, the correct route is a per-tool policy on the
+ * derived `AgentIntegrationBinding` (plan 142-06), not a catalogue entry.
+ */
+const SEARCH_PATH = "/api/v3/sellable-agent/integrations/search";
+const START_PATH = "/api/v3/sellable-agent/integrations/connect/start";
+const STATUS_PATH = "/api/v3/sellable-agent/integrations/connect/status";
+/**
+ * Client-side deadlines, sitting just above each route's own `maxDuration`, so the
+ * server's truthful error wins the race and this bound only fires when the server
+ * never answered at all. Copied in intent from `integrations.ts`.
+ */
+const SEARCH_TIMEOUT_MS = 25_000;
+const START_TIMEOUT_MS = 35_000;
+const STATUS_TIMEOUT_MS = 15_000;
+/**
+ * RESTATED from `APP_QUERY_BOUNDS` in
+ * `src/lib/sellable-agent/integration-app-resolution.ts` because the MCP package
+ * cannot import `src/`. The SERVER is still the authority — it re-validates and
+ * normalizes every value — so a divergence here can only ever be stricter in
+ * practice, never a bypass.
+ */
+const QUERY_MIN = 2;
+const QUERY_MAX = 200;
+const SLUG_MIN = 1;
+const SLUG_MAX = 64;
+const SLUG_PATTERN = /^[a-z0-9_-]+$/i;
+const CONNECT_TRIGGERS = ["explicit_request", "not_connected_offer"];
+/** The five DISTINCT search outcomes. `no_tools` and `catalog_incomplete` are not
+ * the same answer and must never be collapsed (SA142-46). */
+const SEARCH_KINDS = [
+    "resolved",
+    "ambiguous",
+    "not_found",
+    "no_tools",
+    "catalog_incomplete",
+];
+/** The contract's `IntegrationConnectionStatusResult.state` union. */
+const CONNECTION_STATES = [
+    "awaiting_user",
+    "connected",
+    "refused",
+    "expired",
+    "not_found",
+];
+/**
+ * Phase 141's ENVELOPE with a per-tool `result` sub-schema. The envelope keys, the
+ * two closed enums, and the fail-closed clamp all stay 141's — spread from the ONE
+ * exported schema object rather than re-declared — while the `result` branch names
+ * this tool's own success vocabulary so a client (and a reader) can see what
+ * `awaiting_user` or `no_tools` means without leaving the definition. Every
+ * property stays PERMISSIVE (`additionalProperties: true`, no `required`): the
+ * SDK client validates `structuredContent` against this schema, and a schema that
+ * rejects a real answer is an outage, not a documentation nicety.
+ */
+function connectEnvelopeSchema(resultSchema) {
+    return {
+        ...INTEGRATIONS_ENVELOPE_OUTPUT_SCHEMA,
+        properties: {
+            ...INTEGRATIONS_ENVELOPE_OUTPUT_SCHEMA.properties,
+            result: {
+                anyOf: [
+                    {
+                        type: "null",
+                        description: "On refusal the reason travels in `error` and `guidance`; `result` is null.",
+                    },
+                    { type: "object", ...resultSchema, additionalProperties: true },
+                ],
+            },
+        },
+    };
+}
+const SEARCH_OUTPUT_SCHEMA = connectEnvelopeSchema({
+    properties: {
+        kind: {
+            type: "string",
+            enum: [...SEARCH_KINDS],
+            description: "Which of the five DISTINCT search answers this is. `no_tools` means the app genuinely publishes no actions; `catalog_incomplete` means the catalog could not be read completely — never treat them as the same.",
+        },
+        app: {
+            type: "object",
+            description: "The single resolved app, present when kind is `resolved`.",
+            additionalProperties: true,
+        },
+        options: {
+            type: "array",
+            description: "Up to three candidates when kind is `ambiguous`; ask the user which one they meant.",
+            items: {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    description: { type: ["string", "null"] },
+                    iconUrl: { type: ["string", "null"] },
+                    authType: { type: ["string", "null"] },
+                },
+                additionalProperties: true,
+            },
+        },
+    },
+});
+const START_OUTPUT_SCHEMA = connectEnvelopeSchema({
+    properties: {
+        status: {
+            type: "string",
+            enum: ["awaiting_user"],
+            description: "The ONLY success status. It means the DM was sent — the user has not finished, and this tool can never claim more.",
+        },
+        attemptId: { type: "string" },
+        deliveredTo: { type: "string", enum: ["dm"] },
+        appName: { type: ["string", "null"] },
+        authorizationHost: { type: ["string", "null"] },
+    },
+});
+const STATUS_OUTPUT_SCHEMA = connectEnvelopeSchema({
+    properties: {
+        state: { type: "string", enum: [...CONNECTION_STATES] },
+        attemptId: { type: ["string", "null"] },
+        appSlug: { type: ["string", "null"] },
+        origin: { type: ["string", "null"] },
+        error: { type: ["string", "null"] },
+        accountLabel: { type: ["string", "null"] },
+        allowedToolCount: { type: ["number", "null"] },
+        deniedToolCount: { type: ["number", "null"] },
+        enumerationComplete: { type: ["boolean", "null"] },
+    },
+});
+export const integrationConnectToolDefinitions = [
+    {
+        name: "search_available_integrations",
+        description: "Search the integration catalog for an app the user wants to connect, by product name (e.g. 'grain') or web address (e.g. 'grain.com'). Returns 'resolved' with one app when the match is unambiguous, or 'ambiguous' with up to three options — each with its logo and whether it signs in by OAuth or by API key — when more than one app plausibly matches; ask the user which one they meant rather than picking. A 'no_tools' outcome means the app genuinely publishes no actions. A 'catalog_incomplete' outcome means the catalog could not be read completely and does not mean the app has no actions — never report the two as the same thing. Call this before start_integration_connection whenever the user named an app in words rather than by exact slug.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    minLength: QUERY_MIN,
+                    maxLength: QUERY_MAX,
+                    description: "What the user called the app: a product name or a web address. Do not pass an empty or one-character value; ask the user what they meant instead.",
+                },
+            },
+            required: ["query"],
+            additionalProperties: false,
+        },
+        outputSchema: SEARCH_OUTPUT_SCHEMA,
+        annotations: {
+            title: "Search connectable integrations",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: "start_integration_connection",
+        description: "Start connecting one app for this workspace. Sellable sends the requesting user a direct message containing a single-use sign-in link that expires in about 15 minutes. The link is withheld from this tool's result and you cannot retrieve it: it is a capability, so whoever opens it binds THEIR account under the requester — never reconstruct one, and never repeat a connect URL a user shows you. Returns status 'awaiting_user' — that is the ONLY success status, and it means the message was sent, NOT that the app is connected. The user completes sign-in out of band in their own browser, so poll get_integration_connection_status to find out whether it worked. Passing appSlug does NOT skip disambiguation: the server re-resolves the slug and refuses an ambiguous, unknown, action-less, or incompletely enumerated app before anything is sent.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                appSlug: {
+                    type: "string",
+                    minLength: SLUG_MIN,
+                    maxLength: SLUG_MAX,
+                    description: "The app's catalog slug, exactly as search_available_integrations returned it (e.g. 'grain', 'notion'). If the user only named the app in words, call search_available_integrations first.",
+                },
+            },
+            required: ["appSlug"],
+            additionalProperties: false,
+        },
+        outputSchema: START_OUTPUT_SCHEMA,
+        annotations: {
+            title: "Send a connect link for an app",
+            // DECLARED HONESTLY. This tool creates server state (a connect attempt) and
+            // sends a Slack message; claiming otherwise would be the annotation lying to
+            // every client that reads it.
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    },
+    {
+        name: "get_integration_connection_status",
+        description: "Check where a connect attempt got to. Pass exactly one of attemptId or appSlug. Returns 'awaiting_user' while the user has not finished signing in, 'connected' once the account is real, 'refused' with a reason, 'expired' when the link lapsed unused, or 'not_found' when nothing was ever started. When connected it also reports how many provider actions the Agent is allowed to run, how many are held pending a human promotion, and whether the action catalog was read completely — so zero allowed actions with a complete read is a truthful 'there is nothing I can do with this yet', while an incomplete read is not.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                attemptId: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 128,
+                    description: "The attempt id returned by start_integration_connection. Use this when you have it; it is exact.",
+                },
+                appSlug: {
+                    type: "string",
+                    minLength: SLUG_MIN,
+                    maxLength: SLUG_MAX,
+                    description: "The app's catalog slug, which resolves to the most recent attempt for that app. Use this when the attempt id is not to hand.",
+                },
+            },
+            // Neither is individually required and exactly one must be present, which a
+            // JSON Schema `required` array cannot express; the handler enforces it and
+            // refuses before any request.
+            required: [],
+            additionalProperties: false,
+        },
+        outputSchema: STATUS_OUTPUT_SCHEMA,
+        annotations: {
+            title: "Check a connect attempt",
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    },
+];
+/**
+ * The trusted triple, forwarded as EXPLICIT BODY FIELDS.
+ *
+ * The `Bearer sat_` middleware branch OVERWRITES `X-authuserid` from
+ * `AgentServicePrincipal.subjectUserId` and DELETES every caller-supplied
+ * `x-sellable-*` header, so the backend never sees the Slack requester any other
+ * way. A header would be stripped; this is why it has to be a body field.
+ */
+function actorBody(actor) {
+    return {
+        slackRequesterId: actor.requesterId,
+        slackChannelId: actor.channelId,
+        providerRequestId: actor.providerRequestId,
+    };
+}
+/** FAILS CLOSED. An absent actor is a refusal, never a synthetic default. */
+function requireActor(actor) {
+    if (!actor?.requesterId || !actor.channelId || !actor.providerRequestId) {
+        return {
+            ok: false,
+            envelope: envelope({
+                ok: false,
+                outcome: "refused",
+                attribution: "configuration",
+                error: "agent_request_context_required",
+                guidance: "I could not tell which Slack conversation this request came from, so I did nothing. Ask me again in a channel where I am installed.",
+            }),
+        };
+    }
+    return { ok: true, actor };
+}
+function refuse(error, guidance, attribution = "configuration") {
+    return envelope({
+        ok: false,
+        outcome: "refused",
+        attribution,
+        error,
+        guidance,
+    });
+}
+/**
+ * The 142 connect routes answer a FULL envelope — `ok`, `outcome`, `attribution`,
+ * `error`, `guidance`, and an explicit `result` key — unlike Phase 141's serving
+ * routes, whose payload keys travel at the top level and are gathered by
+ * `normalizeRouteResult`. Reusing that gatherer here would re-nest the route's
+ * `result` one level down (`result.result`), so this normalizer reads the envelope
+ * keys by name and forwards `result` as-is, still through the ONE `envelope()`
+ * clamp so an off-enum value normalizes identically across both trios.
+ */
+function normalizeConnectRouteResult(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return envelope({
+            ok: false,
+            error: "integration_response_malformed",
+            guidance: "The Sellable integrations API returned an unexpected shape. Retry after refreshing the Sellable MCP package.",
+        });
+    }
+    const record = value;
+    return envelope({
+        ok: record.ok === true,
+        outcome: typeof record.outcome === "string" ? record.outcome : undefined,
+        attribution: typeof record.attribution === "string" ? record.attribution : undefined,
+        error: typeof record.error === "string" ? record.error : null,
+        guidance: typeof record.guidance === "string" ? record.guidance : null,
+        result: withoutModelFacingHandle(record.result),
+    });
+}
+/**
+ * The single-use handle URL is a CAPABILITY: whoever opens it binds THEIR
+ * provider account under the requesting principal. Sellable delivers it to the
+ * requester by direct message server-side, so nothing downstream of this
+ * boundary needs it — and a model that holds it can paste it into a channel,
+ * where the next person to click becomes the connected account.
+ *
+ * The field is legitimate on the HTTP result: the browser mint path renders it,
+ * and the end-to-end seam driver reads it from the route to continue the flow.
+ * This strips it only where the model can see, which is the boundary that
+ * matters. Removing it from the route instead would break both of those.
+ *
+ * Recorded by phase 142 verification: the shape was mirrored from the phase 141
+ * UI mint, where the browser genuinely needs the URL. On the Slack path it was
+ * never load-bearing, and the tool description asserted the model could not see
+ * it while the response handed it over.
+ */
+function withoutModelFacingHandle(result) {
+    if (!result || typeof result !== "object" || Array.isArray(result)) {
+        return result ?? null;
+    }
+    const { connectHandleUrl: _withheld, ...rest } = result;
+    return rest;
+}
+function validateSlug(value, error) {
+    if (typeof value !== "string" ||
+        value.length < SLUG_MIN ||
+        value.length > SLUG_MAX ||
+        !SLUG_PATTERN.test(value)) {
+        return {
+            ok: false,
+            envelope: refuse(error, `appSlug must be ${SLUG_MIN}-${SLUG_MAX} characters of letters, digits, hyphen, or underscore, exactly as search_available_integrations returned it.`),
+        };
+    }
+    return { ok: true, slug: value };
+}
+export async function searchAvailableIntegrations(input = {}, actor, agentEffectId) {
+    const gate = requireActor(actor);
+    if (!gate.ok)
+        return gate.envelope;
+    const query = input.query;
+    if (typeof query !== "string" ||
+        query.length < QUERY_MIN ||
+        query.length > QUERY_MAX) {
+        // BEFORE any API call, deliberately: an empty or one-character query
+        // normalizes to something the catalog answers with a full-catalogue page,
+        // whose top slice always looks ambiguous — so the Agent would offer three
+        // arbitrary apps as if they were candidates.
+        return refuse("integration_app_query_rejected", `Tell me the app name in ${QUERY_MIN}-${QUERY_MAX} characters, for example "grain" or "grain.com".`);
+    }
+    try {
+        const response = await getApi().post(SEARCH_PATH, { query, ...actorBody(gate.actor) }, {
+            timeoutMs: SEARCH_TIMEOUT_MS,
+            ...(agentEffectId ? { agentEffectId } : {}),
+        });
+        return normalizeConnectRouteResult(response);
+    }
+    catch (error) {
+        return toolError("app_search", error);
+    }
+}
+export async function startIntegrationConnection(input = {}, actor, agentEffectId) {
+    const gate = requireActor(actor);
+    if (!gate.ok)
+        return gate.envelope;
+    const slug = validateSlug(input.appSlug, "integration_app_slug_rejected");
+    if (!slug.ok)
+        return slug.envelope;
+    // BOTH conversational doors converge on ONE mint. `trigger` is the only thing
+    // that differs between "connect Grain" and "you have no Grain account, shall
+    // I connect it" — and the route changes nothing else because of it.
+    const trigger = input.trigger === undefined || input.trigger === null
+        ? "explicit_request"
+        : input.trigger;
+    if (!CONNECT_TRIGGERS.includes(trigger)) {
+        return refuse("integration_connect_trigger_rejected", `trigger must be one of ${CONNECT_TRIGGERS.join(", ")}.`);
+    }
+    try {
+        const response = await getApi().post(START_PATH, { appSlug: slug.slug, trigger, ...actorBody(gate.actor) }, {
+            timeoutMs: START_TIMEOUT_MS,
+            ...(agentEffectId ? { agentEffectId } : {}),
+        });
+        // The route answers `{status:"awaiting_user", attemptId, deliveredTo, appName,
+        // authorizationHost}` and never a credential. `awaiting_user` is the ONLY
+        // success status the route can express, so there is nothing to clamp here:
+        // the type on both sides simply cannot say `connected`. The `appSlug` argument
+        // is a CONVENIENCE, NOT AN AUTHORITY — the route re-resolves it server-side
+        // and refuses ambiguous, unknown, action-less and incompletely enumerated apps
+        // before minting anything.
+        return normalizeConnectRouteResult(response);
+    }
+    catch (error) {
+        return toolError("connect_start", error);
+    }
+}
+function statusState(raw) {
+    const status = typeof raw.status === "string" ? raw.status : "";
+    if (status === "reconciled" || status === "attached")
+        return "connected";
+    if (status === "refused" || status === "failed")
+        return "refused";
+    // There is no `expired` attempt status: expiry is `expiresAt` in the past on a
+    // row nobody has swept yet, so it is DERIVED rather than read.
+    const expiresAt = typeof raw.expiresAt === "string" ? Date.parse(raw.expiresAt) : NaN;
+    if (status === "ready" &&
+        Number.isFinite(expiresAt) &&
+        expiresAt <= Date.now()) {
+        return "expired";
+    }
+    return "awaiting_user";
+}
+function readCount(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+/**
+ * The status route is a plain read route with its OWN body shape (142-04 T5 owns
+ * it), not an envelope producer. Adapting it here rather than reshaping that route
+ * keeps 142-04's tested contract intact and keeps the adaptation in one place.
+ */
+function statusEnvelope(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return envelope({
+            ok: false,
+            outcome: "refused",
+            attribution: "sellable",
+            error: "integration_response_malformed",
+            guidance: "The Sellable connect status API returned an unexpected shape. Retry after refreshing the Sellable MCP package.",
+        });
+    }
+    const record = raw;
+    const state = statusState(record);
+    const enumerationComplete = typeof record.enumerationComplete === "boolean"
+        ? record.enumerationComplete
+        : null;
+    const result = {
+        state,
+        attemptId: typeof record.attemptId === "string" ? record.attemptId : null,
+        appSlug: typeof record.resolvedAppSlug === "string"
+            ? record.resolvedAppSlug
+            : typeof record.appSlug === "string"
+                ? record.appSlug
+                : null,
+        origin: typeof record.origin === "string" ? record.origin : null,
+        error: typeof record.errorCode === "string" ? record.errorCode : null,
+        accountLabel: typeof record.accountLabel === "string" ? record.accountLabel : null,
+        allowedToolCount: readCount(record.allowedToolCount),
+        // The phase's own vocabulary for "pending a human promotion": every DENY'd
+        // tool IS a pending promotion, which is why `tool_approval_required` is
+        // documented as a POINTER at one rather than a terminal failure. A fourth
+        // counter would be a name with no table behind it.
+        deniedToolCount: readCount(record.deniedToolCount),
+        enumerationComplete,
+    };
+    // SA142-46 — a truncated enumeration is reported as its OWN outcome so the Agent
+    // can never say "this app has no tools" about an app it failed to read. The
+    // provider's default actions page returns 10 of Gmail's 22 actions and omits its
+    // only search action, so the two answers are not interchangeable.
+    const incomplete = state === "connected" && enumerationComplete === false;
+    return envelope({
+        ok: true,
+        outcome: incomplete ? "catalog_incomplete" : "ok",
+        attribution: "policy",
+        result,
+    });
+}
+export async function getIntegrationConnectionStatus(input = {}, actor, agentEffectId) {
+    // Required for UNIFORMITY with its two siblings even though the route scopes by
+    // the authenticated principal rather than by a body field: the tool-name set that
+    // drives the fail-closed guard is one set, so a future status variant cannot
+    // quietly opt out of it. Nothing is forwarded — putting a Slack user id in a
+    // query string would write it into every access log on the path.
+    const gate = requireActor(actor);
+    if (!gate.ok)
+        return gate.envelope;
+    const hasAttempt = typeof input.attemptId === "string" && input.attemptId.length > 0;
+    const hasSlug = typeof input.appSlug === "string" && input.appSlug.length > 0;
+    if (hasAttempt === hasSlug) {
+        return refuse("integration_status_selector_required", "Pass exactly one of attemptId or appSlug. Both would be ambiguous and neither would be a lookup.");
+    }
+    if (hasAttempt) {
+        const attemptId = input.attemptId;
+        if (attemptId.length > 128) {
+            return refuse("integration_status_selector_required", "attemptId must be 1-128 characters.");
+        }
+    }
+    else {
+        const slug = validateSlug(input.appSlug, "integration_status_selector_required");
+        if (!slug.ok)
+            return slug.envelope;
+    }
+    const query = hasAttempt
+        ? `attemptId=${encodeURIComponent(input.attemptId)}`
+        : `appSlug=${encodeURIComponent(input.appSlug)}`;
+    try {
+        const response = await getApi().get(`${STATUS_PATH}?${query}`, {
+            timeoutMs: STATUS_TIMEOUT_MS,
+            ...(agentEffectId ? { agentEffectId } : {}),
+        });
+        return statusEnvelope(response);
+    }
+    catch (error) {
+        // A 404 is an ANSWER, not a fault: "nothing was ever started for this app" is
+        // something the Agent should say plainly rather than reporting as a system
+        // error the user cannot act on.
+        if (error instanceof SellableApiError && error.status === 404) {
+            return envelope({
+                ok: true,
+                outcome: "ok",
+                attribution: "policy",
+                result: {
+                    state: "not_found",
+                    attemptId: null,
+                    appSlug: null,
+                    origin: null,
+                    error: null,
+                    accountLabel: null,
+                    allowedToolCount: null,
+                    deniedToolCount: null,
+                    enumerationComplete: null,
+                },
+            });
+        }
+        return toolError("connect_status", error);
+    }
+}

package/dist/tools/integrations.d.ts

@@ -96,6 +96,39 @@ type IntegrationHomeWorkspacePin = {
  * authorization boundary and must not replace the server refusal.
  */
 export declare function resolveIntegrationHomeWorkspacePin(env?: NodeJS.ProcessEnv, token?: string): IntegrationHomeWorkspacePin;
+/**
+ * EXPORTED for plan 142-05's connect trio (SA142-52), which must declare the SAME
+ * schema object rather than a look-alike copy. The two `enum` arrays below are
+ * CLOSED and the MCP client validates against them, so a second copy that gained
+ * a member would make one trio's refusals unvalidatable while the other's passed.
+ * Exporting is what makes "mirror this envelope" mechanically true instead of a
+ * comment. Nothing about this object changed when it was exported.
+ */
+export declare const INTEGRATIONS_ENVELOPE_OUTPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly ok: {
+            readonly type: "boolean";
+        };
+        readonly outcome: {
+            readonly type: "string";
+            readonly enum: readonly ["ok", "refused", "approval_required", "catalog_incomplete", "not_connected", "upstream_degraded"];
+        };
+        readonly attribution: {
+            readonly type: "string";
+            readonly enum: readonly ["provider", "configuration", "policy", "sellable"];
+        };
+        readonly error: {
+            readonly type: readonly ["string", "null"];
+        };
+        readonly guidance: {
+            readonly type: readonly ["string", "null"];
+        };
+        readonly result: {};
+    };
+    readonly required: readonly ["ok", "outcome", "attribution", "error", "guidance", "result"];
+    readonly additionalProperties: false;
+};
 export declare const integrationsToolDefinitions: ({
     name: string;
     description: string;
@@ -327,6 +360,23 @@ type SelectorInput = {
     bindingId?: unknown;
     accountLabel?: unknown;
 };
+/**
+ * EXPORTED for the connect trio, same reason as the schema above: one builder owns
+ * the fail-closed clamp of both closed enums, so a connect refusal and an
+ * `integrations_*` refusal cannot normalize differently.
+ */
+export declare function envelope(value: Partial<IntegrationsResultEnvelope> & {
+    ok: boolean;
+}): IntegrationsResultEnvelope;
+/**
+ * Errors are RETURNED, never thrown, and the route's `error` is forwarded VERBATIM.
+ *
+ * No MCP-side error-code list is exported: this helper forwards whatever the route
+ * said, so a hand-copied list would be a second maintained list the MCP never
+ * produces. Copied in shape from `company-info.ts:96-125`.
+ */
+export declare function toolError(action: string, error: unknown): IntegrationsResultEnvelope;
+export declare function normalizeRouteResult(value: unknown): IntegrationsResultEnvelope;
 export declare function integrationsListTools(input?: SelectorInput, actor?: AgentIntegrationRequestContext | null, agentEffectId?: string): Promise<IntegrationsResultEnvelope>;
 export declare function integrationsDescribeTool(input?: SelectorInput & {
     toolName?: unknown;

package/dist/tools/integrations.js

@@ -143,7 +143,15 @@ const SELECTOR_PROPERTIES = {
         description: "The human label the user gave the connected account. This is the ONLY way to tell two connections over the same inbox apart, because the provider's own account name can be byte-identical for both.",
     },
 };
-const ENVELOPE_OUTPUT_SCHEMA = {
+/**
+ * EXPORTED for plan 142-05's connect trio (SA142-52), which must declare the SAME
+ * schema object rather than a look-alike copy. The two `enum` arrays below are
+ * CLOSED and the MCP client validates against them, so a second copy that gained
+ * a member would make one trio's refusals unvalidatable while the other's passed.
+ * Exporting is what makes "mirror this envelope" mechanically true instead of a
+ * comment. Nothing about this object changed when it was exported.
+ */
+export const INTEGRATIONS_ENVELOPE_OUTPUT_SCHEMA = {
     type: "object",
     properties: {
         ok: { type: "boolean" },
@@ -179,7 +187,7 @@ export const integrationsToolDefinitions = [
             required: [],
             additionalProperties: false,
         },
-        outputSchema: ENVELOPE_OUTPUT_SCHEMA,
+        outputSchema: INTEGRATIONS_ENVELOPE_OUTPUT_SCHEMA,
         annotations: {
             title: "List allowed integration actions",
             readOnlyHint: true,
@@ -217,7 +225,7 @@ export const integrationsToolDefinitions = [
             required: ["toolName"],
             additionalProperties: false,
         },
-        outputSchema: ENVELOPE_OUTPUT_SCHEMA,
+        outputSchema: INTEGRATIONS_ENVELOPE_OUTPUT_SCHEMA,
         annotations: {
             title: "Describe an allowed integration action",
             // Resolving options is a READ: `components/configure` creates no provider
@@ -256,7 +264,7 @@ export const integrationsToolDefinitions = [
             required: ["toolName"],
             additionalProperties: false,
         },
-        outputSchema: ENVELOPE_OUTPUT_SCHEMA,
+        outputSchema: INTEGRATIONS_ENVELOPE_OUTPUT_SCHEMA,
         annotations: {
             title: "Run an allowed integration action",
             /**
@@ -280,7 +288,7 @@ export const integrationsToolDefinitions = [
  * The two CLOSED enums, read off the declared `outputSchema` so there is one source.
  *
  * `outcome` and `attribution` are validated by the MCP CLIENT against
- * `ENVELOPE_OUTPUT_SCHEMA` (`@modelcontextprotocol/sdk` runs ajv over
+ * `INTEGRATIONS_ENVELOPE_OUTPUT_SCHEMA` (`@modelcontextprotocol/sdk` runs ajv over
  * `structuredContent`; the python SDK does the same via `jsonschema`). An off-enum
  * value therefore does not degrade the envelope — it makes the client reject the
  * WHOLE response, so the operator loses the refusal AND its reason.
@@ -291,9 +299,14 @@ export const integrationsToolDefinitions = [
  * normalized FAIL-CLOSED to a refusal by `sellable`, while the route's `error` code —
  * the field that actually carries the reason — is still forwarded verbatim.
  */
-const ENVELOPE_OUTCOMES = ENVELOPE_OUTPUT_SCHEMA.properties.outcome.enum;
-const ENVELOPE_ATTRIBUTIONS = ENVELOPE_OUTPUT_SCHEMA.properties.attribution.enum;
-function envelope(value) {
+const ENVELOPE_OUTCOMES = INTEGRATIONS_ENVELOPE_OUTPUT_SCHEMA.properties.outcome.enum;
+const ENVELOPE_ATTRIBUTIONS = INTEGRATIONS_ENVELOPE_OUTPUT_SCHEMA.properties.attribution.enum;
+/**
+ * EXPORTED for the connect trio, same reason as the schema above: one builder owns
+ * the fail-closed clamp of both closed enums, so a connect refusal and an
+ * `integrations_*` refusal cannot normalize differently.
+ */
+export function envelope(value) {
     const outcome = value.outcome ?? (value.ok ? "ok" : "refused");
     const attribution = value.attribution ?? (value.ok ? "policy" : "sellable");
     return {
@@ -318,7 +331,7 @@ function envelope(value) {
  * said, so a hand-copied list would be a second maintained list the MCP never
  * produces. Copied in shape from `company-info.ts:96-125`.
  */
-function toolError(action, error) {
+export function toolError(action, error) {
     if (error instanceof SellableApiError) {
         let forwarded = {};
         try {
@@ -434,7 +447,7 @@ function actorBody(actor) {
         providerRequestId: actor.providerRequestId,
     };
 }
-function normalizeRouteResult(value) {
+export function normalizeRouteResult(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return envelope({
             ok: false,

package/dist/tools/registry.d.ts

@@ -8765,6 +8765,12 @@ export declare const allTools: ({
         idempotentHint: boolean;
         openWorldHint: boolean;
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema: Record<string, unknown>;
+    annotations: Record<string, unknown>;
 } | {
     name: string;
     description: string;

package/dist/tools/registry.js

@@ -27,6 +27,7 @@ import { findLeadsRunToolDefinitions } from "./find-leads-runs.js";
 import { frameworkToolDefinitions } from "./framework.js";
 import { harvestJobToolDefinitions } from "./harvest-jobs.js";
 import { inboxToolDefinitions } from "./inbox.js";
+import { integrationConnectToolDefinitions } from "./integration-connect.js";
 import { integrationsToolDefinitions } from "./integrations.js";
 import { leadToolDefinitions } from "./leads.js";
 import { linkedinToolDefinitions } from "./linkedin.js";
@@ -83,10 +84,11 @@ export const allTools = [
     ...leadToolDefinitions,
     ...harvestJobToolDefinitions,
     ...inboxToolDefinitions,
-    // Phase 142 plan 142-05 adds its three CONNECT tools to this same array.
-    // 141 merges first, so 142 is additive; neither plan owns this file exclusively
-    // and neither may reorder the other's entries.
+    // Phase 142 plan 142-05's three CONNECT tools sit beside 141-06's
+    // `integrations_*` trio. Neither plan owns this file exclusively and neither
+    // may reorder the other's entries.
     ...integrationsToolDefinitions,
+    ...integrationConnectToolDefinitions,
     ...enrichmentToolDefinitions,
     ...processingToolDefinitions,
     ...rubricToolDefinitions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.769",
+  "version": "0.1.770",
   "type": "module",
   "description": "Sellable MCP server for Claude Code, Codex, and Hermes campaign workflows",
   "main": "dist/index.js",