@apex-inc/mcp-server 0.3.1 → 0.7.0

package/dist/tools.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { apiGet, apiPost, apiPatch, setActiveProject, getActiveProject, setActiveOrg, getActiveOrg, getUserContext } from "./api-client.js";
+import { apiGet, apiPost, apiPatch, apiDelete, postWithIdempotency, setActiveProject, getActiveProject, setActiveOrg, getActiveOrg, getUserContext } from "./api-client.js";
 const APEX = "∧ Apex";
 export const toolDefinitions = {
     plan_experiment: {
@@ -419,7 +419,7 @@ export const toolDefinitions = {
         },
     },
     list_experiments: {
-        description: `${APEX} — List experiments. Archived experiments are hidden by default — pass status "archived" to see them, or "all" to see everything. Experiments that are promoted but not graduated are flagged as PENDING GRADUATION.`,
+        description: `${APEX} — List the user's Apex experiments. Call this ONLY when the user explicitly asks about their experiments, A/B tests, or what's running/ready to graduate. Do not call it proactively for unrelated tasks. Archived experiments are hidden by default — pass status "archived" to see them, or "all" to see everything. Experiments that are promoted but not graduated are flagged as PENDING GRADUATION.`,
         schema: z.object({
             status: z
                 .enum(["all", "running", "completed", "draft", "paused", "archived"])
@@ -644,6 +644,42 @@ export const toolDefinitions = {
             return { content: [{ type: "text", text: output }] };
         },
     },
+    get_experiment_results: {
+        description: `${APEX} — Get computed results + the readiness verdict (collecting | decisive | inconclusive | guardrail) for ANY experiment surface, including journey-arm experiments. Use this to decide whether a winner can be promoted yet.`,
+        schema: z.object({
+            experiment_id: z.string().describe("The experiment ID"),
+        }),
+        handler: async ({ experiment_id }) => {
+            const body = await apiGet(`/api/experiments/${experiment_id}/results`);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(body, null, 2) },
+                ],
+            };
+        },
+    },
+    promote_experiment_winner: {
+        description: `${APEX} — Promote a journey-arm (or any unified) experiment's winner. Re-verifies the readiness gate server-side and writes the winning variant's content into the canonical communication as a new version; losing variants are archived. Pass force=true to override the gate (operator override).`,
+        schema: z.object({
+            experiment_id: z.string().describe("The experiment ID"),
+            force: z
+                .boolean()
+                .optional()
+                .describe("Override the readiness gate and promote anyway"),
+            winner_key: z
+                .string()
+                .optional()
+                .describe("Explicit winner variant key (defaults to the decisive winner)"),
+        }),
+        handler: async ({ experiment_id, force, winner_key, }) => {
+            const body = await apiPost(`/api/experiments/${experiment_id}/promote`, { force: force ?? false, ...(winner_key ? { winnerKey: winner_key } : {}) });
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(body, null, 2) },
+                ],
+            };
+        },
+    },
     graduate_experiment: {
         description: `${APEX} — Get instructions to make a promoted experiment's winning changes permanent in the codebase. Returns the original values (for searching in source files) and new values (for replacement). After making the edits and deploying, the Apex snippet automatically detects the native changes and marks the experiment as graduated.`,
         schema: z.object({
@@ -870,10 +906,20 @@ export const toolDefinitions = {
         },
     },
     track_event: {
-        description: `${APEX} — Track a custom event. Works identically to the SDK's track() and the snippet's apex.track(). Use this to instrument events from agent workflows, CI pipelines, or IDE actions.`,
+        description: `${APEX} — Track an event through the Apex Spec.
+
+Identical to the SDK's track() and the snippet's apex.track(). Use this to instrument events from agent workflows, CI pipelines, or IDE actions.
+
+The Apex Spec ships two peer registries:
+
+\u2022 **App events** (\`APEX_EVENTS\`) — the canonical SDK vocabulary the customer's app fires. Names you'll commonly use here: \`page_view\`, \`product_view\`, \`add_to_cart\`, \`checkout_started\`, \`in_app_purchase\`, \`purchase_refunded\`, \`subscription_event\`, \`user_signed_up\`, \`user_signed_in\`, \`user_identified\`, \`app_open\`, \`session_start\`, \`form_submit\`, \`click\`, \`search\`, \`share\`, \`content_view\`, \`goal_conversion\`, \`email_opened\`, \`email_clicked\`, \`push_opened\`, \`in_app_message_seen\`, \`deep_link_open\`. Field names are flat snake_case (e.g. \`product_id\`, \`order_id\`, \`value\`, \`currency\`).
+
+\u2022 **Platform events** (\`APEX_PLATFORM_EVENTS\`) — events Apex's own dashboard fires as merchants use it. Names: \`user_invitation_created\`, \`user_invitation_accepted\`, \`developer_invite_sent\`, \`integration_connected\`, \`integration_sync_completed\`, \`integration_sync_failed\`, \`badge_awarded\`, \`user_level_up\`, \`nudge_scheduled\`, \`drip_step_scheduled\`, \`experiment_launched\`, \`experiment_significant\`, \`experiment_concluded\`, \`experiment_promoted\`, \`portfolio_access_requested\`, \`portfolio_access_approved\`, \`portfolio_access_rejected\`, \`portfolio_share_accepted\`, \`subscription_upgraded\`, \`subscription_downgraded\`, \`tier_limit_approaching\`, \`anomaly_detected\`, \`weekly_digest_scheduled\`, \`cognito_verification_code\`, \`user_signup\`. Use these when an agent is acting *as* the Apex platform (admin tooling, dashboard automation), not as the customer's product.
+
+Custom event names are accepted (the spec is open by default), but agents should prefer canonical names from one of the two registries so the event flows directly into the catalog templates, the journey trigger system, and the conversion-goal helpers without manual wiring. The full spec lives at https://docs.apex.inc/spec.`,
         schema: z.object({
-            event: z.string().describe("Event name (e.g. 'page_view', 'form_submit', 'cta_click')"),
-            properties: z.record(z.unknown()).optional().describe("Event properties (url, formId, variant, etc.)"),
+            event: z.string().describe("Event name — snake_case from APEX_EVENTS or APEX_PLATFORM_EVENTS (e.g. 'page_view', 'in_app_purchase', 'user_invitation_created'). Custom names are accepted but prefer canonical ones."),
+            properties: z.record(z.unknown()).optional().describe("Flat snake_case properties matching the spec entry for this event (e.g. { product_id: 'prod_abc', value: 29.99, currency: 'USD' })."),
         }),
         handler: async ({ event, properties }) => {
             const result = await apiPost("/api/events", {
@@ -895,6 +941,42 @@ export const toolDefinitions = {
             };
         },
     },
+    send_server_event: {
+        description: `${APEX} — Server Events API. Send a server-to-server event via the /api/v1/events endpoint (clientType: "server", batch cap 100, idempotency-key supported). Use this from agent workflows that simulate backend integrations (Stripe webhook flows, CRM-driven conversions, billing events) or to test the Server Events API end-to-end. Differs from track_event in that it stamps clientType: "server" and uses the v1 ingest contract.`,
+        schema: z.object({
+            type: z.string().describe("Event type (e.g. 'purchase_completed', 'signup_completed', or any custom verb)"),
+            visitorId: z.string().optional().describe("Visitor ID to stitch back to a web/mobile session (apex_vid)"),
+            email: z.string().optional().describe("Email to stitch by identity when no visitorId is known"),
+            data: z.record(z.unknown()).optional().describe("Event payload (value, currency, order_id, …)"),
+            idempotencyKey: z.string().optional().describe("Stable key to prevent double-counting on retry (defaults to a fresh UUID)"),
+        }),
+        handler: async ({ type, visitorId, email, data, idempotencyKey, }) => {
+            const key = idempotencyKey ??
+                (typeof globalThis.crypto?.randomUUID === "function"
+                    ? globalThis.crypto.randomUUID()
+                    : `idk_${Date.now()}_${Math.random().toString(36).slice(2, 12)}`);
+            const result = await postWithIdempotency("/api/v1/events", key, {
+                events: [
+                    {
+                        type,
+                        visitorId,
+                        email,
+                        data,
+                        timestamp: new Date().toISOString(),
+                    },
+                ],
+            });
+            const lines = [
+                `Server Events API event sent: "${type}"`,
+                `  received: ${result.data.received}, duplicates: ${result.data.duplicates}`,
+                `  idempotency-key: ${key}`,
+            ];
+            if (result.data.errors.length > 0) {
+                lines.push(`  errors: ${JSON.stringify(result.data.errors)}`);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        },
+    },
     identify_user: {
         description: `${APEX} — Identify a user by email for identity stitching. Works identically to the SDK's identify() and the snippet's apex.identify(). Links an anonymous visitor to a known email/lead.`,
         schema: z.object({
@@ -918,6 +1000,55 @@ export const toolDefinitions = {
             };
         },
     },
+    get_schema: {
+        description: `${APEX} — Read the workspace's canonical Schema (data dictionary): entities, their fields, which fields are wired (observed in live data) vs not, surface coverage, and any canonical mappings. Use to see what variables/attributes a workspace has and what's still unwired before authoring comms or segments.`,
+        schema: z.object({}),
+        handler: async () => {
+            const dict = await apiGet("/api/data-dictionary");
+            const lines = [];
+            for (const entity of Object.values(dict.entities)) {
+                lines.push(`\n${entity.label}  {{${entity.key}.<field>}}`);
+                for (const f of Object.values(entity.fields)) {
+                    const wired = f.source === "discovered" || Boolean(f.lastSeenAt);
+                    const canon = f.canonicalName ? ` -> ${f.canonicalName}` : "";
+                    const surf = f.surfaces?.length ? ` [${f.surfaces.join(",")}]` : "";
+                    lines.push(`  ${wired ? "[wired]" : "[ not ]"} ${f.name}${canon} (${f.type})${surf}`);
+                }
+            }
+            lines.push("\n[wired] = observed in live data   [ not ] = canonical field not sent yet");
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        },
+    },
+    map_attribute: {
+        description: `${APEX} — Map a discovered field onto its canonical Apex Spec name (e.g. firstName -> first_name) so templates resolve it cleanly at send time. Pass canonicalName: null to clear an existing mapping.`,
+        schema: z.object({
+            entityKey: z
+                .string()
+                .describe("Entity key (user, account, order, product, or a custom entity)"),
+            fieldName: z
+                .string()
+                .describe("The field to map, as stored (e.g. 'firstName')"),
+            canonicalName: z
+                .string()
+                .nullable()
+                .optional()
+                .describe("Canonical snake_case name (e.g. 'first_name'), or null to clear"),
+        }),
+        handler: async ({ entityKey, fieldName, canonicalName, }) => {
+            const res = await apiPost("/api/data-dictionary/map", { entityKey, fieldName, canonicalName: canonicalName ?? null });
+            const mapped = res.data?.canonicalName;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: mapped
+                            ? `Mapped ${entityKey}.${fieldName} -> ${mapped}`
+                            : `Cleared canonical mapping on ${entityKey}.${fieldName}`,
+                    },
+                ],
+            };
+        },
+    },
     log_prediction: {
         description: `${APEX} — Log a prediction about a metric change. Feeds the calibration loop. Before calling, present the metric, expected change, and confidence as options the user can pick from or adjust.`,
         schema: z.object({
@@ -1206,5 +1337,709 @@ export const toolDefinitions = {
             return { content: [{ type: "text", text: `${events.length} events in taxonomy:\n\n${summary}\n\nFull data:\n${JSON.stringify(data, null, 2)}` }] };
         },
     },
+    // ─── Partner Network (MMP-161) ──────────────────────────────────────────
+    //
+    // Merchant-scoped tools for managing an affiliate program through the
+    // Apex Partner Network. Every tool authenticates via the caller's
+    // active project + API key (same pattern as experiments / comms).
+    // Partner-facing flows (self-signup, portal) + admin Fraud Ops are
+    // intentionally not wrapped — they require different auth.
+    list_partner_programs: {
+        description: "List every affiliate program this merchant owns. Returns each program's name, status (active/paused/archived), visibility (public/private), approval mode, commission structure, reputation counters, and created/updated timestamps.",
+        schema: z.object({}),
+        handler: async () => {
+            const data = await apiGet("/api/mobile/affiliates/programs");
+            const programs = Array.isArray(data) ? data : [];
+            if (programs.length === 0) {
+                return { content: [{ type: "text", text: "No affiliate programs yet. Use create_partner_program to set one up." }] };
+            }
+            const summary = programs.map((p) => {
+                const pr = p;
+                return `• ${pr.name} (${pr.id}) — ${pr.status} / ${pr.visibility} / approval ${pr.approvalMode}`;
+            }).join("\n");
+            return { content: [{ type: "text", text: `${programs.length} program${programs.length === 1 ? "" : "s"}:\n\n${summary}\n\nFull data:\n${JSON.stringify(data, null, 2)}` }] };
+        },
+    },
+    create_partner_program: {
+        description: "Create a new affiliate program. Partners can join via marketplace (public+auto), by invite only (private), or via application (public+manual). Commission can be a flat CPA amount or a percentage of sale (RevShare).",
+        schema: z.object({
+            name: z.string().describe("Public program name, shown in marketplace + partner portal"),
+            description: z.string().optional().describe("<= 600 chars, marketplace card body"),
+            vertical: z.enum(["saas", "ecommerce", "fintech", "marketplace", "hardware", "enterprise", "creator_tools", "other"]).describe("Drives marketplace filters"),
+            commissionStructure: z.object({
+                type: z.enum(["cpa", "revshare"]),
+                amountUsd: z.number().optional().describe("For CPA: flat commission"),
+                percentage: z.number().optional().describe("For RevShare: 0-100"),
+                appliesTo: z.enum(["install", "purchase", "subscription"]).describe("Which conversion event pays the commission"),
+            }),
+            visibility: z.enum(["public", "private"]).optional().default("public"),
+            approvalMode: z.enum(["auto", "manual"]).optional().default("auto").describe("Manual = merchant reviews every application"),
+        }),
+        handler: async (args) => {
+            const data = await apiPost("/api/mobile/affiliates/programs", args);
+            return { content: [{ type: "text", text: `Program created.\n\n${JSON.stringify(data, null, 2)}` }] };
+        },
+    },
+    update_partner_program: {
+        description: "Update an existing program (pause/resume, change visibility, edit default commission). Changing default commission does NOT apply to existing members — use apply_program_default_to_members for that.",
+        schema: z.object({
+            programId: z.string(),
+            updates: z.record(z.unknown()).describe("Fields to update: name, description, status, visibility, commissionStructure, vertical, tagline, landingPageUrl, autoPayoutPolicy, etc."),
+        }),
+        handler: async (args) => {
+            const data = await apiPatch(`/api/mobile/affiliates/programs/${args.programId}`, args.updates);
+            return { content: [{ type: "text", text: `Program updated.\n\n${JSON.stringify(data, null, 2)}` }] };
+        },
+    },
+    list_partner_program_members: {
+        description: "List every partner bound to a specific program. Shows each member's handle, current commission (with source: program_default | membership_override | invite_override), totalEarnedUsd, approvedConversions count.",
+        schema: z.object({ programId: z.string() }),
+        handler: async (args) => {
+            const data = await apiGet(`/api/mobile/affiliates/programs/${args.programId}/members`);
+            const members = Array.isArray(data) ? data : [];
+            if (members.length === 0) {
+                return { content: [{ type: "text", text: "No partners on this program yet." }] };
+            }
+            const summary = members.map((m) => {
+                const mem = m;
+                const ms = mem.membership;
+                return `• @${ms.handle} — ${ms.totalEarnedUsd ?? 0} lifetime, ${ms.approvedConversions ?? 0} conversions`;
+            }).join("\n");
+            return { content: [{ type: "text", text: `${members.length} partner${members.length === 1 ? "" : "s"}:\n\n${summary}\n\nFull data:\n${JSON.stringify(data, null, 2)}` }] };
+        },
+    },
+    apply_program_default_to_members: {
+        description: "Apply the program's current default commission to every existing member whose commission is a program_default source. Members with sticky overrides (membership_override / invite_override) are NOT touched. Fires partner_commission_changed emails to affected partners.",
+        schema: z.object({ programId: z.string() }),
+        handler: async (args) => {
+            const data = await apiPost(`/api/mobile/affiliates/programs/${args.programId}/apply-to-members`, {});
+            return { content: [{ type: "text", text: `Applied default to ${data.updated} member${data.updated === 1 ? "" : "s"}.` }] };
+        },
+    },
+    update_membership_rate: {
+        description: "Override a single partner's commission rate on this merchant's program. Sticky — survives future program default updates. Opens the per-membership commission history with `source: membership_override` for audit.",
+        schema: z.object({
+            profileId: z.string().describe("Partner profile id (starts with prof_)"),
+            commissionStructure: z.object({
+                type: z.enum(["cpa", "revshare"]),
+                amountUsd: z.number().optional(),
+                percentage: z.number().optional(),
+                appliesTo: z.enum(["install", "purchase", "subscription"]),
+            }),
+            reason: z.string().optional().describe("Audit log note — e.g. 'Volume discount Q3 2026'"),
+        }),
+        handler: async (args) => {
+            const data = await apiPost(`/api/mobile/affiliates/memberships/${args.profileId}/rate`, {
+                commissionStructure: args.commissionStructure,
+                reason: args.reason,
+            });
+            return { content: [{ type: "text", text: `Commission updated.\n\n${JSON.stringify(data, null, 2)}` }] };
+        },
+    },
+    reset_membership_rate: {
+        description: "Reset a partner's commission back to the program default, removing any prior override. Useful when a negotiated rate expires or a promo ends.",
+        schema: z.object({
+            profileId: z.string(),
+            reason: z.string().optional(),
+        }),
+        handler: async (args) => {
+            const data = await apiPost(`/api/mobile/affiliates/memberships/${args.profileId}/rate`, {
+                reset: true,
+                reason: args.reason,
+            });
+            return { content: [{ type: "text", text: `Rate reset to program default.\n\n${JSON.stringify(data, null, 2)}` }] };
+        },
+    },
+    invite_partner: {
+        description: "Send a magic-link invite to a partner for a specific program. Resolves existing profiles by email (no duplicate profile created) or creates a pending invite the partner redeems on first sign-in. Optional customRate overrides the program default for this partner's membership.",
+        schema: z.object({
+            email: z.string().email().describe("Partner's email — used for matching + the invite email"),
+            programId: z.string(),
+            inviterName: z.string().optional().describe("Name shown in the invite email's 'from' field"),
+            inviterMessage: z.string().optional().describe("Personal note from the merchant, shown in the invite email"),
+            customRate: z.object({
+                commissionStructure: z.object({
+                    type: z.enum(["cpa", "revshare"]),
+                    amountUsd: z.number().optional(),
+                    percentage: z.number().optional(),
+                    appliesTo: z.enum(["install", "purchase", "subscription"]),
+                }),
+            }).optional().describe("Override commission for this partner only (sticky)"),
+        }),
+        handler: async (args) => {
+            const data = await apiPost("/api/mobile/affiliates/invites", args);
+            return { content: [{ type: "text", text: `Invite sent.\n\n${JSON.stringify(data, null, 2)}` }] };
+        },
+    },
+    list_pending_payouts: {
+        description: "Every approved-but-unpaid commission this merchant owes, grouped into aging buckets: 0-30 / 30-60 / 60+ days. Returns totals per bucket + the effective autoPayoutPolicy + current merchant cap. Use before approving batches to see the backlog.",
+        schema: z.object({}),
+        handler: async () => {
+            const data = await apiGet("/api/mobile/affiliates/payouts/pending");
+            return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+        },
+    },
+    approve_payouts: {
+        description: "Approve one or more pending payouts. Each approved conversion: transitions to 'approved', writes a HoldbackEntry splitting commission into available + held portions per tier policy (25% held for NEW, 15% TRUSTED, 5% VERIFIED), stamps approvedAt. Transfer fires later via the scheduled payout orchestrator (run-payouts cron).",
+        schema: z.object({
+            conversionIds: z.array(z.string()).describe("Conversion ids from list_pending_payouts"),
+        }),
+        handler: async (args) => {
+            const data = await apiPost("/api/mobile/affiliates/payouts/approve", { conversionIds: args.conversionIds });
+            const { approved, skipped, failed } = data;
+            return { content: [{ type: "text", text: `Approved ${approved.length}, skipped ${skipped.length}, failed ${failed.length}.\n\n${JSON.stringify(data, null, 2)}` }] };
+        },
+    },
+    reject_payouts: {
+        description: "Reject pending payouts (e.g. suspicious patterns that don't warrant a FraudCase). Flips conversions to 'reversed'. Also opens a low-severity audit FraudCase per rejection so patterns surface if the same partner's payouts get rejected repeatedly.",
+        schema: z.object({
+            conversionIds: z.array(z.string()),
+            reason: z.string().optional().describe("Shown in the audit case — e.g. 'Duplicate event'"),
+        }),
+        handler: async (args) => {
+            const data = await apiPost("/api/mobile/affiliates/payouts/reject", args);
+            return { content: [{ type: "text", text: `Rejected.\n\n${JSON.stringify(data, null, 2)}` }] };
+        },
+    },
+    get_effective_fees: {
+        description: "Show the merchant's current fee schedule for every fee kind (facilitation_payout, identity_verification, instant_payout). Returns bps + flatUsd + source (platform_default | merchant_override | hardcoded_fallback) + isCustom flag. Useful for building pricing disclosure UIs or answering 'what am I charged?'.",
+        schema: z.object({}),
+        handler: async () => {
+            const data = await apiGet("/api/mobile/affiliates/fees");
+            const lines = Object.entries(data.fees).map(([kind, f]) => {
+                const parts = [];
+                if (f.bps && f.bps > 0)
+                    parts.push(`${(f.bps / 100).toFixed(2)}%`);
+                if (f.flatUsd && f.flatUsd > 0)
+                    parts.push(`$${f.flatUsd.toFixed(2)}`);
+                const display = parts.join(" + ") || "$0";
+                const tag = f.isCustom ? " (custom)" : "";
+                return `• ${kind}: ${display}${tag} — source: ${f.source}`;
+            }).join("\n");
+            return { content: [{ type: "text", text: `Fees for ${data.projectKey}:\n\n${lines}\n\nFull data:\n${JSON.stringify(data, null, 2)}` }] };
+        },
+    },
+    vouch_for_partner: {
+        description: "Vouch for a partner — bumps their trust tier by one level (NEW→TRUSTED or TRUSTED→VERIFIED) for 60 days. REQUIRES indemnityAcknowledged=true: if the partner commits fraud during the vouched window, your merchant account is liable for any clawback the reserve can't cover. Fails if the partner is already VERIFIED.",
+        schema: z.object({
+            profileId: z.string(),
+            indemnityAcknowledged: z.literal(true).describe("Must be exactly `true` — acknowledges merchant liability for fraud during vouch window"),
+            reason: z.string().optional().describe("Audit note — e.g. 'Long-standing professional relationship'"),
+            vouchDays: z.number().optional().describe("Custom window in days (default 60, max 90)"),
+        }),
+        handler: async (args) => {
+            const data = await apiPost(`/api/mobile/affiliates/${args.profileId}/vouch`, args);
+            return { content: [{ type: "text", text: `Vouch recorded.\n\n${JSON.stringify(data, null, 2)}` }] };
+        },
+    },
+    // ─── Wave 68cb — Audience Activation MCP tools ───────────────────
+    // Pair with the AudienceActivationWizard (Layer 2) to give agents
+    // a way to wire up audience instrumentation without leaving the
+    // editor. Both tools are PROJECT-SCOPED via the api-client's
+    // active-project context — the merchant's CLI run pins which
+    // workspace they're acting on.
+    wire_audience_seed: {
+        description: `${APEX} — Wire up the events and traits a campaign audience seed depends on. Use this when the merchant says "wire up the active customers audience" or after the AudienceActivationWizard's Screen 1 hands off to Cursor. Returns the per-event/trait code snippets, the file recommendations, and fires a test event with is_test=1 so the wizard's polling loop confirms the wiring landed end-to-end. Idempotent: calling twice does NOT double-instrument; the agent should still review existing code before adding the snippet.`,
+        schema: z.object({
+            seedId: z
+                .string()
+                .describe("Audience seed id, e.g. 'aud-seed-active-customers-90d'. Returned by the seed-campaign-defaults POST endpoint and surfaced in the wizard's URL."),
+            framework: z
+                .enum(["typescript", "snippet", "python", "ruby"])
+                .optional()
+                .describe("Code style to return. Defaults to 'typescript' (the SDK's canonical surface). Use 'snippet' for script-tag installs (Shopify, WordPress, Webflow). The wizard sets this from the detected framework."),
+            fireTestEvent: z
+                .boolean()
+                .optional()
+                .describe("When true (default), fires a test event with is_test=1 for each event the seed depends on. The wizard's poll loop sees these and advances. Set to false if the agent only wants to read the snippets without writing test data."),
+        }),
+        handler: async ({ seedId, framework = "typescript", fireTestEvent = true, }) => {
+            const projectKey = getActiveProject() || process.env.APEX_PROJECT_KEY;
+            if (!projectKey) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No active project. Call set_active_project first or set APEX_PROJECT_KEY.",
+                        },
+                    ],
+                };
+            }
+            // Pull the seed's instrumentation requirements via the
+            // dashboard API. Single source of truth: the dashboard
+            // walks the seed's predicate the same way the
+            // AudienceBuilder does.
+            const data = await apiGet(`/api/audiences/seed-campaign-defaults/${encodeURIComponent(seedId)}/instrumentation?framework=${framework}`);
+            // Optionally fire test events so the wizard polling loop
+            // can flip into the "test received" state immediately.
+            // We fire one per event with is_test=1 so they don't
+            // pollute analytics.
+            const firedTests = [];
+            if (fireTestEvent && data.events.length > 0) {
+                for (const ev of data.events) {
+                    try {
+                        await apiPost("/api/events", {
+                            type: "custom",
+                            visitorId: "mcp-agent-wire-test",
+                            data: {
+                                eventName: ev.name,
+                                endUserId: "mcp-agent-test-user",
+                                is_test: 1,
+                                source: "mcp_wire_audience_seed",
+                            },
+                        });
+                        firedTests.push(ev.name);
+                    }
+                    catch {
+                        // Best-effort — the agent gets the snippets even if
+                        // test firing fails; the wizard's manual fire
+                        // button is still available.
+                    }
+                }
+            }
+            const snippetBlocks = [];
+            for (const ev of data.events) {
+                const props = ev.properties.length > 0
+                    ? `\nProperties (predicate cares about):\n${ev.properties
+                        .map((p) => `  - ${p.name} (${p.type}): ${p.description}`)
+                        .join("\n")}`
+                    : "";
+                snippetBlocks.push(`### Event: ${ev.name}${props}\n\n\`\`\`${framework === "typescript" ? "ts" : framework}\n${ev.sdkExample}\n\`\`\``);
+            }
+            for (const tr of data.traits) {
+                snippetBlocks.push(`### Trait: ${tr.fieldPath}\n${tr.description}\n\n\`\`\`${framework === "typescript" ? "ts" : framework}\n${tr.sdkExample}\n\`\`\``);
+            }
+            const summary = [
+                `# Wiring up "${data.seedName}"`,
+                ``,
+                `Predicate: ${data.predicateSummary}`,
+                ``,
+                `Add the following ${data.events.length} event ${data.events.length === 1 ? "call" : "calls"} and ${data.traits.length} trait ${data.traits.length === 1 ? "set" : "sets"} to the merchant's codebase. Find the right files (checkout success handler, login flow, session start) and insert the snippet, replacing placeholder properties with the merchant's actual values.`,
+                ``,
+                ...snippetBlocks,
+                ``,
+                firedTests.length > 0
+                    ? `## Test events fired\nFired test events for: ${firedTests.join(", ")}. The wizard's polling loop will see these and advance. Confirm the merchant fires REAL events from production code paths before relying on the audience.`
+                    : `## Test events\nNo test events fired (per fireTestEvent=false). Run the wizard's "Send a test event" button manually after wiring.`,
+                ``,
+                `Project: ${projectKey}`,
+            ].join("\n");
+            return { content: [{ type: "text", text: summary }] };
+        },
+    },
+    wire_audience: {
+        description: `${APEX} — Wire up the events and traits ANY audience depends on, not just starter audiences. Use this for bespoke / merchant-built audiences (e.g. 'New sign-ups in the last 14 days', 'Stalled sign-ups — no connector in 12h'). Walks the audience's predicate server-side, classifies each referenced event (auto-fired by the Apex snippet vs documented in Apex's event taxonomy vs custom merchant event), returns per-event recommendations, and optionally fires test events (is_test=1) for non-auto-fired events so the wizard's polling loop confirms wiring landed.`,
+        schema: z.object({
+            audienceId: z
+                .string()
+                .describe("Audience id (the workspace's audience record). Use list_audiences first to find it. Bespoke audiences carry generated ids; seed-cloned audiences carry ids starting with `aud-seed-`."),
+            framework: z
+                .enum(["typescript", "snippet", "python", "ruby"])
+                .optional()
+                .describe("Code style to return. Defaults to 'typescript'. Use 'snippet' for script-tag installs (Shopify, WordPress, Webflow)."),
+            fireTestEvent: z
+                .boolean()
+                .optional()
+                .describe("When true (default), fires a test event with is_test=1 for each NON-AUTO-FIRED event the audience depends on. Auto-fired events (pageview, click, etc.) are skipped — they're already firing automatically and don't need a synthetic test."),
+        }),
+        handler: async ({ audienceId, framework = "typescript", fireTestEvent = true, }) => {
+            const projectKey = getActiveProject() || process.env.APEX_PROJECT_KEY;
+            if (!projectKey) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No active project. Call set_active_project first or set APEX_PROJECT_KEY.",
+                        },
+                    ],
+                };
+            }
+            const data = await apiGet(`/api/audiences/${encodeURIComponent(audienceId)}/instrumentation?framework=${framework}`);
+            // Fire test events for non-auto-fired events only. Auto-fired
+            // events are already flowing — sending a synthetic one would
+            // be misleading (and it'd fail because the merchant's snippet
+            // is what ingests pageview, not our agent).
+            const wirableEvents = data.events.filter((e) => e.category !== "auto-fired-web" &&
+                e.category !== "auto-fired-mobile");
+            const firedTests = [];
+            const skippedAutoFired = data.events
+                .filter((e) => e.category === "auto-fired-web" ||
+                e.category === "auto-fired-mobile")
+                .map((e) => e.name);
+            if (fireTestEvent && wirableEvents.length > 0) {
+                for (const ev of wirableEvents) {
+                    try {
+                        await apiPost("/api/events", {
+                            type: "custom",
+                            visitorId: "mcp-agent-wire-test",
+                            data: {
+                                eventName: ev.name,
+                                endUserId: "mcp-agent-test-user",
+                                is_test: 1,
+                                source: "mcp_wire_audience",
+                            },
+                        });
+                        firedTests.push(ev.name);
+                    }
+                    catch {
+                        // Best-effort.
+                    }
+                }
+            }
+            const sections = [];
+            sections.push(`# Wiring up "${data.audienceName}"`);
+            if (data.audienceSummary) {
+                sections.push(`\n${data.audienceSummary}`);
+            }
+            if (skippedAutoFired.length > 0) {
+                sections.push(`\n## Already automatic (no code needed)\nThe Apex web snippet / mobile SDK fires these events automatically. Just confirm the snippet/SDK is installed:`);
+                for (const name of skippedAutoFired) {
+                    sections.push(`  - ${name}`);
+                }
+            }
+            if (wirableEvents.length > 0 || data.traits.length > 0) {
+                sections.push(`\n## Code to add to the merchant's codebase`);
+                for (const ev of wirableEvents) {
+                    const props = ev.properties.length > 0
+                        ? `\nProperties (audience reads these): ${ev.properties.map((p) => p.name).join(", ")}`
+                        : "";
+                    sections.push(`\n### Event: ${ev.name} (${ev.category})\n${ev.caption}${props}\n\n\`\`\`${framework === "typescript" ? "ts" : framework}\n${ev.sdkExample}\n\`\`\``);
+                }
+                for (const tr of data.traits) {
+                    sections.push(`\n### Trait: ${tr.fieldPath}\n${tr.description}\n\n\`\`\`${framework === "typescript" ? "ts" : framework}\n${tr.sdkExample}\n\`\`\``);
+                }
+            }
+            if (firedTests.length > 0) {
+                sections.push(`\n## Test events fired\nFired test events (is_test=1) for: ${firedTests.join(", ")}. The wizard's polling loop will see these and advance. Confirm the merchant fires REAL events from production code paths before relying on the audience.`);
+            }
+            else if (wirableEvents.length === 0) {
+                sections.push(`\n## Test events\nNothing to fire — every event is auto-fired by Apex's snippet/SDK.`);
+            }
+            else {
+                sections.push(`\n## Test events\nNo test events fired (per fireTestEvent=false). Run the wizard's "Send a test event" button manually after wiring.`);
+            }
+            sections.push(`\nProject: ${projectKey}`);
+            return { content: [{ type: "text", text: sections.join("\n") }] };
+        },
+    },
+    audit_audience_readiness: {
+        description: `${APEX} — Check whether an audience is wired up and matching users. Use this to verify your wire_audience_seed work succeeded, or to diagnose why a campaign is showing zero matches. Returns the audience predicate, current matching count, recency buckets, and which referenced events have arrived from the workspace.`,
+        schema: z.object({
+            audienceId: z
+                .string()
+                .describe("Audience id (the workspace's audience record, not the seed). Use list_audiences first to find it."),
+        }),
+        handler: async ({ audienceId }) => {
+            const projectKey = getActiveProject() || process.env.APEX_PROJECT_KEY;
+            if (!projectKey) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No active project. Call set_active_project first or set APEX_PROJECT_KEY.",
+                        },
+                    ],
+                };
+            }
+            const [audience, preview] = await Promise.all([
+                apiGet(`/api/audiences/${encodeURIComponent(audienceId)}`),
+                apiGet(`/api/audiences/${encodeURIComponent(audienceId)}/preview`).catch(() => null),
+            ]);
+            const matchingLine = preview
+                ? `${preview.matchingCount.toLocaleString()} user${preview.matchingCount === 1 ? "" : "s"} currently match`
+                : "Couldn't compute live preview (audience may still resolve correctly at send time)";
+            const recencyLines = preview
+                ? [
+                    `  - Last 24h: ${preview.recencyBuckets.last_24h}`,
+                    `  - Last 7d:  ${preview.recencyBuckets.last_7d}`,
+                    `  - Last 30d: ${preview.recencyBuckets.last_30d}`,
+                    `  - Older:    ${preview.recencyBuckets.older}`,
+                ].join("\n")
+                : "  (no recency data)";
+            const summary = [
+                `# Audience readiness: ${audience.name}`,
+                audience.description ? `\n${audience.description}` : "",
+                `\n## Match status\n${matchingLine}`,
+                `\n## Recency buckets\n${recencyLines}`,
+                `\n## Predicate\n\`\`\`json\n${JSON.stringify(audience.predicate, null, 2)}\n\`\`\``,
+                preview && preview.matchingCount === 0
+                    ? `\n## Diagnosis\nZero matches. Most likely causes:\n  1. Events the predicate references aren't firing yet from the merchant's codebase. Run \`wire_audience_seed\` if this is a starter audience, or check the predicate's event names against your codebase.\n  2. The predicate's window (\`last_n_days\`, \`ever\`) is too narrow.\n  3. End-user identity isn't being stitched. Each \`apex.track()\` call must include \`endUserId\` in its data payload, or be preceded by an \`identify()\` call.\n`
+                    : "",
+                `\nProject: ${projectKey}`,
+            ].join("\n");
+            return { content: [{ type: "text", text: summary }] };
+        },
+    },
+    // ─── Journey Exit Semantics — catch-up tools ────────────────────────────
+    //
+    // Wraps the journey-management + exit-rules + cart-state API
+    // surfaces shipped in `journey_exit_semantics_0b4fe496.plan.md`.
+    // Agent-friendly arg names (snake_case) are mapped to the REST
+    // routes inside each handler.
+    list_journeys: {
+        description: `${APEX} — List every adaptive journey in the active workspace. Returns id, name, status (draft/published/paused/archived), and journey type (lifecycle/campaign). Foundation for exit-rule audit loops + journey CRUD agent flows.`,
+        schema: z.object({}),
+        handler: async () => {
+            const journeys = await apiGet("/api/journeys");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(journeys.map((j) => ({
+                            id: j.id,
+                            name: j.name,
+                            status: j.status,
+                            journey_type: j.journeyType ?? null,
+                            version: j.version,
+                            exit_rule_count: (j.exitEvents ?? []).length,
+                        })), null, 2),
+                    },
+                ],
+            };
+        },
+    },
+    get_journey: {
+        description: `${APEX} — Read the full configuration for a single journey, including steps, goal event, attribution window, and exit rules. Use after list_journeys to inspect a journey's wiring before recommending edits.`,
+        schema: z.object({
+            journey_id: z.string().describe("Journey id returned from list_journeys"),
+        }),
+        handler: async ({ journey_id }) => {
+            const journey = await apiGet(`/api/journeys/${encodeURIComponent(journey_id)}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(journey, null, 2),
+                    },
+                ],
+            };
+        },
+    },
+    list_journey_exits: {
+        description: `${APEX} — Just the exit-rules block of one journey. Cheaper than get_journey for audit loops that only need to know "does this journey suppress purchase / unsubscribe?".`,
+        schema: z.object({
+            journey_id: z.string(),
+        }),
+        handler: async ({ journey_id }) => {
+            const body = await apiGet(`/api/journeys/${encodeURIComponent(journey_id)}/exit-rules`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(body.data ?? [], null, 2),
+                    },
+                ],
+            };
+        },
+    },
+    add_journey_exit: {
+        description: `${APEX} — Append a new exit rule to a journey's draft. Rule fires when the chosen trigger contract's event lands on a contact with an in-flight execution — Apex stops the execution and skips any pending sends. Re-publish required for the rule to take effect on live runs.`,
+        schema: z.object({
+            journey_id: z.string(),
+            trigger_contract_id: z
+                .string()
+                .describe("Trigger-contract id, e.g. trig-in-app-purchase"),
+            label: z.string().optional(),
+            enabled: z.boolean().optional().default(true),
+        }),
+        handler: async ({ journey_id, trigger_contract_id, label, enabled, }) => {
+            const body = await apiPost(`/api/journeys/${encodeURIComponent(journey_id)}/exit-rules`, {
+                triggerContractId: trigger_contract_id,
+                ...(label !== undefined && { label }),
+                enabled: enabled !== false,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Added exit rule ${body.data.id} → ${body.data.triggerContractId}. Publish the journey for it to apply to new executions.`,
+                    },
+                ],
+            };
+        },
+    },
+    remove_journey_exit: {
+        description: `${APEX} — Remove an exit rule from a journey's draft. Re-publish required for the change to apply to live runs.`,
+        schema: z.object({
+            journey_id: z.string(),
+            rule_id: z.string(),
+        }),
+        handler: async ({ journey_id, rule_id, }) => {
+            await apiDelete(`/api/journeys/${encodeURIComponent(journey_id)}/exit-rules/${encodeURIComponent(rule_id)}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Removed exit rule ${rule_id} from journey ${journey_id}.`,
+                    },
+                ],
+            };
+        },
+    },
+    get_contact_cart: {
+        description: `${APEX} — Read the rolled-up cart state for a contact (Phase 2 of Journey Exit Semantics). Returns lines, itemCount, valueCents, and last-updated timestamp. Useful for "is this lead worth a follow-up?" agent loops.`,
+        schema: z.object({
+            contact_id: z.string(),
+        }),
+        handler: async ({ contact_id }) => {
+            const contact = await apiGet(`/api/contacts/${encodeURIComponent(contact_id)}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            contact_id: contact.id,
+                            email: contact.email ?? null,
+                            cart: contact.cart ?? null,
+                        }, null, 2),
+                    },
+                ],
+            };
+        },
+    },
+    audit_journey_exits: {
+        description: `${APEX} — Audit every published journey in the workspace for exit-rule hygiene. Flags marketing/lifecycle journeys (goalEventName=in_app_purchase) that don't have a purchase exit rule — the most common misconfiguration that produces "received the recovery push AFTER converting" complaints.`,
+        schema: z.object({}),
+        handler: async () => {
+            const journeys = await apiGet("/api/journeys");
+            const findings = [];
+            for (const j of journeys) {
+                if (j.status !== "published" && j.status !== "paused")
+                    continue;
+                const isMarketing = j.journeyType === "campaign" || j.journeyType === "lifecycle";
+                if (!isMarketing)
+                    continue;
+                const goalLooksLikePurchase = j.goalEventName === "in_app_purchase" ||
+                    j.goalEventName === "purchase";
+                if (!goalLooksLikePurchase)
+                    continue;
+                const hasPurchaseExit = (j.exitEvents ?? []).some((r) => r.enabled !== false &&
+                    (r.triggerContractId.includes("purchase") ||
+                        (r.label ?? "").toLowerCase().includes("purchase")));
+                if (!hasPurchaseExit) {
+                    findings.push({
+                        journey_id: j.id,
+                        name: j.name,
+                        recommendation: "Marketing journey with purchase goal but no purchase exit rule. Users who convert mid-journey will still receive later sends.",
+                    });
+                }
+            }
+            const text = findings.length === 0
+                ? "✓ All published marketing journeys with a purchase goal have a purchase exit rule wired."
+                : `# Exit-rule audit — ${findings.length} journey${findings.length === 1 ? "" : "s"} need attention\n\n${findings.map((f) => `- **${f.name}** (${f.journey_id}): ${f.recommendation}`).join("\n")}\n\nFix with: \`add_journey_exit\` for each journey using a purchase trigger contract.`;
+            return { content: [{ type: "text", text }] };
+        },
+    },
+    get_setup_state: {
+        description: `${APEX} — READ-ONLY. Returns the current Set up Apex state for the active workspace: which steps the merchant has marked complete or skipped, plus the live signal flags (snippet installed, mobile live, sender domain verified, etc.). Use to answer "where am I in onboarding?" or to surface "your next step is X" recommendations. WRITE tools (complete_setup_step, skip_setup_step) are deliberately NOT exposed pending a server-enforced confirmation nonce.`,
+        schema: z.object({}),
+        handler: async () => {
+            // The active project key is encoded in the x-apex-project header
+            // that apiGet sends automatically.
+            const data = await apiGet("/api/setup-state");
+            const { overrides, signal, workspaceKey } = data.data;
+            const completedSteps = overrides
+                .filter((o) => o.action === "complete")
+                .map((o) => o.stepId);
+            const skippedSteps = overrides
+                .filter((o) => o.action === "skipped")
+                .map((o) => o.stepId);
+            const signalLines = Object.entries(signal)
+                .filter(([, v]) => typeof v === "boolean")
+                .map(([k, v]) => `- ${k}: ${v ? "✓" : "—"}`)
+                .join("\n");
+            const text = `# Set up Apex — workspace ${workspaceKey}
+
+## Live signal
+${signalLines || "_no signal data yet_"}
+
+## Completed steps (${completedSteps.length})
+${completedSteps.length ? completedSteps.map((s) => `- ${s}`).join("\n") : "_none_"}
+
+## Skipped steps (${skippedSteps.length})
+${skippedSteps.length ? skippedSteps.map((s) => `- ${s}`).join("\n") : "_none_"}
+
+_Suggest the next step the user should tackle based on what's incomplete in the signal._`;
+            return { content: [{ type: "text", text }] };
+        },
+    },
+    // ─── Data Sources + unified analytics ──────────────────────────────────
+    list_data_sources: {
+        description: `${APEX} — List the workspace's Data Sources (the producers that send events: Website, iOS/Android apps, Backend). Shows each source's live status (live / listening / stalled / not-started). Call when the user asks "where is my data coming from?", "which sources are live?", or to audit collection coverage.`,
+        schema: z.object({
+            includeArchived: z
+                .boolean()
+                .optional()
+                .describe("Include archived sources. Defaults to false."),
+        }),
+        handler: async ({ includeArchived }) => {
+            const proj = getActiveProject();
+            const qs = includeArchived ? "?includeArchived=true" : "";
+            const json = await apiGet(`/api/workspaces/${proj}/data-sources${qs}`);
+            const sources = json.data ?? [];
+            if (sources.length === 0) {
+                return { content: [{ type: "text", text: "No data sources registered yet. They auto-register on the first event, or add one in Integrations." }] };
+            }
+            const lines = sources.map((s) => `- **${s.name}** (${s.kind}) — ${s.status}${s.lastSeenAt ? ` · last seen ${s.lastSeenAt}` : ""} · \`${s.id}\``);
+            return { content: [{ type: "text", text: `# Data Sources (${sources.length})\n\n${lines.join("\n")}` }] };
+        },
+    },
+    create_data_source: {
+        description: `${APEX} — Register a new Data Source in the active workspace. Most sources auto-register on their first event; use this to set one up BEFORE events arrive (e.g. a Backend API source). Reporting-only — registering a source never changes access control.`,
+        schema: z.object({
+            kind: z
+                .enum(["website", "ios", "android", "server", "pos", "kiosk", "extension", "other"])
+                .describe("The producer kind."),
+            name: z.string().describe("Display name, e.g. 'Marketing site' or 'Backend API'."),
+        }),
+        handler: async ({ kind, name }) => {
+            const proj = getActiveProject();
+            const json = await apiPost(`/api/workspaces/${proj}/data-sources`, { kind, name });
+            const s = json.data;
+            return { content: [{ type: "text", text: `✓ Created data source **${s.name}** (${s.kind}) — ${s.status} · \`${s.id}\`` }] };
+        },
+    },
+    get_data_source_health: {
+        description: `${APEX} — Get the live status of one Data Source (live / listening / stalled / not-started) plus its first/last seen timestamps. Use to diagnose "why isn't my backend / app showing data?"`,
+        schema: z.object({
+            id: z.string().describe("The data source id (ds_...)."),
+        }),
+        handler: async ({ id }) => {
+            const proj = getActiveProject();
+            const json = await apiGet(`/api/workspaces/${proj}/data-sources/${encodeURIComponent(id)}/health`);
+            const h = json.data;
+            return { content: [{ type: "text", text: `# ${h.kind} source ${h.id}\n\n- status: **${h.status}**\n- first seen: ${h.firstSeenAt ?? "never"}\n- last seen: ${h.lastSeenAt ?? "never"}` }] };
+        },
+    },
+    get_analytics_sources: {
+        description: `${APEX} — Unified analytics breakdown by Data Source, platform, and hostname over a date range. Use for "how much traffic from each source?", "web vs mobile split", or "which hostnames are busiest?".`,
+        schema: z.object({
+            days: z.number().optional().describe("Lookback window in days (default 30, max 365)."),
+        }),
+        handler: async ({ days }) => {
+            const qs = days ? `?days=${days}` : "";
+            const json = await apiGet(`/api/analytics/sources${qs}`);
+            const d = json.data;
+            const srcLines = d.sources.map((s) => `- ${s.name} (${s.kind}, ${s.status}): ${s.eventCount.toLocaleString()} events`);
+            const platLines = d.platforms.map((p) => `- ${p.platform}: ${p.count.toLocaleString()}`);
+            const hostLines = d.hostnames.slice(0, 10).map((h) => `- ${h.hostname}: ${h.count.toLocaleString()}`);
+            return {
+                content: [{ type: "text", text: `# Analytics by source\n\n## Sources\n${srcLines.join("\n") || "_none_"}\n\n## Platforms\n${platLines.join("\n") || "_none_"}\n\n## Top hostnames\n${hostLines.join("\n") || "_none_"}` }],
+            };
+        },
+    },
+    get_analytics_hostnames: {
+        description: `${APEX} — The hostname catalog for this workspace (every host the web snippet has reported, ranked by volume). Use to populate a hostname filter or audit which subdomains are sending events.`,
+        schema: z.object({
+            limit: z.number().optional().describe("Max hostnames to return (default 100)."),
+        }),
+        handler: async ({ limit }) => {
+            const qs = limit ? `?limit=${limit}` : "";
+            const json = await apiGet(`/api/analytics/hostnames${qs}`);
+            const hosts = json.data ?? [];
+            const lines = hosts.map((h) => `- ${h.hostname}: ${h.count.toLocaleString()}`);
+            return { content: [{ type: "text", text: hosts.length ? `# Hostnames (${hosts.length})\n\n${lines.join("\n")}` : "No hostnames seen yet." }] };
+        },
+    },
 };
 //# sourceMappingURL=tools.js.map