@convertcom/mcp-server 0.0.1-beta.10

package/build/operator.js

@@ -0,0 +1,1320 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { executeNamespacedTool } from './namespaced.js';
+import { JSON_SCHEMA_DRAFT_2020_12 } from './shared.js';
+const READ_ACTIONS = [
+    {
+        action: 'project_audit',
+        mode: 'read',
+        description: 'Fetch project, domains, experiments, goals, audiences, locations, tags, and features where supported, then return a compact project audit.',
+        path_parameters: ['account_id', 'project_id'],
+        accepts_body: false,
+    },
+    {
+        action: 'experiment_portfolio',
+        mode: 'read',
+        description: 'Summarize experiments by status, type, duration, goals, and observed outcome fields.',
+        path_parameters: ['account_id', 'project_id'],
+        accepts_body: true,
+    },
+    {
+        action: 'experiment_velocity',
+        mode: 'read',
+        description: 'Compute created, active, completed, draft backlog, and cycle-time signals from project experiments.',
+        path_parameters: ['account_id', 'project_id'],
+        accepts_body: true,
+    },
+    {
+        action: 'draft_qa',
+        mode: 'read',
+        description: 'Check draft experiences for missing goals, targeting, variations, code, URLs, and alerts.',
+        path_parameters: ['account_id', 'project_id'],
+        accepts_body: false,
+    },
+    {
+        action: 'active_health',
+        mode: 'read',
+        description: 'Check active experiments for long runtime, alerts, setup gaps, and traffic-allocation concerns.',
+        path_parameters: ['account_id', 'project_id'],
+        accepts_body: true,
+    },
+    {
+        action: 'implementation_health',
+        mode: 'read',
+        description: 'Inspect Convert-side implementation evidence for web/fullstack projects: project type, snippet/SDK config, domains, live data, optional experience live data, and next browser/local checks.',
+        path_parameters: ['account_id', 'project_id'],
+        accepts_body: true,
+    },
+    {
+        action: 'failed_test_analysis',
+        mode: 'read',
+        description: 'Analyze paused/completed/inconclusive experiments and identify likely loss, underpowering, or retest candidates.',
+        path_parameters: ['account_id', 'project_id'],
+        accepts_body: true,
+    },
+    {
+        action: 'hypothesis_quality_audit',
+        mode: 'read',
+        description: 'Score hypothesis wording quality and correlate hypotheses with linked experiment outcomes when available.',
+        path_parameters: ['account_id', 'project_id'],
+        accepts_body: true,
+    },
+    {
+        action: 'audience_segment_comparison',
+        mode: 'read',
+        description: 'Run aggregated report comparisons across supported segments for one experience.',
+        path_parameters: ['account_id', 'project_id', 'experience_id'],
+        accepts_body: true,
+    },
+    {
+        action: 'cleanup_candidates',
+        mode: 'read',
+        description: 'Find stale drafts and unused goals, audiences, locations, tags, and fullstack features where supported.',
+        path_parameters: ['account_id', 'project_id'],
+        accepts_body: true,
+    },
+    {
+        action: 'get_defaults',
+        mode: 'read',
+        description: 'Infer and cache project defaults such as preferred goal, audience, location, URL, and traffic split.',
+        path_parameters: ['account_id', 'project_id'],
+        accepts_body: true,
+    },
+];
+const WRITE_ACTIONS = [
+    {
+        action: 'create_custom_code_ab_test',
+        mode: 'write',
+        description: 'Create a draft custom-code A/B experience, then read it back for verification.',
+        path_parameters: ['account_id', 'project_id'],
+        accepts_body: true,
+    },
+    {
+        action: 'create_split_url_test',
+        mode: 'write',
+        description: 'Create a draft split URL experience with defaultRedirect change data, then read it back for verification.',
+        path_parameters: ['account_id', 'project_id'],
+        accepts_body: true,
+    },
+    {
+        action: 'enable_split_url_regex',
+        mode: 'write',
+        description: 'Enable split URL regex support with experiences.update, then read the experience back.',
+        path_parameters: ['account_id', 'project_id', 'experience_id'],
+        accepts_body: true,
+    },
+    {
+        action: 'safe_update_variation_code',
+        mode: 'write',
+        description: 'Update a variation customCode change with experiences.update_variation, then read the experience back.',
+        path_parameters: ['account_id', 'project_id', 'experience_id', 'variation_id'],
+        accepts_body: true,
+    },
+];
+const ALL_ACTIONS = [...READ_ACTIONS, ...WRITE_ACTIONS];
+const DEFAULT_RESULTS_PER_PAGE = 50;
+const DEFAULT_CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+export function getOperatorActions(toolSet) {
+    return toolSet === 'all' ? ALL_ACTIONS : READ_ACTIONS;
+}
+export function getOperatorTool(toolSet) {
+    const actions = getOperatorActions(toolSet);
+    const hasWrite = actions.some((action) => action.mode === 'write');
+    const annotations = {
+        title: 'Operator',
+        readOnlyHint: !hasWrite,
+        destructiveHint: false,
+        idempotentHint: !hasWrite,
+        openWorldHint: false,
+    };
+    return {
+        name: 'operator',
+        title: 'Operator',
+        description: `High-level Convert experimentation workflows. Available actions: ${actions.map((item) => item.action).join(', ')}.`,
+        inputSchema: {
+            $schema: JSON_SCHEMA_DRAFT_2020_12,
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: actions.map((item) => item.action),
+                    description: 'Operator workflow action to perform. See _meta.available_actions for per-action details.',
+                },
+                path: {
+                    type: 'object',
+                    additionalProperties: true,
+                    description: 'Path identifiers such as account_id, project_id, experience_id, and variation_id. For compatibility, these IDs may also be supplied at the top level.',
+                },
+                query: {
+                    type: 'object',
+                    additionalProperties: true,
+                    description: 'Optional filters or reporting parameters.',
+                },
+                body: {
+                    type: 'object',
+                    additionalProperties: true,
+                    description: 'Workflow input. Mutating operator actions always create draft/update-only changes and perform readback verification.',
+                },
+                confirmation: {
+                    type: 'object',
+                    additionalProperties: true,
+                    description: 'Explicit user confirmation metadata. Passed through to underlying namespace calls when needed.',
+                },
+            },
+            required: ['action'],
+            additionalProperties: true,
+            _meta: {
+                namespace: 'operator',
+                available_actions: actions,
+            },
+        },
+        outputSchema: {
+            $schema: JSON_SCHEMA_DRAFT_2020_12,
+            type: 'object',
+            description: 'Standardized operator result envelope.',
+            properties: {
+                ok: { type: 'boolean' },
+                namespace: { type: 'string' },
+                action: { type: 'string' },
+                delegate: { type: 'string' },
+                status: { type: 'number' },
+                data: {},
+                error: {},
+                issues: { type: 'array', items: { type: 'object' } },
+                verified: { type: 'boolean' },
+            },
+            additionalProperties: true,
+        },
+        annotations,
+    };
+}
+export async function executeOperatorTool(rawArgs, toolSet = process.env.TOOLS_FOR_CLIENT ?? 'reporting', context = {}) {
+    const parsed = normalizeArgs(rawArgs);
+    if (!parsed) {
+        return errorResult('unknown', 'InvalidArguments', 'Expected object with fields: action, path, query, body, confirmation.');
+    }
+    const actionDef = getOperatorActions(toolSet).find((candidate) => candidate.action === parsed.action);
+    if (!actionDef) {
+        return errorResult(parsed.action || 'unknown', 'UnknownAction', `Unknown operator action "${parsed.action}". Available: ${getOperatorActions(toolSet).map((item) => item.action).join(', ')}`);
+    }
+    const missing = actionDef.path_parameters.filter((name) => typeof parsed.path[name] === 'undefined' || parsed.path[name] === null);
+    if (missing.length > 0) {
+        return errorResult(parsed.action, 'MissingPathParameters', `Missing required path parameters: ${missing.map((name) => `path.${name}`).join(', ')}`, { missing_parameters: missing });
+    }
+    try {
+        await report(context, `Starting operator.${parsed.action}`, 0, 1);
+        switch (parsed.action) {
+            case 'project_audit':
+                return okResult(parsed.action, await projectAudit(parsed, context));
+            case 'experiment_portfolio':
+                return okResult(parsed.action, await experimentPortfolio(parsed, context));
+            case 'experiment_velocity':
+                return okResult(parsed.action, await experimentVelocity(parsed, context));
+            case 'draft_qa':
+                return okResult(parsed.action, await draftQa(parsed, context));
+            case 'active_health':
+                return okResult(parsed.action, await activeHealth(parsed, context));
+            case 'implementation_health':
+                return okResult(parsed.action, await implementationHealth(parsed, context));
+            case 'failed_test_analysis':
+                return okResult(parsed.action, await failedTestAnalysis(parsed, context));
+            case 'hypothesis_quality_audit':
+                return okResult(parsed.action, await hypothesisQualityAudit(parsed, context));
+            case 'audience_segment_comparison':
+                return okResult(parsed.action, await audienceSegmentComparison(parsed, context));
+            case 'cleanup_candidates':
+                return okResult(parsed.action, await cleanupCandidates(parsed, context));
+            case 'get_defaults':
+                return okResult(parsed.action, await getDefaults(parsed, context));
+            case 'create_custom_code_ab_test':
+                return okResult(parsed.action, await createCustomCodeAbTest(parsed, context));
+            case 'create_split_url_test':
+                return okResult(parsed.action, await createSplitUrlTest(parsed, context));
+            case 'enable_split_url_regex':
+                return okResult(parsed.action, await enableSplitUrlRegex(parsed, context));
+            case 'safe_update_variation_code':
+                return okResult(parsed.action, await safeUpdateVariationCode(parsed, context));
+            default:
+                return errorResult(parsed.action, 'UnknownAction', `Unhandled operator action "${parsed.action}".`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return errorResult(parsed.action, 'OperatorExecutionFailed', message);
+    }
+}
+function normalizeArgs(rawArgs) {
+    if (!isObject(rawArgs))
+        return null;
+    const path = isObject(rawArgs.path) ? { ...rawArgs.path } : {};
+    const query = isObject(rawArgs.query) ? { ...rawArgs.query } : {};
+    const body = isObject(rawArgs.body) ? { ...rawArgs.body } : {};
+    for (const key of ['account_id', 'project_id', 'experience_id', 'variation_id']) {
+        if (typeof path[key] === 'undefined' && typeof rawArgs[key] !== 'undefined') {
+            path[key] = rawArgs[key];
+        }
+    }
+    return {
+        action: typeof rawArgs.action === 'string' ? rawArgs.action : String(rawArgs.action ?? ''),
+        path,
+        query,
+        body,
+        confirmation: rawArgs.confirmation,
+    };
+}
+async function projectAudit(args, context) {
+    await report(context, 'Fetching project audit resources', 1, 4);
+    const path = basePath(args);
+    const [project, domains, experiences, goals, audiences, locations, tags, features] = await Promise.all([
+        safeNamespaceCall('projects', 'get', path, undefined, { include: ['domains', 'default_goals', 'default_audiences', 'default_locations'] }),
+        safeNamespaceCall('domains', 'list', path),
+        listExperiences(path),
+        listResource('goals', path, { include: ['stats'] }),
+        listResource('audiences', path, { include: ['rules', 'stats.experiences_usage'] }),
+        listResource('locations', path, { include: ['rules', 'trigger', 'stats.experiences_usage'] }),
+        listResource('tags', path),
+        listResource('features', path, { include: ['stats'] }),
+    ]);
+    await report(context, 'Summarizing project audit resources', 3, 4);
+    const experienceItems = collectionFrom(experiences.data);
+    const goalItems = collectionFrom(goals.data);
+    const audienceItems = collectionFrom(audiences.data);
+    const locationItems = collectionFrom(locations.data);
+    const domainItems = collectionFrom(domains.data);
+    const tagItems = collectionFrom(tags.data);
+    const featureItems = features.ok ? collectionFrom(features.data) : [];
+    return {
+        project: compactEntity(objectFrom(project.data)),
+        counts: {
+            experiences: experienceItems.length,
+            experiences_by_status: countBy(experienceItems, 'status'),
+            experiences_by_type: countBy(experienceItems, 'type'),
+            goals: goalItems.length,
+            audiences: audienceItems.length,
+            locations: locationItems.length,
+            domains: domainItems.length,
+            tags: tagItems.length,
+            features: featureItems.length,
+        },
+        active_experiments: summarizeExperiences(experienceItems.filter((item) => item.status === 'active')).slice(0, 20),
+        draft_experiments: summarizeExperiences(experienceItems.filter((item) => item.status === 'draft')).slice(0, 20),
+        setup_flags: [
+            ...(domainItems.length === 0 ? ['No domains returned for this project.'] : []),
+            ...(goalItems.length === 0 ? ['No goals returned for this project.'] : []),
+            ...(locationItems.length === 0 ? ['No locations returned for this project.'] : []),
+            ...(audienceItems.length === 0 ? ['No audiences returned for this project.'] : []),
+            ...warningsFromCalls([project, domains, experiences, goals, audiences, locations, tags, features]),
+        ],
+    };
+}
+async function experimentPortfolio(args, context) {
+    await report(context, 'Fetching experiment portfolio', 1, 3);
+    const experiences = collectionFrom((await listExperiences(basePath(args), portfolioFilters(args))).data);
+    await report(context, 'Computing experiment portfolio', 2, 3);
+    const summaries = summarizeExperiences(experiences);
+    const outcomes = summaries.map((item) => item.outcome);
+    return {
+        total: summaries.length,
+        by_status: countBy(experiences, 'status'),
+        by_type: countBy(experiences, 'type'),
+        outcome_counts: countValues(outcomes),
+        completed: summaries.filter((item) => item.status === 'completed').length,
+        active: summaries.filter((item) => item.status === 'active').length,
+        draft: summaries.filter((item) => item.status === 'draft').length,
+        experiments: summaries,
+    };
+}
+async function experimentVelocity(args, context) {
+    await report(context, 'Fetching experiments for velocity report', 1, 3);
+    const experiences = collectionFrom((await listExperiences(basePath(args), portfolioFilters(args))).data);
+    const summaries = summarizeExperiences(experiences);
+    const launched = summaries.filter((item) => typeof item.start_time === 'number' && item.start_time > 0);
+    const completed = summaries.filter((item) => typeof item.end_time === 'number' && item.end_time > 0);
+    return {
+        total: summaries.length,
+        created_or_returned: summaries.length,
+        active: summaries.filter((item) => item.status === 'active').length,
+        completed: summaries.filter((item) => item.status === 'completed').length,
+        draft_backlog: summaries.filter((item) => item.status === 'draft').length,
+        average_launch_to_end_days: average(completed.map((item) => daysBetween(item.start_time, item.end_time)).filter(isFiniteNumber)),
+        launched_with_start_time: launched.length,
+        by_status: countBy(experiences, 'status'),
+        newest: summaries.slice(0, 20),
+    };
+}
+async function draftQa(args, context) {
+    await report(context, 'Fetching draft experiences for QA', 1, 3);
+    const experiences = collectionFrom((await listExperiences(basePath(args), { status: ['draft'] })).data);
+    const checks = experiences.map((experience) => ({
+        ...summarizeExperience(experience),
+        issues: draftIssues(experience),
+    }));
+    return {
+        total_drafts: checks.length,
+        needs_attention: checks.filter((item) => item.issues.length > 0),
+        passed_basic_qa: checks.filter((item) => item.issues.length === 0),
+    };
+}
+async function activeHealth(args, context) {
+    const thresholdDays = numberFrom(args.body.threshold_days ?? args.query.threshold_days, 30);
+    await report(context, 'Fetching active experiments for health check', 1, 3);
+    const experiences = collectionFrom((await listExperiences(basePath(args), { status: ['active'] })).data);
+    const checks = experiences.map((experience) => ({
+        ...summarizeExperience(experience),
+        issues: activeIssues(experience, thresholdDays),
+    }));
+    return {
+        threshold_days: thresholdDays,
+        total_active: checks.length,
+        needs_attention: checks.filter((item) => item.issues.length > 0),
+        healthy_or_waiting: checks.filter((item) => item.issues.length === 0),
+    };
+}
+async function implementationHealth(args, context) {
+    await report(context, 'Fetching project implementation evidence', 1, 4);
+    const path = basePath(args);
+    const requestedExperienceId = args.path.experience_id ?? args.body.experience_id ?? args.query.experience_id;
+    const liveDataBody = {
+        event_types: normalizeEventTypes(args.body.event_types ?? args.query.event_types),
+        expand: ['experiences', 'experiences.variation', 'conversion.goals', 'project'],
+    };
+    const [project, domains, projectLiveData] = await Promise.all([
+        safeNamespaceCall('projects', 'get', path, undefined, { include: ['domains', 'default_goals', 'default_audiences', 'default_locations'] }),
+        safeNamespaceCall('domains', 'list', path),
+        safeNamespaceCall('projects', 'get_live_data', path, liveDataBody),
+    ]);
+    const projectData = objectFrom(project.data);
+    const projectType = inferProjectType(projectData);
+    const shouldFetchFullstackResources = projectType === 'fullstack';
+    await report(context, 'Fetching type-specific implementation evidence', 2, 4);
+    const [sdkKeys, features] = shouldFetchFullstackResources
+        ? await Promise.all([
+            safeNamespaceCall('accounts', 'list_sdk_keys', path),
+            listResource('features', path, { include: ['stats'] }),
+        ])
+        : [null, null];
+    const experiencePath = requestedExperienceId
+        ? basePath(args, [], { experience_id: coerceNumberIfNumeric(requestedExperienceId) })
+        : null;
+    const [experience, experienceLiveData] = experiencePath
+        ? await Promise.all([
+            safeNamespaceCall('experiences', 'get', experiencePath, undefined, {
+                include: ['goals', 'stats', 'variations', 'variations.changes', 'audiences', 'locations', 'alerts'],
+                expand: ['goals', 'variations', 'variations.changes', 'audiences', 'locations'],
+            }),
+            safeNamespaceCall('experiences', 'get_live_data', experiencePath, liveDataBody),
+        ])
+        : [null, null];
+    await report(context, 'Summarizing implementation health', 3, 4);
+    const domainItems = collectionFrom(domains.data);
+    const projectEvents = collectionFrom(projectLiveData.data);
+    const experienceEvents = experienceLiveData ? collectionFrom(experienceLiveData.data) : [];
+    const issueList = implementationIssues({
+        project,
+        domains,
+        projectLiveData,
+        projectData,
+        projectType,
+        domainItems,
+        projectEvents,
+        experience,
+        experienceEvents,
+        sdkKeys,
+    });
+    return {
+        project: compactObject({
+            id: projectData.id,
+            name: projectData.name,
+            project_type: projectType,
+            status: projectData.status,
+            snippet: summarizeTrackingSnippet(projectData),
+        }),
+        convert_side_evidence: {
+            domains: domainItems.map((domain) => compactObject({
+                id: domain.id,
+                url: domain.url,
+                status: domain.status,
+                code_installed: domain.code_installed,
+            })),
+            project_live_data: summarizeLiveData(projectEvents),
+            experience_live_data: experienceLiveData ? summarizeLiveData(experienceEvents) : null,
+            sdk_keys: sdkKeys ? summarizeCollectionCall(sdkKeys) : null,
+            features: features ? summarizeCollectionCall(features) : null,
+            requested_experience: experience ? summarizeExperience(objectFrom(experience.data)) : null,
+        },
+        required_external_checks: implementationExternalChecks(projectType, stringFrom(args.body.url ?? args.query.url, '')),
+        issues: issueList,
+        next_steps: implementationNextSteps(projectType, issueList.length > 0),
+        limitations: [
+            'Convert MCP can verify Convert-side configuration and live-data evidence, but it does not inspect the user browser DOM or local source tree by itself.',
+            'Use browser tooling for snippet/window/network checks and filesystem tooling for SDK dependency/startup checks.',
+            'A deterministic bucketing trace requires a Convert rule-engine trace endpoint; do not fake exact exclusion reasons from static config alone.',
+        ],
+        warnings: warningsFromCalls([
+            project,
+            domains,
+            projectLiveData,
+            ...(experience ? [experience] : []),
+            ...(experienceLiveData ? [experienceLiveData] : []),
+            ...(sdkKeys ? [sdkKeys] : []),
+            ...(features ? [features] : []),
+        ]),
+    };
+}
+async function failedTestAnalysis(args, context) {
+    await report(context, 'Fetching completed and paused experiments', 1, 3);
+    const experiences = collectionFrom((await listExperiences(basePath(args), { status: ['completed', 'paused'] })).data);
+    const summaries = summarizeExperiences(experiences);
+    const losses = summaries.filter((item) => item.outcome === 'negative' || item.outcome === 'inconclusive_or_unknown');
+    return {
+        total_reviewed: summaries.length,
+        outcome_counts: countValues(summaries.map((item) => item.outcome)),
+        possible_failures: losses,
+        retest_candidates: losses.filter((item) => item.duration_days === null || item.duration_days < 14),
+        guidance: 'Treat unknown outcomes as candidates for report review, not confirmed losses. Use aggregated_report for final statistical decisions.',
+    };
+}
+async function hypothesisQualityAudit(args, context) {
+    await report(context, 'Fetching hypotheses and experiments', 1, 3);
+    const path = basePath(args);
+    const [hypotheses, experiences] = await Promise.all([
+        listResource('hypotheses', path),
+        listExperiences(path, portfolioFilters(args)),
+    ]);
+    const experienceItems = collectionFrom(experiences.data);
+    const hypothesisItems = collectionFrom(hypotheses.data);
+    const audited = hypothesisItems.map((hypothesis) => {
+        const text = [hypothesis.name, hypothesis.objective, hypothesis.description, hypothesis.summary].filter(Boolean).join(' ');
+        return {
+            id: hypothesis.id,
+            name: hypothesis.name,
+            status: hypothesis.status,
+            score: hypothesisQualityScore(text),
+            linked_experiences: Array.isArray(hypothesis.experiences) ? hypothesis.experiences : [],
+            notes: hypothesisQualityNotes(text),
+        };
+    });
+    return {
+        total_hypotheses: audited.length,
+        average_quality_score: average(audited.map((item) => item.score)),
+        quality_distribution: countValues(audited.map((item) => item.score >= 4 ? 'strong' : item.score >= 2 ? 'usable' : 'weak')),
+        hypotheses: audited,
+        experience_outcomes_by_status: countBy(experienceItems, 'status'),
+    };
+}
+async function audienceSegmentComparison(args, context) {
+    await report(context, 'Fetching base experience', 1, 4);
+    const path = basePath(args, ['experience_id']);
+    const experience = await namespaceCall('experiences', 'get', path, undefined, {
+        include: ['goals', 'stats', 'variations', 'audiences', 'locations'],
+        expand: ['goals', 'variations', 'audiences', 'locations'],
+    });
+    const segmentSets = normalizeSegmentSets(args.body.segment_sets ?? args.body.segments);
+    await report(context, 'Fetching segment reports', 2, 4);
+    const reports = [];
+    const warnings = [];
+    for (const segmentSet of segmentSets) {
+        const report = await safeNamespaceCall('experiences', 'aggregated_report', path, {
+            ...reportBodyFrom(args),
+            segments: segmentSet.segments,
+        });
+        if (report.ok) {
+            reports.push({ label: segmentSet.label, segments: segmentSet.segments, report: report.data });
+        }
+        else {
+            warnings.push(`${segmentSet.label}: ${String(report.error ?? report.text ?? 'report failed')}`);
+        }
+    }
+    return {
+        experience: summarizeExperience(objectFrom(experience.data)),
+        segment_reports: reports,
+        warnings,
+    };
+}
+async function cleanupCandidates(args, context) {
+    await report(context, 'Fetching cleanup candidates', 1, 4);
+    const path = basePath(args);
+    const staleDraftDays = numberFrom(args.body.stale_draft_days ?? args.query.stale_draft_days, 30);
+    const [drafts, goals, audiences, locations, features] = await Promise.all([
+        listExperiences(path, { status: ['draft'] }),
+        listResource('goals', path, { usage: 'not_used', status: ['active'] }),
+        listResource('audiences', path, { usage: 'not_used', status: ['active'] }),
+        listResource('locations', path, { usage: 'not_used', status: ['active'] }),
+        listResource('features', path),
+    ]);
+    const draftItems = collectionFrom(drafts.data);
+    const staleCutoff = Date.now() / 1000 - staleDraftDays * 24 * 60 * 60;
+    const staleDrafts = draftItems
+        .filter((item) => typeof item.created_at !== 'number' || item.created_at < staleCutoff)
+        .map(summarizeExperience);
+    return {
+        stale_draft_days: staleDraftDays,
+        stale_drafts: staleDrafts,
+        unused_goals: collectionFrom(goals.data).map(compactEntity),
+        unused_audiences: collectionFrom(audiences.data).map(compactEntity),
+        unused_locations: collectionFrom(locations.data).map(compactEntity),
+        feature_cleanup_guidance: features.ok
+            ? collectionFrom(features.data).map((feature) => {
+                const compact = compactEntity(feature);
+                return {
+                    ...(isObject(compact) ? compact : { value: compact }),
+                    sdk_search_patterns: feature.key ? [`${feature.key}`, `isFeatureEnabled("${feature.key}")`, `getFeature("${feature.key}")`] : [],
+                };
+            })
+            : [],
+        warnings: warningsFromCalls([drafts, goals, audiences, locations, features]),
+    };
+}
+async function getDefaults(args, context) {
+    const refresh = args.body.refresh === true || args.query.refresh === true;
+    const cacheKey = `${String(args.path.account_id)}-${String(args.path.project_id)}`;
+    if (!refresh) {
+        const cached = await readDefaultsCache(cacheKey);
+        if (cached) {
+            return { ...cached, cached: true };
+        }
+    }
+    await report(context, 'Inferring project defaults', 1, 4);
+    const path = basePath(args);
+    const [project, experiences, goals, audiences, locations] = await Promise.all([
+        safeNamespaceCall('projects', 'get', path, undefined, { include: ['domains', 'default_goals', 'default_audiences', 'default_locations'] }),
+        listExperiences(path),
+        listResource('goals', path, { status: ['active'] }),
+        listResource('audiences', path, { status: ['active'] }),
+        listResource('locations', path, { status: ['active'] }),
+    ]);
+    const projectData = objectFrom(project.data);
+    const experienceItems = collectionFrom(experiences.data);
+    const inferred = {
+        account_id: args.path.account_id,
+        project_id: args.path.project_id,
+        inferred_at: new Date().toISOString(),
+        expires_at: new Date(Date.now() + DEFAULT_CACHE_TTL_MS).toISOString(),
+        default_goal: firstEntity(projectData.default_goals) ?? mostFrequentEntity(experienceItems, 'primary_goal') ?? firstEntity(collectionFrom(goals.data)),
+        default_audience: firstEntity(projectData.default_audiences) ?? firstEntity(collectionFrom(audiences.data)),
+        default_location: firstEntity(projectData.default_locations) ?? firstEntity(collectionFrom(locations.data)),
+        default_url: mostFrequentString(experienceItems.map((item) => item.url)) ?? firstDomainUrl(projectData) ?? 'https://example.com',
+        traffic_split: { control: 50, treatment: 50 },
+        recent_name_patterns: experienceItems.map((item) => String(item.name ?? '')).filter(Boolean).slice(0, 10),
+        source_counts: {
+            experiences: experienceItems.length,
+            goals: collectionFrom(goals.data).length,
+            audiences: collectionFrom(audiences.data).length,
+            locations: collectionFrom(locations.data).length,
+        },
+        warnings: warningsFromCalls([project, experiences, goals, audiences, locations]),
+    };
+    await writeDefaultsCache(cacheKey, inferred);
+    return { ...inferred, cached: false };
+}
+async function createCustomCodeAbTest(args, context) {
+    await report(context, 'Creating draft custom-code A/B test', 1, 3);
+    const body = buildCustomCodeExperienceBody(args.body);
+    const create = await namespaceCall('experiences', 'create', basePath(args), body, {
+        include: ['variations', 'variations.changes', 'goals', 'audiences', 'locations'],
+        expand: ['variations', 'variations.changes', 'goals', 'audiences', 'locations'],
+    }, args.confirmation);
+    const experienceId = extractId(create.data);
+    const readback = experienceId
+        ? await safeNamespaceCall('experiences', 'get', basePath(args, [], { experience_id: experienceId }), undefined, {
+            include: ['variations', 'variations.changes', 'goals', 'audiences', 'locations'],
+            expand: ['variations', 'variations.changes', 'goals', 'audiences', 'locations'],
+        })
+        : null;
+    return {
+        created: create.data,
+        readback: readback?.data ?? null,
+        verified: Boolean(readback?.ok),
+        verification_detail: readback?.ok ? 'Created experience was read back successfully.' : 'Create call succeeded but no readback ID was available.',
+    };
+}
+async function createSplitUrlTest(args, context) {
+    await report(context, 'Creating draft split URL test', 1, 3);
+    const body = buildSplitUrlExperienceBody(args.body);
+    const create = await namespaceCall('experiences', 'create', basePath(args), body, {
+        include: ['variations', 'variations.changes', 'goals', 'audiences', 'locations'],
+        expand: ['variations', 'variations.changes', 'goals', 'audiences', 'locations'],
+    }, args.confirmation);
+    const experienceId = extractId(create.data);
+    const readback = experienceId
+        ? await safeNamespaceCall('experiences', 'get', basePath(args, [], { experience_id: experienceId }), undefined, {
+            include: ['variations', 'variations.changes', 'goals', 'audiences', 'locations'],
+            expand: ['variations', 'variations.changes', 'goals', 'audiences', 'locations'],
+        })
+        : null;
+    return {
+        created: create.data,
+        readback: readback?.data ?? null,
+        verified: Boolean(readback?.ok),
+        verification_detail: readback?.ok ? 'Created split URL experience was read back successfully.' : 'Create call succeeded but no readback ID was available.',
+    };
+}
+async function enableSplitUrlRegex(args, context) {
+    await report(context, 'Enabling split URL regex support', 1, 3);
+    const path = basePath(args, ['experience_id']);
+    const update = await namespaceCall('experiences', 'update', path, {
+        settings: {
+            split_url_settings: {
+                split_regex_support: args.body.split_regex_support ?? true,
+            },
+        },
+    }, undefined, args.confirmation);
+    const readback = await safeNamespaceCall('experiences', 'get', path, undefined, {
+        include: ['variations', 'variations.changes'],
+        expand: ['variations', 'variations.changes'],
+    });
+    const readbackData = objectFrom(readback.data);
+    const readbackValue = readbackData?.settings?.split_url_settings?.split_regex_support;
+    return {
+        updated: update.data,
+        readback: readback.data,
+        verified: readback.ok && (readbackValue === true || typeof readbackValue === 'undefined'),
+        verification_detail: readbackValue === true
+            ? 'Readback confirmed settings.split_url_settings.split_regex_support=true.'
+            : 'Readback succeeded, but the API response did not expose split_regex_support.',
+    };
+}
+async function safeUpdateVariationCode(args, context) {
+    await report(context, 'Updating variation custom code', 1, 3);
+    const path = basePath(args, ['experience_id', 'variation_id']);
+    const js = stringFrom(args.body.js, '');
+    const css = stringFrom(args.body.css, '');
+    const update = await namespaceCall('experiences', 'update_variation', path, {
+        changes: [
+            {
+                type: 'customCode',
+                data: { js, css },
+            },
+        ],
+    }, undefined, args.confirmation);
+    const readback = await safeNamespaceCall('experiences', 'get', basePath(args, ['experience_id']), undefined, {
+        include: ['variations', 'variations.changes'],
+        expand: ['variations', 'variations.changes'],
+    });
+    return {
+        updated: update.data,
+        readback: readback.data,
+        verified: readback.ok && containsCustomCode(readback.data, args.path.variation_id, js, css),
+        verification_detail: readback.ok
+            ? 'Experience readback completed after variation update.'
+            : 'Variation update succeeded but readback failed.',
+    };
+}
+function buildCustomCodeExperienceBody(input) {
+    const name = stringFrom(input.name, 'Draft Custom Code A/B Test');
+    const url = stringFrom(input.url, 'https://example.com');
+    const js = stringFrom(input.js, '');
+    const css = stringFrom(input.css, '');
+    const controlName = stringFrom(input.control_name, 'control');
+    const variationName = stringFrom(input.variation_name, 'Treatment');
+    const rawVariations = Array.isArray(input.variations) ? input.variations : null;
+    return compactObject({
+        name,
+        type: 'a/b',
+        status: 'draft',
+        url,
+        description: input.description,
+        objective: input.objective,
+        primary_goal: input.primary_goal,
+        goals: input.goals,
+        audiences: input.audiences,
+        locations: input.locations,
+        settings: input.settings,
+        variations: rawVariations ?? [
+            { name: controlName, changes: [{ type: 'customCode', data: { js: '', css: '' } }] },
+            { name: variationName, changes: [{ type: 'customCode', data: { js, css } }] },
+        ],
+    });
+}
+function buildSplitUrlExperienceBody(input) {
+    const name = stringFrom(input.name, 'Draft Split URL Test');
+    const originalPattern = stringFrom(input.original_pattern ?? input.url, 'https://example.com');
+    const variationPattern = stringFrom(input.variation_pattern ?? input.redirect_url, 'https://example.com/variant');
+    const url = stringFrom(input.url, originalPattern);
+    const splitRegexSupport = input.split_regex_support === true;
+    return compactObject({
+        name,
+        type: 'split_url',
+        status: 'draft',
+        url,
+        description: input.description,
+        objective: input.objective,
+        primary_goal: input.primary_goal,
+        goals: input.goals,
+        audiences: input.audiences,
+        locations: input.locations,
+        settings: splitRegexSupport ? { split_url_settings: { split_regex_support: true } } : input.settings,
+        variations: Array.isArray(input.variations) ? input.variations : [
+            {
+                name: stringFrom(input.variation_name, 'Variation URL'),
+                changes: [
+                    {
+                        type: 'defaultRedirect',
+                        data: {
+                            original_pattern: originalPattern,
+                            variation_pattern: variationPattern,
+                            case_sensitive: input.case_sensitive === true,
+                        },
+                    },
+                ],
+            },
+        ],
+    });
+}
+async function listExperiences(path, filters = {}) {
+    return safeNamespaceCall('experiences', 'list', path, {
+        results_per_page: DEFAULT_RESULTS_PER_PAGE,
+        sort_by: 'id',
+        sort_direction: 'desc',
+        include: ['goals', 'stats', 'variations', 'variations.changes', 'audiences', 'locations', 'alerts'],
+        expand: ['goals', 'variations', 'variations.changes', 'audiences', 'locations', 'tags'],
+        ...filters,
+    });
+}
+async function listResource(namespace, path, body = {}) {
+    return safeNamespaceCall(namespace, 'list', path, {
+        results_per_page: DEFAULT_RESULTS_PER_PAGE,
+        sort_by: body.sort_by ?? 'id',
+        sort_direction: body.sort_direction ?? 'desc',
+        ...body,
+    });
+}
+async function namespaceCall(namespace, action, path, body, query, confirmation) {
+    const result = await executeNamespacedTool(namespace, {
+        action,
+        path,
+        ...(query ? { query } : {}),
+        ...(typeof body !== 'undefined' ? { body } : {}),
+        ...(typeof confirmation !== 'undefined' ? { confirmation } : {}),
+    });
+    const structured = isObject(result.structuredContent) ? result.structuredContent : {};
+    const text = result.content?.[0]?.type === 'text' ? result.content[0].text : undefined;
+    if (result.isError || structured.ok === false) {
+        return {
+            ok: false,
+            namespace,
+            action,
+            status: typeof structured.status === 'number' ? structured.status : undefined,
+            error: structured.error ?? text ?? 'Unknown error',
+            text,
+        };
+    }
+    return {
+        ok: true,
+        namespace,
+        action,
+        status: typeof structured.status === 'number' ? structured.status : undefined,
+        data: structured.data,
+        text,
+    };
+}
+async function safeNamespaceCall(namespace, action, path, body, query) {
+    try {
+        return await namespaceCall(namespace, action, path, body, query);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            namespace,
+            action,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function portfolioFilters(args) {
+    const out = {};
+    for (const key of ['status', 'type', 'tags', 'audiences', 'goals', 'locations', 'features', 'hypotheses']) {
+        const value = args.body[key] ?? args.query[key];
+        if (typeof value !== 'undefined')
+            out[key] = value;
+    }
+    return out;
+}
+function basePath(args, extra = [], override = {}) {
+    const path = {
+        account_id: coerceNumberIfNumeric(args.path.account_id),
+        project_id: coerceNumberIfNumeric(args.path.project_id),
+        ...override,
+    };
+    for (const key of extra) {
+        path[key] = coerceNumberIfNumeric(args.path[key]);
+    }
+    return path;
+}
+function summarizeExperiences(experiences) {
+    return experiences.map(summarizeExperience);
+}
+function summarizeExperience(experience) {
+    const start = numberOrNull(experience.start_time ?? experience.min_running_timestamp);
+    const end = numberOrNull(experience.end_time ?? experience.max_running_timestamp);
+    const durationDays = daysBetween(start, end ?? Math.floor(Date.now() / 1000));
+    return {
+        id: experience.id,
+        key: experience.key,
+        name: experience.name,
+        type: experience.type,
+        status: experience.status,
+        url: experience.url,
+        primary_goal: compactEntity(experience.primary_goal),
+        goals: collectionFrom(experience.goals).map(compactEntity),
+        audiences: collectionFrom(experience.audiences).map(compactEntity),
+        locations: collectionFrom(experience.locations).map(compactEntity),
+        variations: collectionFrom(experience.variations).map((variation) => ({
+            id: variation.id,
+            name: variation.name,
+            status: variation.status,
+            traffic_distribution: variation.traffic_distribution ?? variation.traffic_percentage,
+            changes_count: collectionFrom(variation.changes).length,
+        })),
+        start_time: start,
+        end_time: end,
+        duration_days: isFiniteNumber(durationDays) ? durationDays : null,
+        outcome: inferOutcome(experience),
+        alerts: collectionFrom(experience.alerts),
+    };
+}
+function draftIssues(experience) {
+    const issues = [];
+    if (!experience.url)
+        issues.push('Missing URL.');
+    if (collectionFrom(experience.variations).length < 2)
+        issues.push('Fewer than two variations.');
+    if (collectionFrom(experience.goals).length === 0 && !experience.primary_goal)
+        issues.push('No goals or primary goal returned.');
+    if (collectionFrom(experience.locations).length === 0)
+        issues.push('No locations returned.');
+    if (collectionFrom(experience.audiences).length === 0)
+        issues.push('No audiences returned.');
+    if (collectionFrom(experience.alerts).length > 0)
+        issues.push('Experience has alerts.');
+    return issues;
+}
+function activeIssues(experience, thresholdDays) {
+    const summary = summarizeExperience(experience);
+    const issues = [];
+    if (typeof summary.duration_days === 'number' && summary.duration_days > thresholdDays) {
+        issues.push(`Running longer than ${thresholdDays} days.`);
+    }
+    issues.push(...draftIssues(experience).filter((issue) => issue !== 'No audiences returned.' && issue !== 'No locations returned.'));
+    const traffic = collectionFrom(experience.variations)
+        .map((variation) => numberOrNull(variation.traffic_distribution ?? variation.traffic_percentage))
+        .filter(isFiniteNumber);
+    if (traffic.length > 1) {
+        const expected = 100 / traffic.length;
+        if (traffic.some((value) => Math.abs(value - expected) > 5)) {
+            issues.push('Variation traffic allocation appears uneven.');
+        }
+    }
+    return issues;
+}
+function normalizeEventTypes(input) {
+    if (Array.isArray(input)) {
+        const values = input.filter((value) => typeof value === 'string' && value.trim().length > 0);
+        return values.length > 0 ? values : ['view_experience', 'conversion', 'transaction'];
+    }
+    return ['view_experience', 'conversion', 'transaction'];
+}
+function inferProjectType(project) {
+    const explicit = String(project.project_type ?? '').toLowerCase();
+    if (explicit.includes('full'))
+        return 'fullstack';
+    if (explicit.includes('web'))
+        return 'web';
+    return typeof project.sdk_key === 'string' && project.sdk_key ? 'fullstack' : 'web';
+}
+function summarizeTrackingSnippet(project) {
+    const snippet = typeof project.tracking_snippet === 'string' ? project.tracking_snippet : '';
+    const srcs = [...snippet.matchAll(/src=["']([^"']+)["']/gi)].map((match) => match[1]).filter(Boolean);
+    return {
+        configured: snippet.trim().length > 0,
+        contains_convert_source: /convert\.com|cdn\.convert/i.test(snippet),
+        script_sources: srcs,
+        length: snippet.length,
+    };
+}
+function summarizeLiveData(events) {
+    const timestamps = events.map(liveEventTimestamp).filter(isFiniteNumber);
+    const newest = timestamps.length > 0 ? Math.max(...timestamps) : null;
+    return {
+        events_returned: events.length,
+        events_by_type: countValues(events.map(liveEventType)),
+        latest_timestamp: newest,
+        latest_iso: newest ? unixToIso(newest) : null,
+        sample: events.slice(0, 5).map((event) => compactObject({
+            event_type: liveEventType(event),
+            timestamp: liveEventTimestamp(event),
+            experience: compactEntity(event.experience),
+            variation: compactEntity(event.variation ?? event.experiences?.variation),
+            goal: compactEntity(event.goal ?? event.conversion?.goal),
+            project: compactEntity(event.project),
+        })),
+    };
+}
+function summarizeCollectionCall(call) {
+    const items = collectionFrom(call.data);
+    return {
+        ok: call.ok,
+        count: items.length,
+        sample: items.slice(0, 10).map(compactEntity),
+        ...(call.ok ? {} : { error: call.error ?? call.text ?? 'failed' }),
+    };
+}
+function implementationExternalChecks(projectType, url) {
+    if (projectType === 'fullstack') {
+        return {
+            local_code_checks: [
+                'Inspect package dependencies for the relevant Convert Full Stack SDK.',
+                'Verify SDK initialization runs once during startup and waits for configuration readiness before bucketing.',
+                'Verify bucketing calls pass the intended visitor_id and audience attributes.',
+                'Verify conversion tracking calls use the intended goal keys or IDs after the business event completes.',
+            ],
+            browser_checks: [],
+        };
+    }
+    return {
+        browser_checks: [
+            `Load ${url || 'the target page'} with browser automation and confirm the Convert script source from project.tracking_snippet appears in the document head.`,
+            'Check window.convert readiness after load and inspect console/network errors for blocked or failed Convert resources.',
+            'For a specific experience, force or preview the variation and verify the intended DOM/CSS changes apply after dynamic page content has loaded.',
+            'Trigger the relevant goal action and re-check Convert live data for view_experience/conversion events.',
+        ],
+        local_code_checks: [],
+    };
+}
+function implementationNextSteps(projectType, hasIssues) {
+    const shared = [
+        'Use search/fetch for the latest Convert implementation docs before generating code.',
+        'After changing setup, re-run operator.implementation_health and compare live-data evidence.',
+    ];
+    if (projectType === 'fullstack') {
+        return [
+            ...(hasIssues ? ['Fix missing SDK/live-data evidence before debugging experiment logic.'] : []),
+            'Use filesystem tooling to inspect SDK dependency, initialization, visitor attributes, and track calls.',
+            'If the user needs exact "why not bucketed" output, request or use a backend rule-engine trace endpoint.',
+            ...shared,
+        ];
+    }
+    return [
+        ...(hasIssues ? ['Fix snippet/domain/live-data evidence before deeper visual QA.'] : []),
+        'Use browser tooling for snippet-in-head, window.convert, network, console, preview/forced variation, and DOM assertions.',
+        'Prefer programmatic/callback triggers when dynamic content loads after the standard page trigger.',
+        ...shared,
+    ];
+}
+function implementationIssues(input) {
+    const issues = [];
+    if (!input.project.ok)
+        issues.push('Could not fetch project configuration.');
+    if (!input.domains.ok)
+        issues.push('Could not fetch project domains.');
+    if (!input.projectLiveData.ok)
+        issues.push('Could not fetch project live data.');
+    if (input.projectLiveData.ok && input.projectEvents.length === 0) {
+        issues.push('No project live-data events returned; verify traffic, environment, snippet/SDK installation, and ad/script blockers.');
+    }
+    if (input.projectType === 'web') {
+        const snippet = summarizeTrackingSnippet(input.projectData);
+        if (snippet.configured !== true) {
+            issues.push('Project response did not expose a tracking_snippet; browser snippet checks need the project script source from Convert.');
+        }
+        if (input.domainItems.length > 0 && !input.domainItems.some((domain) => domain.code_installed === true)) {
+            issues.push('No returned domain has code_installed=true.');
+        }
+    }
+    else if (input.sdkKeys?.ok && collectionFrom(input.sdkKeys.data).length === 0) {
+        issues.push('No SDK keys returned for this fullstack project.');
+    }
+    if (input.experience && !input.experience.ok) {
+        issues.push('Could not fetch requested experience configuration.');
+    }
+    if (input.experience?.ok && input.experienceEvents.length === 0) {
+        issues.push('No live-data events returned for the requested experience.');
+    }
+    return issues;
+}
+function liveEventType(event) {
+    return String(event.event_type ?? event.eventType ?? event.event ?? event.type ?? 'unknown');
+}
+function liveEventTimestamp(event) {
+    return numberOrNull(event.timestamp ?? event.created_at ?? event.time ?? event.received_at);
+}
+function unixToIso(timestamp) {
+    const millis = timestamp > 1000000000000 ? timestamp : timestamp * 1000;
+    return new Date(millis).toISOString();
+}
+function inferOutcome(experience) {
+    const candidates = [
+        experience.outcome,
+        experience.result,
+        experience.winner,
+        experience.stats?.outcome,
+        experience.stats?.result,
+    ].filter(Boolean).map(String).join(' ').toLowerCase();
+    if (/(winner|won|positive|significant|lift)/.test(candidates) && !/(loss|negative)/.test(candidates))
+        return 'positive';
+    if (/(loser|lost|negative|harm)/.test(candidates))
+        return 'negative';
+    if (String(experience.status ?? '').toLowerCase() === 'completed')
+        return 'completed_unknown';
+    return 'inconclusive_or_unknown';
+}
+function normalizeSegmentSets(input) {
+    if (Array.isArray(input)) {
+        return input
+            .filter(isObject)
+            .map((item, index) => ({
+            label: stringFrom(item.label, `segment_${index + 1}`),
+            segments: isObject(item.segments) ? item.segments : item,
+        }));
+    }
+    if (isObject(input)) {
+        return [{ label: 'custom', segments: input }];
+    }
+    return [
+        { label: 'desktop', segments: { devices: ['desktop'] } },
+        { label: 'phones', segments: { devices: ['all_phones'] } },
+        { label: 'tablets', segments: { devices: ['all_tablets'] } },
+    ];
+}
+function reportBodyFrom(args) {
+    const body = {};
+    for (const key of ['goals', 'metrics', 'start_time', 'end_time', 'utc_offset', 'stats_engine_processing']) {
+        if (typeof args.body[key] !== 'undefined')
+            body[key] = args.body[key];
+    }
+    return body;
+}
+function hypothesisQualityScore(text) {
+    let score = 0;
+    if (text.length > 80)
+        score += 1;
+    if (/\b(because|due to|data|observed|evidence|research)\b/i.test(text))
+        score += 1;
+    if (/\b(increase|decrease|improve|reduce|lift|conversion|revenue|click)\b/i.test(text))
+        score += 1;
+    if (/\b(by|from|to|percent|%|rate|rpv|aov)\b/i.test(text))
+        score += 1;
+    if (/\b(if|then|expect|hypothesis)\b/i.test(text))
+        score += 1;
+    return score;
+}
+function hypothesisQualityNotes(text) {
+    const notes = [];
+    if (text.length <= 80)
+        notes.push('Hypothesis is short; may not capture problem, change, and expected impact.');
+    if (!/\b(because|due to|data|observed|evidence|research)\b/i.test(text))
+        notes.push('No clear evidence or rationale language found.');
+    if (!/\b(increase|decrease|improve|reduce|lift|conversion|revenue|click)\b/i.test(text))
+        notes.push('No explicit metric or behavior impact language found.');
+    if (!/\b(if|then|expect|hypothesis)\b/i.test(text))
+        notes.push('No explicit if/then or expectation structure found.');
+    return notes;
+}
+function objectFrom(value) {
+    if (Array.isArray(value))
+        return isObject(value[0]) ? value[0] : {};
+    if (!isObject(value))
+        return {};
+    if (isObject(value.data) && !Array.isArray(value.data))
+        return value.data;
+    return value;
+}
+function collectionFrom(value) {
+    if (Array.isArray(value))
+        return value.filter(isObject);
+    if (!isObject(value))
+        return [];
+    if (Array.isArray(value.data))
+        return value.data.filter(isObject);
+    if (Array.isArray(value.items))
+        return value.items.filter(isObject);
+    if (Array.isArray(value.results))
+        return value.results.filter(isObject);
+    return [];
+}
+function compactEntity(value) {
+    if (typeof value === 'number' || typeof value === 'string')
+        return value;
+    if (!isObject(value))
+        return null;
+    return compactObject({
+        id: value.id,
+        key: value.key,
+        name: value.name,
+        status: value.status,
+        type: value.type ?? value.goal_type,
+        url: value.url,
+    });
+}
+function compactObject(value) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (typeof item !== 'undefined' && item !== null)
+            out[key] = item;
+    }
+    return out;
+}
+function countBy(items, key) {
+    return countValues(items.map((item) => item[key]));
+}
+function countValues(values) {
+    const out = {};
+    for (const value of values) {
+        const key = String(value ?? 'unknown');
+        out[key] = (out[key] ?? 0) + 1;
+    }
+    return out;
+}
+function warningsFromCalls(calls) {
+    return calls
+        .filter((call) => !call.ok)
+        .map((call) => `${call.namespace}.${call.action}: ${String(call.error ?? call.text ?? 'failed')}`);
+}
+function daysBetween(start, end) {
+    const startNum = numberOrNull(start);
+    const endNum = numberOrNull(end);
+    if (!isFiniteNumber(startNum) || !isFiniteNumber(endNum) || endNum < startNum)
+        return null;
+    return Math.round(((endNum - startNum) / 86400) * 10) / 10;
+}
+function average(values) {
+    const finite = values.filter(isFiniteNumber);
+    if (finite.length === 0)
+        return null;
+    return Math.round((finite.reduce((sum, value) => sum + value, 0) / finite.length) * 100) / 100;
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function numberOrNull(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function numberFrom(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+function stringFrom(value, fallback) {
+    return typeof value === 'string' && value.trim() ? value.trim() : fallback;
+}
+function coerceNumberIfNumeric(value) {
+    if (typeof value !== 'string')
+        return value;
+    if (!/^\d+$/.test(value))
+        return value;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : value;
+}
+function firstEntity(value) {
+    const items = collectionFrom(value);
+    if (items.length > 0)
+        return compactEntity(items[0]);
+    if (Array.isArray(value) && value.length > 0)
+        return compactEntity(value[0]);
+    return null;
+}
+function mostFrequentEntity(items, key) {
+    const counts = new Map();
+    for (const item of items) {
+        const value = item[key];
+        if (typeof value === 'undefined' || value === null)
+            continue;
+        const id = JSON.stringify(compactEntity(value));
+        const current = counts.get(id);
+        counts.set(id, { count: (current?.count ?? 0) + 1, value });
+    }
+    return [...counts.values()].sort((a, b) => b.count - a.count)[0]?.value ?? null;
+}
+function mostFrequentString(values) {
+    const counts = new Map();
+    for (const value of values) {
+        if (typeof value !== 'string' || !value.trim())
+            continue;
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    }
+    return [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
+}
+function firstDomainUrl(project) {
+    const domains = collectionFrom(project.domains);
+    const domain = domains.find((item) => typeof item.url === 'string' && item.url);
+    return typeof domain?.url === 'string' ? domain.url : null;
+}
+function extractId(data) {
+    const obj = objectFrom(data);
+    return obj.id ?? obj.experience_id ?? obj.data?.id;
+}
+function containsCustomCode(data, variationId, js, css) {
+    const experience = objectFrom(data);
+    const variations = collectionFrom(experience.variations);
+    const target = variations.find((variation) => String(variation.id) === String(variationId));
+    if (!target)
+        return false;
+    return collectionFrom(target.changes).some((change) => {
+        if (change.type !== 'customCode' || !isObject(change.data))
+            return false;
+        return String(change.data.js ?? '') === js && String(change.data.css ?? '') === css;
+    });
+}
+async function readDefaultsCache(cacheKey) {
+    try {
+        const raw = await readFile(defaultsCachePath(cacheKey), 'utf8');
+        const parsed = JSON.parse(raw);
+        const expiresAt = typeof parsed.expires_at === 'string' ? Date.parse(parsed.expires_at) : 0;
+        if (!Number.isFinite(expiresAt) || expiresAt <= Date.now())
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeDefaultsCache(cacheKey, data) {
+    const dir = join(homedir(), '.convert', 'convert-mcp-defaults');
+    await mkdir(dir, { recursive: true });
+    await writeFile(defaultsCachePath(cacheKey), JSON.stringify(data, null, 2));
+}
+function defaultsCachePath(cacheKey) {
+    return join(homedir(), '.convert', 'convert-mcp-defaults', `${cacheKey.replace(/[^a-zA-Z0-9_.-]/g, '_')}.json`);
+}
+async function report(context, message, progress, total) {
+    if (!context.progress)
+        return;
+    await context.progress(message, progress, total);
+}
+function okResult(action, data) {
+    const payload = {
+        ok: true,
+        namespace: 'operator',
+        action,
+        delegate: 'operator',
+        status: 200,
+        data,
+        ...(typeof data.verified === 'boolean' ? { verified: data.verified } : {}),
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload) }],
+        structuredContent: payload,
+    };
+}
+function errorResult(action, code, message, extra = {}) {
+    const payload = {
+        ok: false,
+        namespace: 'operator',
+        action,
+        delegate: 'operator',
+        status: 400,
+        error: code,
+        message,
+        ...extra,
+    };
+    return {
+        isError: true,
+        content: [{ type: 'text', text: JSON.stringify(payload) }],
+        structuredContent: payload,
+    };
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=operator.js.map