@analyticscli/growth-engineer 0.1.0-preview.15 → 0.1.0-preview.18

package/dist/runtime/openclaw-exporters-lib.mjs

@@ -100,6 +100,21 @@ function buildRetentionQualityEvidence(retention) {
     }
     return evidence;
 }
+function hasRetentionIdentityPersistenceGap(retention) {
+    const reliability = normalizeRetentionReliability(retention);
+    if (reliability !== 'low' && reliability !== 'unknown') {
+        return false;
+    }
+    const stableShare = coerceNumber(retention?.quality?.stableIdentityShare);
+    const multiSessionShare = coerceNumber(retention?.quality?.multiSessionShare);
+    if (stableShare !== null && stableShare >= 0.5) {
+        return false;
+    }
+    if (multiSessionShare !== null && multiSessionShare >= 0.2) {
+        return false;
+    }
+    return true;
+}
 function maybePushSignal(signals, signal) {
     if (!signal)
         return;
@@ -230,42 +245,68 @@ export function buildAnalyticsSummary(input) {
     const retentionReliability = normalizeRetentionReliability(retention);
     const retentionHasLowConfidence = retentionReliability === 'low' || retentionReliability === 'unknown';
     const retentionQualityEvidence = buildRetentionQualityEvidence(retention);
+    const retentionIdentityPersistenceGap = hasRetentionIdentityPersistenceGap(retention);
     if (hasMinimumSample(retention?.cohortSize)) {
-        for (const target of retentionTargets) {
-            const actual = retentionByDay.get(target.day);
-            if (actual === undefined || actual >= target.baseline) {
-                continue;
-            }
+        if (retentionIdentityPersistenceGap) {
             maybePushSignal(signals, {
-                id: `retention_d${target.day}_below_target`,
-                title: retentionHasLowConfidence
-                    ? `Day-${target.day} retention appears below target, but identity quality is low`
-                    : `Day-${target.day} retention is below target`,
-                area: 'retention',
-                priority: retentionHasLowConfidence ? 'medium' : target.day >= 3 ? 'high' : 'medium',
-                metric: `d${target.day}_retention`,
-                current_value: round(actual),
-                baseline_value: target.baseline,
-                delta_percent: computeDeltaPercent(actual, target.baseline),
+                id: 'analytics_identity_persistence_missing',
+                title: 'Analytics identity persistence is missing; D7 retention is not reliable',
+                area: 'analytics_anomaly',
+                priority: 'high',
+                metric: 'retention_identity_quality',
+                current_value: coerceNumber(retention?.quality?.stableIdentityShare) || 0,
+                baseline_value: 0.5,
+                delta_percent: computeDeltaPercent(coerceNumber(retention?.quality?.stableIdentityShare) || 0, 0.5),
                 evidence: [
                     `Retention cohort size: ${retention.cohortSize}`,
-                    `Observed D${target.day} retention: ${(actual * 100).toFixed(2)}%`,
                     ...retentionQualityEvidence,
-                    retention?.avgActiveDays !== undefined
-                        ? `Average active days in the cohort: ${retention.avgActiveDays}`
-                        : null,
+                    'D1/D7 retention is suppressed from product findings until the host app persists a stable SDK identity.',
                 ].filter(Boolean),
                 suggested_actions: [
-                    retentionHasLowConfidence
-                        ? 'Verify SDK identity persistence and rerun retention with stable identity filtering before treating D1/D7 as a product fact'
-                        : null,
-                    'Revisit the first-session value loop and ensure the core action completes quickly',
-                    'Add targeted re-entry prompts or reminders after the first session',
-                    'Instrument the major early-session drop-off points to isolate which step drives the retention loss',
-                ].filter(Boolean),
-                keywords: ['retention', 'engagement', 'activation', `d${target.day}`],
+                    'Enable persistent AnalyticsCLI SDK identity in the host app before evaluating D1/D7 retention',
+                    'Verify new release events carry identityQuality=persistent or identified instead of ephemeral or unknown',
+                    'Rerun retention after at least one cohort has stable identity coverage',
+                ],
+                keywords: ['analyticscli', 'identity', 'persistence', 'retention', 'd7'],
             });
-            break;
+        }
+        else {
+            for (const target of retentionTargets) {
+                const actual = retentionByDay.get(target.day);
+                if (actual === undefined || actual >= target.baseline) {
+                    continue;
+                }
+                maybePushSignal(signals, {
+                    id: `retention_d${target.day}_below_target`,
+                    title: retentionHasLowConfidence
+                        ? `Day-${target.day} retention appears below target, but identity quality is low`
+                        : `Day-${target.day} retention is below target`,
+                    area: 'retention',
+                    priority: retentionHasLowConfidence ? 'medium' : target.day >= 3 ? 'high' : 'medium',
+                    metric: `d${target.day}_retention`,
+                    current_value: round(actual),
+                    baseline_value: target.baseline,
+                    delta_percent: computeDeltaPercent(actual, target.baseline),
+                    evidence: [
+                        `Retention cohort size: ${retention.cohortSize}`,
+                        `Observed D${target.day} retention: ${(actual * 100).toFixed(2)}%`,
+                        ...retentionQualityEvidence,
+                        retention?.avgActiveDays !== undefined
+                            ? `Average active days in the cohort: ${retention.avgActiveDays}`
+                            : null,
+                    ].filter(Boolean),
+                    suggested_actions: [
+                        retentionHasLowConfidence
+                            ? 'Verify SDK identity persistence and rerun retention with stable identity filtering before treating D1/D7 as a product fact'
+                            : null,
+                        'Revisit the first-session value loop and ensure the core action completes quickly',
+                        'Add targeted re-entry prompts or reminders after the first session',
+                        'Instrument the major early-session drop-off points to isolate which step drives the retention loss',
+                    ].filter(Boolean),
+                    keywords: ['retention', 'engagement', 'activation', `d${target.day}`],
+                });
+                break;
+            }
         }
     }
     return {
@@ -319,6 +360,42 @@ function collectStatusEntries(payload) {
     });
     return entries;
 }
+function normalizeVersionToken(value) {
+    const normalized = String(value || '').trim();
+    if (!normalized)
+        return '';
+    const match = normalized.match(/\b\d+(?:\.\d+){1,3}(?:\+\d+)?\b/);
+    return match ? match[0] : '';
+}
+function collectAscProductionVersions(payload) {
+    const candidates = [];
+    walk(payload, (value, pathParts, key) => {
+        if (typeof value !== 'string' && typeof value !== 'number')
+            return;
+        const normalizedKey = String(key || '').toLowerCase();
+        if (!/(version|string|build|release)/.test(normalizedKey))
+            return;
+        const version = normalizeVersionToken(value);
+        if (!version)
+            return;
+        const pathText = pathParts.join('.').toLowerCase();
+        const parentPath = pathParts.slice(0, -1).join('.').toLowerCase();
+        const context = String(JSON.stringify(resolvePathPayload(payload, pathParts.slice(0, -1))) || '').toLowerCase();
+        if (/(ready_for_sale|readyforsale|approved|active|available|current|live|production)/.test(`${pathText} ${parentPath} ${context}`)) {
+            candidates.push(version);
+        }
+    });
+    return [...new Set(candidates)].sort();
+}
+function resolvePathPayload(payload, pathParts) {
+    let current = payload;
+    for (const part of pathParts) {
+        if (!current || typeof current !== 'object')
+            return null;
+        current = current[part];
+    }
+    return current;
+}
 function classifyAscStatus(value) {
     const normalized = String(value || '')
         .trim()
@@ -590,6 +667,7 @@ function formatPercent(value) {
 export function buildAscSummary(input) {
     const appId = String(input?.appId || 'ASC_APP_ID').trim() || 'ASC_APP_ID';
     const statusEntries = collectStatusEntries(input?.statusPayload);
+    const productionVersions = collectAscProductionVersions(input?.statusPayload);
     const blockingStatuses = statusEntries.filter((entry) => classifyAscStatus(entry.value) === 'blocking');
     const watchStatuses = statusEntries.filter((entry) => classifyAscStatus(entry.value) === 'watch');
     const averageRatingCandidates = findNumbersByCandidateKeys(input?.ratingsPayload, [
@@ -891,6 +969,7 @@ export function buildAscSummary(input) {
             analyticsAvailability,
             analyticsWarnings,
             batchReports,
+            productionVersions,
             analytics: {
                 units: unitsMetric
                     ? {
@@ -1094,6 +1173,399 @@ export function buildRevenueCatSummary(input) {
         },
     };
 }
+function metricSeries(payload) {
+    if (Array.isArray(payload?.data?.timeseries))
+        return payload.data.timeseries;
+    if (Array.isArray(payload?.timeseries))
+        return payload.timeseries;
+    return [];
+}
+function metricCurrency(payload) {
+    return String(payload?.data?.currency_code || payload?.currency_code || '').trim();
+}
+function metricUpdatedAt(payload) {
+    return String(payload?.data?.updated_at || payload?.updated_at || '').trim();
+}
+function amountValue(value) {
+    const numeric = coerceNumber(value);
+    return numeric === null ? 0 : numeric;
+}
+function sumAmounts(series) {
+    return series.reduce((total, point) => total + amountValue(point?.amount), 0);
+}
+function sumCounts(series, key = 'count') {
+    return series.reduce((total, point) => total + (coerceNumber(point?.[key]) || 0), 0);
+}
+function firstLastNumeric(series, key) {
+    const values = series
+        .map((point) => coerceNumber(point?.[key]))
+        .filter((value) => value !== null);
+    if (values.length === 0)
+        return { first: null, last: null, deltaPercent: null };
+    const first = values[0];
+    const last = values[values.length - 1];
+    return {
+        first,
+        last,
+        deltaPercent: computeDeltaPercent(last, first),
+    };
+}
+function formatMinorCurrency(amount, currencyCode) {
+    const currency = String(currencyCode || '').trim().toUpperCase();
+    const value = amountValue(amount) / 100;
+    if (!currency)
+        return String(value);
+    try {
+        return new Intl.NumberFormat('en-US', { style: 'currency', currency }).format(value);
+    }
+    catch {
+        return `${value.toFixed(2)} ${currency}`;
+    }
+}
+export function buildPaddleSummary(input) {
+    const revenue = input?.metrics?.revenue || null;
+    const mrr = input?.metrics?.monthlyRecurringRevenue || null;
+    const activeSubscribers = input?.metrics?.activeSubscribers || null;
+    const refunds = input?.metrics?.refunds || null;
+    const chargebacks = input?.metrics?.chargebacks || null;
+    const checkoutConversion = input?.metrics?.checkoutConversion || null;
+    const warnings = Array.isArray(input?.warnings) ? input.warnings.filter(Boolean).map(String) : [];
+    const window = String(input?.window || 'last_30d');
+    const currency = metricCurrency(revenue) || metricCurrency(mrr) || metricCurrency(refunds) || '';
+    const revenueSeries = metricSeries(revenue);
+    const mrrSeries = metricSeries(mrr);
+    const subscriberSeries = metricSeries(activeSubscribers);
+    const refundSeries = metricSeries(refunds);
+    const chargebackSeries = metricSeries(chargebacks);
+    const checkoutSeries = metricSeries(checkoutConversion);
+    const signals = [];
+    const totalRevenue = sumAmounts(revenueSeries);
+    const transactionCount = sumCounts(revenueSeries);
+    if (revenueSeries.length > 0) {
+        const midpoint = Math.floor(revenueSeries.length / 2);
+        const firstHalf = sumAmounts(revenueSeries.slice(0, midpoint || revenueSeries.length));
+        const secondHalf = midpoint > 0 ? sumAmounts(revenueSeries.slice(midpoint)) : totalRevenue;
+        const delta = midpoint > 0 ? computeDeltaPercent(secondHalf, firstHalf) : null;
+        maybePushSignal(signals, {
+            id: 'paddle_revenue_trend',
+            title: delta !== null && delta < -20 ? 'Paddle revenue dropped versus the prior part of the window' : 'Paddle revenue metrics are connected',
+            area: 'revenue',
+            priority: delta !== null && delta < -20 ? 'high' : totalRevenue > 0 ? 'medium' : 'low',
+            metric: 'paddle_revenue',
+            current_value: totalRevenue,
+            baseline_value: firstHalf || null,
+            delta_percent: delta,
+            evidence: [
+                `Revenue in window: ${formatMinorCurrency(totalRevenue, currency)}`,
+                `Completed payment count: ${transactionCount}`,
+                delta !== null ? `Recent-half revenue delta: ${delta}%` : null,
+            ].filter(Boolean),
+            suggested_actions: [
+                'Compare Paddle revenue movement with AnalyticsCLI checkout and activation funnels',
+                'Segment revenue movement by recent releases, traffic sources, and pricing page changes before changing pricing',
+            ],
+            keywords: ['paddle', 'revenue', 'checkout', 'billing'],
+            confidence: transactionCount > 0 ? 'high' : 'medium',
+        });
+    }
+    const mrrTrend = firstLastNumeric(mrrSeries, 'amount');
+    if (mrrTrend.last !== null) {
+        maybePushSignal(signals, {
+            id: 'paddle_mrr_trend',
+            title: mrrTrend.deltaPercent !== null && mrrTrend.deltaPercent < -10 ? 'Paddle MRR is contracting' : 'Paddle MRR is available for subscription analysis',
+            area: mrrTrend.deltaPercent !== null && mrrTrend.deltaPercent < -10 ? 'retention' : 'revenue',
+            priority: mrrTrend.deltaPercent !== null && mrrTrend.deltaPercent < -10 ? 'high' : 'medium',
+            metric: 'paddle_mrr',
+            current_value: mrrTrend.last,
+            baseline_value: mrrTrend.first,
+            delta_percent: mrrTrend.deltaPercent,
+            evidence: [
+                `MRR start: ${formatMinorCurrency(mrrTrend.first, currency)}`,
+                `MRR end: ${formatMinorCurrency(mrrTrend.last, currency)}`,
+                mrrTrend.deltaPercent !== null ? `MRR delta: ${mrrTrend.deltaPercent}%` : null,
+            ].filter(Boolean),
+            suggested_actions: [
+                'Investigate churn, failed renewals, and downgrade timing before adding acquisition spend',
+                'Pair MRR changes with product usage cohorts to find whether contraction follows activation or value-delivery gaps',
+            ],
+            keywords: ['paddle', 'mrr', 'subscription', 'retention'],
+            confidence: 'high',
+        });
+    }
+    const subscriberTrend = firstLastNumeric(subscriberSeries, 'count');
+    if (subscriberTrend.last !== null) {
+        maybePushSignal(signals, {
+            id: 'paddle_active_subscribers_trend',
+            title: subscriberTrend.deltaPercent !== null && subscriberTrend.deltaPercent < -10 ? 'Paddle active subscribers declined' : 'Paddle active subscriber count is connected',
+            area: subscriberTrend.deltaPercent !== null && subscriberTrend.deltaPercent < -10 ? 'retention' : 'revenue',
+            priority: subscriberTrend.deltaPercent !== null && subscriberTrend.deltaPercent < -10 ? 'high' : 'medium',
+            metric: 'paddle_active_subscribers',
+            current_value: subscriberTrend.last,
+            baseline_value: subscriberTrend.first,
+            delta_percent: subscriberTrend.deltaPercent,
+            evidence: [
+                `Active subscribers start: ${subscriberTrend.first}`,
+                `Active subscribers end: ${subscriberTrend.last}`,
+                subscriberTrend.deltaPercent !== null ? `Subscriber delta: ${subscriberTrend.deltaPercent}%` : null,
+            ].filter(Boolean),
+            suggested_actions: [
+                'Compare subscriber movement with onboarding completion, activation, and cancellation feedback',
+                'Check whether acquisition quality or pricing page changes shifted subscriber mix',
+            ],
+            keywords: ['paddle', 'subscribers', 'subscription', 'retention'],
+            confidence: 'high',
+        });
+    }
+    const totalRefunds = sumAmounts(refundSeries);
+    const totalChargebacks = sumCounts(chargebackSeries) || sumAmounts(chargebackSeries);
+    if (totalRefunds > 0 || totalChargebacks > 0) {
+        maybePushSignal(signals, {
+            id: 'paddle_refunds_or_chargebacks_visible',
+            title: 'Paddle reports refunds or chargebacks',
+            area: 'revenue',
+            priority: totalChargebacks > 0 || totalRefunds >= totalRevenue * 0.1 ? 'high' : 'medium',
+            metric: 'paddle_refunds_chargebacks',
+            current_value: totalRefunds + totalChargebacks,
+            baseline_value: 0,
+            delta_percent: 100,
+            evidence: [
+                `Refund amount: ${formatMinorCurrency(totalRefunds, currency)}`,
+                `Chargebacks/count signal: ${totalChargebacks}`,
+            ],
+            suggested_actions: [
+                'Review refund reasons and payment disputes before scaling acquisition',
+                'Compare refund timing with product promise, onboarding quality, and checkout copy',
+            ],
+            keywords: ['paddle', 'refunds', 'chargebacks', 'revenue'],
+            confidence: 'medium',
+        });
+    }
+    if (checkoutSeries.length > 0) {
+        const latest = checkoutSeries[checkoutSeries.length - 1] || {};
+        const rate = coerceNumber(latest.rate);
+        const started = coerceNumber(latest.count);
+        const completed = coerceNumber(latest.completed_count ?? latest.completedCount);
+        if (rate !== null || started !== null || completed !== null) {
+            maybePushSignal(signals, {
+                id: 'paddle_checkout_conversion',
+                title: rate !== null && rate < 0.05 ? 'Paddle checkout conversion is low' : 'Paddle checkout conversion is measurable',
+                area: 'conversion',
+                priority: rate !== null && rate < 0.05 ? 'high' : 'medium',
+                metric: 'paddle_checkout_conversion',
+                current_value: rate,
+                baseline_value: null,
+                delta_percent: null,
+                evidence: [
+                    rate !== null ? `Latest checkout conversion rate: ${(rate * 100).toFixed(2)}%` : null,
+                    started !== null ? `Latest checkout sessions: ${started}` : null,
+                    completed !== null ? `Latest completed checkouts: ${completed}` : null,
+                ].filter(Boolean),
+                suggested_actions: [
+                    'Inspect checkout abandonment by plan, geography, and device before changing the paywall',
+                    'Cross-check pricing page CTA clicks against Paddle checkout starts and completions',
+                ],
+                keywords: ['paddle', 'checkout', 'conversion', 'pricing'],
+                confidence: 'medium',
+            });
+        }
+    }
+    if (warnings.length > 0) {
+        maybePushSignal(signals, {
+            id: 'paddle_api_partial_read',
+            title: 'Paddle metrics summary is partial',
+            area: 'general',
+            priority: 'low',
+            metric: 'paddle_api_warnings',
+            current_value: warnings.length,
+            evidence: warnings.slice(0, 8),
+            suggested_actions: [
+                'Verify the Paddle API key has metrics.read permission on the live account',
+                'Keep sandbox and live keys separate; Paddle metrics endpoints are intended for live account reporting',
+            ],
+            keywords: ['paddle', 'api', 'metrics', 'permissions'],
+            confidence: 'medium',
+        });
+    }
+    return {
+        project: 'paddle',
+        window,
+        metrics: input?.metrics || {},
+        signals: sortSignals(signals).slice(0, Math.max(1, Number(input?.maxSignals) || 6)),
+        meta: {
+            generatedAt: new Date().toISOString(),
+            source: 'paddle',
+            environment: input?.environment || 'live',
+            currencyCode: currency || null,
+            updatedAt: [
+                metricUpdatedAt(revenue),
+                metricUpdatedAt(mrr),
+                metricUpdatedAt(activeSubscribers),
+                metricUpdatedAt(refunds),
+                metricUpdatedAt(chargebacks),
+                metricUpdatedAt(checkoutConversion),
+            ].filter(Boolean)[0] || null,
+            warnings,
+        },
+    };
+}
+function seoNumber(value) {
+    const numeric = coerceNumber(value);
+    return numeric === null ? 0 : numeric;
+}
+function normalizeSeoRow(row) {
+    const keys = Array.isArray(row?.keys) ? row.keys.map((value) => String(value || '').trim()) : [];
+    const query = String(row?.query || row?.keyword || keys[0] || '').trim();
+    const page = String(row?.page || row?.url || keys[1] || '').trim();
+    return {
+        query,
+        page,
+        clicks: seoNumber(row?.clicks),
+        impressions: seoNumber(row?.impressions),
+        ctr: coerceNumber(row?.ctr) ?? null,
+        position: coerceNumber(row?.position) ?? null,
+        volume: coerceNumber(row?.volume ?? row?.search_volume) ?? null,
+        difficulty: coerceNumber(row?.difficulty ?? row?.keyword_difficulty ?? row?.competition_index) ?? null,
+        cpc: coerceNumber(row?.cpc) ?? null,
+        source: String(row?.source || 'seo').trim(),
+    };
+}
+function seoCtr(row) {
+    if (row.ctr !== null)
+        return row.ctr;
+    return row.impressions > 0 ? row.clicks / row.impressions : 0;
+}
+function seoLabel(row) {
+    return [row.query, row.page].filter(Boolean).join(' -> ') || row.query || row.page || 'unknown';
+}
+export function buildSeoSummary(input) {
+    const rows = Array.isArray(input?.rows) ? input.rows.map(normalizeSeoRow) : [];
+    const keywordRows = Array.isArray(input?.keywordRows) ? input.keywordRows.map(normalizeSeoRow) : [];
+    const warnings = Array.isArray(input?.warnings) ? input.warnings.filter(Boolean).map(String) : [];
+    const maxSignals = Math.max(1, Number(input?.maxSignals) || 8);
+    const signals = [];
+    const gscRows = rows.filter((row) => row.impressions > 0);
+    const lowCtr = [...gscRows]
+        .filter((row) => row.impressions >= 100 && seoCtr(row) < 0.02)
+        .sort((a, b) => b.impressions - a.impressions)
+        .slice(0, 5);
+    if (lowCtr.length > 0) {
+        maybePushSignal(signals, {
+            id: 'seo_gsc_high_impression_low_ctr',
+            title: 'Google Search Console shows high-impression queries with low CTR',
+            area: 'marketing',
+            priority: lowCtr.some((row) => row.impressions >= 1000) ? 'high' : 'medium',
+            metric: 'gsc_low_ctr_impressions',
+            current_value: lowCtr.reduce((total, row) => total + row.impressions, 0),
+            baseline_value: null,
+            delta_percent: null,
+            evidence: lowCtr.map((row) => `${seoLabel(row)}: ${row.impressions} impressions, ${row.clicks} clicks, ${(seoCtr(row) * 100).toFixed(2)}% CTR, avg position ${row.position ?? 'n/a'}`),
+            suggested_actions: [
+                'Refresh title, meta description, and above-the-fold promise for the affected page/query pair',
+                'Check SERP intent and make the page answer the query more directly before creating new pages',
+            ],
+            keywords: ['seo', 'gsc', 'ctr', 'search-console'],
+            confidence: 'high',
+        });
+    }
+    const strikingDistance = [...gscRows]
+        .filter((row) => row.impressions >= 50 && row.position !== null && row.position >= 4 && row.position <= 20)
+        .sort((a, b) => b.impressions - a.impressions)
+        .slice(0, 5);
+    if (strikingDistance.length > 0) {
+        maybePushSignal(signals, {
+            id: 'seo_gsc_striking_distance_queries',
+            title: 'Google Search Console has striking-distance SEO opportunities',
+            area: 'marketing',
+            priority: strikingDistance.some((row) => row.position <= 10 && row.impressions >= 500) ? 'high' : 'medium',
+            metric: 'gsc_striking_distance_impressions',
+            current_value: strikingDistance.reduce((total, row) => total + row.impressions, 0),
+            baseline_value: null,
+            delta_percent: null,
+            evidence: strikingDistance.map((row) => `${seoLabel(row)}: avg position ${row.position}, ${row.impressions} impressions, ${row.clicks} clicks`),
+            suggested_actions: [
+                'Improve the existing ranking URL first: intent match, internal links, comparison proof, and product-specific examples',
+                'Only create a new page if the current URL cannot satisfy the query intent without cannibalization',
+            ],
+            keywords: ['seo', 'gsc', 'ranking', 'content-refresh'],
+            confidence: 'high',
+        });
+    }
+    const keywordOpportunities = [...keywordRows]
+        .filter((row) => (row.volume || 0) >= 20)
+        .sort((a, b) => (b.volume || 0) - (a.volume || 0) || (a.difficulty || 100) - (b.difficulty || 100))
+        .slice(0, 5);
+    if (keywordOpportunities.length > 0) {
+        maybePushSignal(signals, {
+            id: 'seo_keyword_research_opportunities',
+            title: 'Keyword research found acquisition opportunities',
+            area: 'marketing',
+            priority: keywordOpportunities.some((row) => (row.volume || 0) >= 500) ? 'high' : 'medium',
+            metric: 'seo_keyword_volume',
+            current_value: keywordOpportunities.reduce((total, row) => total + (row.volume || 0), 0),
+            baseline_value: null,
+            delta_percent: null,
+            evidence: keywordOpportunities.map((row) => `${row.query}: volume ${row.volume ?? 'n/a'}, difficulty ${row.difficulty ?? 'n/a'}, CPC ${row.cpc ?? 'n/a'}, source ${row.source}`),
+            suggested_actions: [
+                'Map each keyword to an existing URL before creating new content',
+                'Prioritize BOF, comparison, integration, and template pages where the product can add unique evidence',
+            ],
+            keywords: ['seo', 'keyword-research', 'dataforseo', 'content'],
+            confidence: keywordOpportunities.some((row) => row.source.includes('dataforseo')) ? 'high' : 'medium',
+        });
+    }
+    if (gscRows.length === 0 && keywordRows.length === 0) {
+        maybePushSignal(signals, {
+            id: 'seo_no_search_data',
+            title: 'SEO connector has no search data yet',
+            area: 'marketing',
+            priority: 'low',
+            metric: 'seo_rows',
+            current_value: 0,
+            baseline_value: 1,
+            delta_percent: -100,
+            evidence: warnings.length > 0 ? warnings.slice(0, 5) : ['No GSC rows, keyword CSV rows, or DataForSEO rows were available.'],
+            suggested_actions: [
+                'Connect Google Search Console or provide a recent GSC/keyword CSV export',
+                'Use DataForSEO only after narrowing seed topics and setting a paid request cap',
+            ],
+            keywords: ['seo', 'gsc', 'dataforseo', 'setup'],
+            confidence: 'medium',
+        });
+    }
+    if (warnings.length > 0) {
+        maybePushSignal(signals, {
+            id: 'seo_partial_read',
+            title: 'SEO summary is partial',
+            area: 'marketing',
+            priority: 'low',
+            metric: 'seo_warnings',
+            current_value: warnings.length,
+            evidence: warnings.slice(0, 8),
+            suggested_actions: [
+                'Fix the missing SEO credential/export only if SEO is part of the active growth cadence',
+                'Prefer cached exports for repeatable analysis and bounded paid API usage',
+            ],
+            keywords: ['seo', 'gsc', 'dataforseo', 'credentials'],
+            confidence: 'medium',
+        });
+    }
+    return {
+        project: input?.siteUrl ? `seo:${input.siteUrl}` : 'seo',
+        window: input?.window || 'latest',
+        rows: gscRows.slice(0, 100),
+        keywordRows: keywordRows.slice(0, 100),
+        signals: sortSignals(signals).slice(0, maxSignals),
+        meta: {
+            generatedAt: new Date().toISOString(),
+            source: 'seo',
+            siteUrl: input?.siteUrl || null,
+            gscRows: gscRows.length,
+            keywordRows: keywordRows.length,
+            paidProvider: input?.paidProvider || null,
+            warnings,
+        },
+    };
+}
 function normalizeSentryIssueCount(issue) {
     return coerceNumber(issue?.count ?? issue?.events ?? issue?.eventCount ?? issue?.stats?.sum) || 0;
 }
@@ -1103,6 +1575,16 @@ function normalizeSentryUserCount(issue) {
 function normalizeSentryIssueTitle(issue) {
     return String(issue?.title || issue?.metadata?.title || issue?.culprit || 'Untitled Sentry issue').trim();
 }
+function normalizeSentryIssueUrl(issue) {
+    return String(issue?.permalink ||
+        issue?.issueUrl ||
+        issue?.issue_url ||
+        issue?.webUrl ||
+        issue?.web_url ||
+        issue?.links?.permalink ||
+        issue?.links?.html ||
+        '').trim();
+}
 function normalizeSentryPriority(issue) {
     const level = String(issue?.level || issue?.priority || '').toLowerCase();
     const events = normalizeSentryIssueCount(issue);
@@ -1114,19 +1596,44 @@ function normalizeSentryPriority(issue) {
     return 'low';
 }
 function normalizeSentryEvidence(issue, environment) {
+    const releaseVersions = extractSentryReleaseVersions(issue);
+    const issueUrl = normalizeSentryIssueUrl(issue);
     return [
         issue?.shortId ? `Sentry issue: ${issue.shortId}` : issue?.id ? `Sentry issue id: ${issue.id}` : null,
-        issue?.permalink ? `Permalink: ${issue.permalink}` : null,
+        issueUrl ? `Issue link: ${issueUrl}` : null,
         issue?.level ? `Level: ${issue.level}` : null,
         issue?.status ? `Status: ${issue.status}` : null,
         issue?.firstSeen ? `First seen: ${issue.firstSeen}` : null,
         issue?.lastSeen ? `Last seen: ${issue.lastSeen}` : null,
         environment ? `Environment: ${environment}` : null,
+        releaseVersions.length > 0 ? `Release/app version: ${releaseVersions.join(', ')}` : null,
         normalizeSentryIssueCount(issue) ? `Events: ${normalizeSentryIssueCount(issue)}` : null,
         normalizeSentryUserCount(issue) ? `Affected users: ${normalizeSentryUserCount(issue)}` : null,
         issue?.culprit ? `Culprit: ${issue.culprit}` : null,
     ].filter(Boolean);
 }
+function extractSentryReleaseVersions(issue) {
+    const values = [
+        issue?.release,
+        issue?.firstRelease?.version,
+        issue?.firstRelease?.shortVersion,
+        issue?.lastRelease?.version,
+        issue?.lastRelease?.shortVersion,
+        issue?.metadata?.release,
+        issue?.metadata?.version,
+        issue?.metadata?.appVersion,
+        issue?.metadata?.['app.version'],
+    ];
+    if (Array.isArray(issue?.tags)) {
+        for (const tag of issue.tags) {
+            const key = String(tag?.key || tag?.name || '').toLowerCase();
+            if (/(release|version|app\.version|dist|build)/.test(key)) {
+                values.push(tag?.value);
+            }
+        }
+    }
+    return [...new Set(values.map(normalizeVersionToken).filter(Boolean))].sort();
+}
 function buildCombinedSentrySummary(input) {
     const accounts = Array.isArray(input?.accounts) ? input.accounts : [];
     const maxSignals = Math.max(1, Number(input?.maxSignals) || 5);
@@ -1148,11 +1655,14 @@ function buildCombinedSentrySummary(input) {
         accountId,
         accountLabel: label,
         sourceProject: summary.project,
+        app: issue.app || summary.project,
     })));
     const signals = summaries
         .flatMap(({ accountId, label, summary }) => (Array.isArray(summary.signals) ? summary.signals : []).map((signal) => ({
         ...signal,
         id: `${accountId}:${signal.id}`,
+        app: signal.app || summary.project,
+        sourceProject: summary.project,
         evidence: [`Sentry account: ${label}`, `Sentry project: ${summary.project}`, ...(signal.evidence || [])],
         keywords: [accountId, ...(signal.keywords || [])],
     })))
@@ -1200,34 +1710,44 @@ export function buildSentrySummary(input) {
     const maxSignals = Math.max(1, Number(input?.maxSignals) || 5);
     const normalizedIssues = issues
         .filter((issue) => issue && typeof issue === 'object')
-        .map((issue, index) => ({
-        id: String(issue.id || issue.shortId || `sentry_${index + 1}`),
-        title: normalizeSentryIssueTitle(issue),
-        priority: normalizeSentryPriority(issue),
-        impact: normalizeSentryUserCount(issue) > 0
-            ? `${normalizeSentryUserCount(issue)} affected users in ${last}`
-            : `Production stability issue observed in ${last}`,
-        events: normalizeSentryIssueCount(issue),
-        users: normalizeSentryUserCount(issue),
-        area: 'crash',
-        metric: 'sentry_unresolved_issues',
-        stack_keywords: [
-            issue.level,
-            issue.type,
-            issue.platform,
-            issue.metadata?.type,
-            issue.culprit,
-        ]
-            .filter(Boolean)
-            .map((value) => String(value).slice(0, 80)),
-        evidence: normalizeSentryEvidence(issue, environment),
-        suggested_actions: [
-            'Map this Sentry issue to the current production release and affected user journey',
-            'Check whether the crash intersects onboarding, paywall, purchase, or first value events',
-            'Fix or mitigate the highest-user-impact issue before running new growth experiments that send more traffic into the broken path',
-        ],
-        confidence: 'high',
-    }))
+        .map((issue, index) => {
+        const releaseVersions = extractSentryReleaseVersions(issue);
+        const issueUrl = normalizeSentryIssueUrl(issue);
+        return {
+            id: String(issue.id || issue.shortId || `sentry_${index + 1}`),
+            shortId: issue.shortId ? String(issue.shortId) : null,
+            title: normalizeSentryIssueTitle(issue),
+            priority: normalizeSentryPriority(issue),
+            impact: normalizeSentryUserCount(issue) > 0
+                ? `${normalizeSentryUserCount(issue)} affected users in ${last}`
+                : `Production stability issue observed in ${last}`,
+            events: normalizeSentryIssueCount(issue),
+            users: normalizeSentryUserCount(issue),
+            releaseVersions,
+            area: 'crash',
+            metric: 'sentry_unresolved_issues',
+            sourceUrl: issueUrl || null,
+            issueUrl: issueUrl || null,
+            app: org ? `sentry:${org}/${project}` : `sentry:${project}`,
+            stack_keywords: [
+                issue.level,
+                issue.type,
+                issue.platform,
+                issue.metadata?.type,
+                issue.culprit,
+                ...releaseVersions,
+            ]
+                .filter(Boolean)
+                .map((value) => String(value).slice(0, 80)),
+            evidence: normalizeSentryEvidence(issue, environment),
+            suggested_actions: [
+                'Map this Sentry issue to the current production release and affected user journey',
+                'Check whether the crash intersects onboarding, paywall, purchase, or first value events',
+                'Fix or mitigate the highest-user-impact issue before running new growth experiments that send more traffic into the broken path',
+            ],
+            confidence: 'high',
+        };
+    })
         .sort((a, b) => {
         const priorityDelta = priorityRank(b.priority) - priorityRank(a.priority);
         if (priorityDelta !== 0)
@@ -1249,10 +1769,14 @@ export function buildSentrySummary(input) {
             priority: issue.priority,
             metric: issue.metric,
             current_value: issue.events,
+            releaseVersions: issue.releaseVersions,
             evidence: issue.evidence,
             suggested_actions: issue.suggested_actions,
             keywords: issue.stack_keywords,
             confidence: issue.confidence,
+            app: issue.app,
+            sourceUrl: issue.sourceUrl,
+            issueUrl: issue.issueUrl,
         })),
         meta: {
             generatedAt: new Date().toISOString(),
@@ -1264,6 +1788,186 @@ export function buildSentrySummary(input) {
         },
     };
 }
+function normalizeCoolifyName(value, fallback) {
+    const text = String(value || '').trim();
+    return text || fallback;
+}
+function normalizeCoolifyDomains(resource) {
+    const raw = resource?.domains ?? resource?.fqdn ?? resource?.domain ?? resource?.url ?? '';
+    if (Array.isArray(raw))
+        return raw.map((entry) => String(entry).trim()).filter(Boolean);
+    return String(raw || '')
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function normalizeCoolifyStatus(value) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '_');
+}
+function isCoolifyDeploymentFailed(deployment) {
+    const status = normalizeCoolifyStatus(deployment?.status || deployment?.state);
+    return Boolean(status && /(failed|error|cancelled|canceled|exited|unhealthy)/i.test(status));
+}
+function isCoolifyDeploymentRecent(deployment, sinceMs) {
+    const candidates = [
+        deployment?.created_at,
+        deployment?.createdAt,
+        deployment?.updated_at,
+        deployment?.updatedAt,
+        deployment?.finished_at,
+        deployment?.finishedAt,
+    ];
+    const timestamps = candidates
+        .map((value) => Date.parse(String(value || '')))
+        .filter((value) => Number.isFinite(value));
+    if (timestamps.length === 0)
+        return true;
+    return Math.max(...timestamps) >= sinceMs;
+}
+function isCoolifyResourceUnhealthy(resource) {
+    const status = normalizeCoolifyStatus(resource?.status || resource?.state || resource?.health);
+    if (!status)
+        return false;
+    return /(unhealthy|failed|error|exited|stopped|dead|degraded|missing)/i.test(status);
+}
+function coolifyResourceLabel(resource, fallback) {
+    return normalizeCoolifyName(resource?.name || resource?.application_name || resource?.service_name || resource?.uuid || resource?.id, fallback);
+}
+export function buildCoolifySummary(input) {
+    const applications = Array.isArray(input?.applications) ? input.applications : [];
+    const deployments = Array.isArray(input?.deployments) ? input.deployments : [];
+    const resources = Array.isArray(input?.resources) ? input.resources : [];
+    const servers = Array.isArray(input?.servers) ? input.servers : [];
+    const warnings = Array.isArray(input?.warnings) ? input.warnings.map((entry) => String(entry)).filter(Boolean) : [];
+    const baseUrl = String(input?.baseUrl || process.env.COOLIFY_BASE_URL || '').replace(/\/$/, '');
+    const last = String(input?.last || input?.window || '24h');
+    const maxSignals = Math.max(1, Number(input?.maxSignals) || 8);
+    const durationValue = Number(last.slice(0, -1));
+    const durationMs = Number.isFinite(durationValue) && last.endsWith('d')
+        ? durationValue * 24 * 60 * 60 * 1000
+        : Number.isFinite(durationValue) && last.endsWith('h')
+            ? durationValue * 60 * 60 * 1000
+            : Number.isFinite(durationValue) && last.endsWith('m')
+                ? durationValue * 60 * 1000
+                : 24 * 60 * 60 * 1000;
+    const sinceMs = Date.now() - durationMs;
+    const signals = [];
+    const failedDeployments = deployments
+        .filter((deployment) => isCoolifyDeploymentFailed(deployment) && isCoolifyDeploymentRecent(deployment, sinceMs))
+        .slice(0, maxSignals);
+    if (failedDeployments.length > 0) {
+        signals.push({
+            id: 'coolify_failed_deployments',
+            title: 'Coolify has recent failed deployments',
+            area: 'crash',
+            priority: failedDeployments.length >= 3 ? 'high' : 'medium',
+            metric: 'coolify_failed_deployments',
+            current_value: failedDeployments.length,
+            evidence: failedDeployments.slice(0, 5).map((deployment) => {
+                const app = coolifyResourceLabel(deployment, 'unknown resource');
+                const status = deployment?.status || deployment?.state || 'unknown status';
+                const when = deployment?.created_at || deployment?.createdAt || deployment?.finished_at || deployment?.finishedAt || '';
+                return `${app}: ${status}${when ? ` at ${when}` : ''}`;
+            }),
+            suggested_actions: [
+                'Open the failed Coolify deployment and inspect build/runtime logs before pushing more traffic to the app',
+                'Correlate the failed deploy with Sentry issues, release changes, and AnalyticsCLI conversion or activation drops',
+                'Fix the deployment blocker or roll back the affected service before running growth experiments',
+            ],
+            keywords: ['coolify', 'deployment', 'hosting', 'production'],
+            confidence: 'high',
+        });
+    }
+    const unhealthyResources = [...applications, ...resources]
+        .filter((resource) => isCoolifyResourceUnhealthy(resource))
+        .slice(0, maxSignals);
+    if (unhealthyResources.length > 0) {
+        signals.push({
+            id: 'coolify_unhealthy_resources',
+            title: 'Coolify reports unhealthy or stopped resources',
+            area: 'crash',
+            priority: 'high',
+            metric: 'coolify_unhealthy_resources',
+            current_value: unhealthyResources.length,
+            evidence: unhealthyResources.slice(0, 8).map((resource) => {
+                const name = coolifyResourceLabel(resource, 'unknown resource');
+                const status = resource?.status || resource?.state || resource?.health || 'unknown status';
+                const domains = normalizeCoolifyDomains(resource);
+                return `${name}: ${status}${domains.length ? ` (${domains.join(', ')})` : ''}`;
+            }),
+            suggested_actions: [
+                'Restore or restart the unhealthy Coolify resource and verify its public domain before prioritizing product-growth work',
+                'Check whether Sentry error volume and AnalyticsCLI active users changed after the resource became unhealthy',
+                'Add or tighten health checks for the affected service so future incidents are caught earlier',
+            ],
+            keywords: ['coolify', 'health', 'availability', 'hosting'],
+            confidence: 'high',
+        });
+    }
+    const publicAppsWithoutHealthChecks = applications
+        .filter((app) => normalizeCoolifyDomains(app).length > 0 && app?.health_check_enabled === false)
+        .slice(0, maxSignals);
+    if (publicAppsWithoutHealthChecks.length > 0) {
+        signals.push({
+            id: 'coolify_public_apps_without_health_checks',
+            title: 'Public Coolify applications are missing health checks',
+            area: 'crash',
+            priority: 'medium',
+            metric: 'coolify_missing_health_checks',
+            current_value: publicAppsWithoutHealthChecks.length,
+            evidence: publicAppsWithoutHealthChecks.slice(0, 8).map((app) => {
+                const name = coolifyResourceLabel(app, 'unknown application');
+                return `${name}: ${normalizeCoolifyDomains(app).join(', ')}`;
+            }),
+            suggested_actions: [
+                'Enable Coolify health checks for public production applications',
+                'Use the health endpoint that best reflects the real app dependency path, not only process liveness',
+                'Pair Coolify health-check alerts with Sentry and AnalyticsCLI anomaly checks in the daily guardrail',
+            ],
+            keywords: ['coolify', 'health_check', 'production', 'monitoring'],
+            confidence: 'medium',
+        });
+    }
+    if (warnings.length > 0) {
+        signals.push({
+            id: 'coolify_api_partial_read',
+            title: 'Coolify API summary is partial',
+            area: 'general',
+            priority: 'low',
+            metric: 'coolify_api_warnings',
+            current_value: warnings.length,
+            evidence: warnings.slice(0, 8),
+            suggested_actions: [
+                'Verify the Coolify API token has read-only access to the team that owns the production resources',
+                'Keep the token read-only; only expand permissions if a specific API endpoint requires it',
+            ],
+            keywords: ['coolify', 'api', 'token', 'permissions'],
+            confidence: 'medium',
+        });
+    }
+    return {
+        project: baseUrl ? `coolify:${baseUrl}` : 'coolify',
+        window: normalizeWindow(last),
+        applications,
+        deployments,
+        resources,
+        servers,
+        signals: signals.slice(0, maxSignals),
+        meta: {
+            generatedAt: new Date().toISOString(),
+            source: 'coolify',
+            baseUrl: baseUrl || null,
+            applicationsReturned: applications.length,
+            deploymentsReturned: deployments.length,
+            resourcesReturned: resources.length,
+            serversReturned: servers.length,
+            warnings,
+        },
+    };
+}
 export async function writeJsonOutput(outPath, payload) {
     const serialized = `${JSON.stringify(payload, null, 2)}\n`;
     if (outPath) {