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

package/dist/runtime/openclaw-growth-runner.mjs

@@ -5,7 +5,7 @@ import process from 'node:process';
 import { createHash } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { deriveRuntimeDirFromStatePath, deriveSchedulerProofPathFromStatePath, getActionMode, getAllSourceEntries, getGitHubArtifactModes, getGitHubRequirementText, shouldAutoCreateGitHubArtifact, } from './openclaw-growth-shared.mjs';
+import { deriveRuntimeDirFromStatePath, deriveSchedulerProofPathFromStatePath, getActionMode, getAllSourceEntries, getGitHubArtifactModes, getGitHubRequirementText, repairOpenClawCronDeliveryStore, shouldAutoCreateGitHubArtifact, } from './openclaw-growth-shared.mjs';
 import { applyOpenClawSecretRefs, loadOpenClawGrowthSecrets } from './openclaw-growth-env.mjs';
 const DEFAULT_CONFIG_PATH = 'data/openclaw-growth-engineer/config.json';
 const DEFAULT_STATE_PATH = 'data/openclaw-growth-engineer/state.json';
@@ -15,55 +15,65 @@ const SELF_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const RUNTIME_DIR = path.dirname(fileURLToPath(import.meta.url));
 let schedulerProofPath = path.resolve(DEFAULT_SCHEDULER_PROOF_PATH);
 const DEFAULT_CADENCES = [
+    {
+        key: 'healthcheck',
+        title: '90-minute production error healthcheck',
+        intervalMinutes: 90,
+        criticalOnly: true,
+        focusAreas: ['crash', 'deployment', 'availability'],
+        sourcePriorities: ['sentry', 'glitchtip', 'coolify', 'asc_cli'],
+        objective: 'Check Sentry/GlitchTip and Coolify for production errors, failed deploys, unhealthy resources, and availability blockers across every configured app.',
+        instructions: 'For Sentry/GlitchTip app errors, compare the issue release or app version with ASC production versions first. Ignore errors that only affect TestFlight, debug, staging, unreleased, or non-production app versions. Keep the social output short and action-oriented.',
+    },
     {
         key: 'daily',
-        title: 'Daily Sentry and production guardrail',
+        title: 'Daily behavioral anomaly guardrail',
         intervalDays: 1,
         criticalOnly: true,
-        focusAreas: ['sentry_errors', 'crash', 'onboarding', 'conversion', 'paywall', 'purchase'],
-        sourcePriorities: ['sentry', 'glitchtip', 'analytics', 'revenuecat', 'asc_cli', 'feedback', 'github'],
-        objective: 'Analyze every configured project for critical production blockers: Sentry/GlitchTip errors, crashes, onboarding or purchase drop-offs, zero-conversion days, missing buyers, very low users, and other silent business anomalies.',
-        instructions: 'Compare against recent baselines across Sentry/GlitchTip, AnalyticsCLI, RevenueCat, ASC, feedback, release metadata, memory/state, and recent code changes. If the finding is critical, produce the exact fix or next debugging step and prefer a GitHub issue or draft PR when GitHub write access is configured; otherwise hand off via OpenClaw chat. Do not invent generic growth ideas.',
+        focusAreas: ['analytics_anomaly', 'onboarding', 'conversion', 'paywall', 'purchase', 'retention', 'revenue'],
+        sourcePriorities: ['analytics', 'revenuecat', 'paddle', 'asc_cli', 'feedback', 'github', 'sentry', 'glitchtip', 'coolify'],
+        objective: 'Detect non-Sentry product and payment anomalies that affect real users: broken login or account flows inferred from behavior, onboarding or purchase drop-offs, zero-conversion days, missing buyers, very low active users, retention cliffs, and revenue anomalies.',
+        instructions: 'Compare AnalyticsCLI, RevenueCat, Paddle, ASC, feedback, memory/state, and recent code changes against recent baselines. Use Sentry/GlitchTip/Coolify only as corroborating context; do not repeat pure crash or deployment alerts that belong to the 90-minute healthcheck.',
     },
     {
         key: 'weekly',
         title: 'Weekly executive product and growth summary',
         intervalDays: 7,
         criticalOnly: false,
-        focusAreas: ['conversion', 'paywall', 'onboarding', 'marketing', 'retention', 'stability'],
-        sourcePriorities: ['analytics', 'revenuecat', 'asc_cli', 'feedback', 'sentry', 'github'],
-        objective: 'Create an executive summary across all configured projects, connectors, recent releases, code changes, revenue, activation, retention, reviews, and production stability.',
-        instructions: 'Choose one to three high-confidence improvements with evidence, expected KPI movement, likely code/store surfaces, owner-ready next steps, and verification plan. Create GitHub issues or draft PR proposals only when the evidence is specific enough. Kill or adjust experiments without signal.',
+        focusAreas: ['conversion', 'paywall', 'onboarding', 'marketing', 'retention', 'stability', 'seo'],
+        sourcePriorities: ['analytics', 'revenuecat', 'paddle', 'seo', 'asc_cli', 'feedback', 'sentry', 'coolify', 'github'],
+        objective: 'Create a deep app-by-app executive summary across all configured projects, connectors, recent releases, code changes, traffic, SEO/acquisition, revenue, activation, conversion, retention, reviews, and production stability.',
+        instructions: 'Be detailed. Group findings per app, explain why each recommendation should improve app usage, revenue, conversion, retention, or traffic, include expected KPI movement, likely code/store surfaces, owner-ready next steps, and verification plans. Generate charts when they clarify the evidence.',
     },
     {
         key: 'monthly',
         title: 'Monthly deep product, business, and code review',
         intervalDays: 30,
         criticalOnly: false,
-        focusAreas: ['conversion', 'paywall', 'retention', 'marketing', 'onboarding', 'codebase'],
-        sourcePriorities: ['analytics', 'revenuecat', 'asc_cli', 'feedback', 'sentry', 'github'],
-        objective: 'Compare all configured projects month-over-month: MRR, trial conversion, churn, acquisition channel quality, store/listing conversion, retention, review themes, feature usage, crash totals, and codebase changes.',
-        instructions: 'Decide what should be built, changed, deleted, or instrumented next. Tie conclusions to connector data plus codebase evidence and explain why each recommendation should move revenue, activation, retention, stability, or acquisition quality.',
+        focusAreas: ['conversion', 'paywall', 'retention', 'marketing', 'onboarding', 'codebase', 'seo'],
+        sourcePriorities: ['analytics', 'revenuecat', 'paddle', 'seo', 'asc_cli', 'feedback', 'sentry', 'coolify', 'github'],
+        objective: 'Compare all configured projects month-over-month: MRR, trial conversion, churn, Paddle revenue/subscriber movement, SEO demand/clicks, acquisition channel quality, store/listing conversion, retention, review themes, feature usage, crash totals, and codebase changes.',
+        instructions: 'Be very detailed and app-grouped. Decide what should be built, changed, deleted, priced differently, marketed differently, or instrumented next. Tie conclusions to connector data plus codebase evidence and explain why each recommendation should move revenue, conversion, retention, traffic, or acquisition quality. Generate charts when useful.',
     },
     {
         key: 'quarterly',
-        title: 'Quarterly positioning, pricing, and roadmap review',
+        title: '3-month positioning, pricing, and roadmap review',
         intervalDays: 91,
         criticalOnly: false,
         focusAreas: ['marketing', 'paywall', 'retention', 'conversion', 'onboarding'],
-        sourcePriorities: ['analytics', 'revenuecat', 'asc_cli', 'feedback', 'github', 'sentry'],
-        objective: 'Revisit positioning, pricing/packaging, onboarding architecture, roadmap assumptions, tracking quality, codebase constraints, and major funnel bets across every configured project.',
-        instructions: 'Find structural constraints and durable opportunities, not small UI tweaks. Tie recommendations to cohort behavior, monetization, reviews, channel quality, and shipped changes.',
+        sourcePriorities: ['analytics', 'revenuecat', 'paddle', 'seo', 'asc_cli', 'feedback', 'github', 'sentry'],
+        objective: 'Revisit positioning, pricing/packaging, onboarding architecture, roadmap assumptions, tracking quality, codebase constraints, and major funnel bets across every configured app.',
+        instructions: 'Find structural constraints and durable opportunities, not small UI tweaks. Group the analysis by app and tie recommendations to cohort behavior, monetization, SEO demand, reviews, channel quality, and shipped changes. Include concrete roadmap, pricing, conversion, and traffic recommendations.',
     },
     {
         key: 'six_months',
         title: 'Six-month instrumentation and growth-system audit',
         intervalDays: 182,
         criticalOnly: false,
-        focusAreas: ['retention', 'conversion', 'paywall', 'marketing', 'general'],
-        sourcePriorities: ['analytics', 'revenuecat', 'asc_cli', 'feedback', 'sentry'],
+        focusAreas: ['retention', 'conversion', 'paywall', 'marketing', 'general', 'seo'],
+        sourcePriorities: ['analytics', 'revenuecat', 'paddle', 'seo', 'asc_cli', 'feedback', 'sentry'],
         objective: 'Audit connector coverage, SDK instrumentation, event taxonomy, data reliability, data memory, growth loops, and whether product/code strategy still matches the best users across configured projects.',
-        instructions: 'Prioritize measurement fixes and system changes that make future analysis more trustworthy. Identify stale events, missing attribution, weak identity, broken feedback loops, and misleading dashboards.',
+        instructions: 'Group by app. Prioritize measurement fixes and system changes that make future analysis more trustworthy, then identify the highest-leverage app/revenue/conversion/SEO/traffic improvements. Identify stale events, missing attribution, weak identity, broken feedback loops, and misleading dashboards.',
     },
     {
         key: 'yearly',
@@ -71,7 +81,7 @@ const DEFAULT_CADENCES = [
         intervalDays: 365,
         criticalOnly: false,
         focusAreas: ['marketing', 'retention', 'paywall', 'conversion', 'general'],
-        sourcePriorities: ['analytics', 'revenuecat', 'asc_cli', 'feedback', 'sentry'],
+        sourcePriorities: ['analytics', 'revenuecat', 'paddle', 'seo', 'asc_cli', 'feedback', 'sentry'],
         objective: 'Reset strategy from evidence across every configured project: market/channel fit, monetization model, retention ceiling, product scope, and whether to double down, reposition, rebuild, or sunset major surfaces/features.',
         instructions: 'Use the full year of memory, releases, revenue, acquisition, reviews, code changes, and cohort behavior. Produce a strategic operating plan with specific experiments and stop-doing decisions.',
     },
@@ -145,19 +155,28 @@ function replaceLegacyRuntimeScriptCommand(command) {
     const trimmed = String(command || '').trim();
     if (!trimmed)
         return trimmed;
-    return trimmed.replace(/^node\s+scripts\/(export-analytics-summary\.mjs|export-revenuecat-summary\.mjs|export-sentry-summary\.mjs|export-asc-summary\.mjs|openclaw-growth-engineer\.mjs|openclaw-growth-status\.mjs|openclaw-growth-preflight\.mjs|openclaw-growth-runner\.mjs)(?=\s|$)/, (_match, scriptName) => nodeRuntimeScriptCommand(scriptName));
+    return trimmed.replace(/^node\s+scripts\/(export-analytics-summary\.mjs|export-revenuecat-summary\.mjs|export-paddle-summary\.mjs|export-seo-summary\.mjs|export-sentry-summary\.mjs|export-coolify-summary\.mjs|export-asc-summary\.mjs|openclaw-growth-engineer\.mjs|openclaw-growth-status\.mjs|openclaw-growth-preflight\.mjs|openclaw-growth-runner\.mjs)(?=\s|$)/, (_match, scriptName) => nodeRuntimeScriptCommand(scriptName));
 }
 function commandHasConfigArg(command) {
     return /(?:^|\s)--config(?:=|\s|$)/.test(String(command || ''));
 }
-function commandShouldReceiveActiveConfig(command) {
-    return /(?:^|\s)(?:node\s+)?(?:\S*\/)?(?:export-analytics-summary|export-revenuecat-summary|export-sentry-summary|export-asc-summary)\.mjs(?:\s|$)/.test(String(command || ''));
+function commandIsBuiltinExporter(command) {
+    return /(?:^|\s)(?:node\s+)?(?:\S*\/)?(?:export-analytics-summary|export-revenuecat-summary|export-paddle-summary|export-seo-summary|export-sentry-summary|export-coolify-summary|export-asc-summary)\.mjs(?:\s|$)/.test(String(command || ''));
+}
+function commandSupportsActiveConfig(command) {
+    return /(?:^|\s)(?:node\s+)?(?:\S*\/)?(?:export-sentry-summary|export-coolify-summary)\.mjs(?:\s|$)/.test(String(command || ''));
 }
 function withActiveConfigArg(command, configPath) {
     const trimmed = String(command || '').trim();
-    if (!trimmed || !configPath || !commandShouldReceiveActiveConfig(trimmed)) {
+    if (!trimmed || !configPath || !commandIsBuiltinExporter(trimmed)) {
         return trimmed;
     }
+    if (!commandSupportsActiveConfig(trimmed)) {
+        return trimmed
+            .replace(/(^|\s)--config=(?:"[^"]*"|'[^']*'|\S+)/, '$1')
+            .replace(/(^|\s)--config\s+(?:"[^"]*"|'[^']*'|\S+)/, '$1')
+            .trim();
+    }
     if (commandHasConfigArg(trimmed)) {
         return trimmed
             .replace(/(^|\s)--config=(?:"[^"]*"|'[^']*'|\S+)/, `$1--config ${quote(configPath)}`)
@@ -205,6 +224,33 @@ function stableStringify(value) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function isTransientNetworkFailure(value) {
+    return /NETWORK_ERROR|fetch failed|tlsv1 alert|SSL routines|ECONNRESET|ECONNREFUSED|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket hang up|network timeout|Temporary failure|upstream connect error|disconnect\/reset before headers|HTTP 5\d\d|API 5\d\d/i.test(String(value || ''));
+}
+function isRequiredSource(sourceConfig, sourceName) {
+    if (sourceConfig?.required === true)
+        return true;
+    if (sourceConfig?.required === false)
+        return false;
+    return String(sourceName || '').toLowerCase() === 'analytics';
+}
+function isSentryCompatibleSource(sourceConfig, sourceName) {
+    const sourceKey = String(sourceName || '').toLowerCase();
+    const service = String(sourceConfig?.service || sourceConfig?.provider || '').toLowerCase();
+    const command = String(sourceConfig?.command || '').toLowerCase();
+    return (sourceKey === 'sentry' ||
+        sourceKey === 'glitchtip' ||
+        service === 'sentry' ||
+        service === 'glitchtip' ||
+        command.includes('export-sentry-summary'));
+}
+function shouldDegradeTransientSourceFailure(sourceConfig, sourceName, retried) {
+    if (!retried)
+        return false;
+    if (!isRequiredSource(sourceConfig, sourceName))
+        return true;
+    return isSentryCompatibleSource(sourceConfig, sourceName);
+}
 function isTruthyEnv(value) {
     return ['1', 'true', 'yes', 'y', 'on'].includes(String(value || '').trim().toLowerCase());
 }
@@ -350,11 +396,24 @@ function resolveShellCommand() {
     }
     return 'sh';
 }
+function hardenUnattendedShellCommand(command) {
+    return String(command || '').replace(/(^|[;&|]\s*)sudo(?!\s+-n(?:\s|$))(?=\s|$)/g, '$1sudo -n');
+}
+function isSudoPasswordPrompt(stderr) {
+    return /sudo: (?:a password is required|a terminal is required to read the password|no tty present)/i.test(String(stderr || ''));
+}
 function runShellCommand(command, timeoutMs = 120_000, options = {}) {
     return new Promise((resolve) => {
-        const child = spawn(resolveShellCommand(), ['-c', command], {
+        const hardenedCommand = hardenUnattendedShellCommand(command);
+        const child = spawn(resolveShellCommand(), ['-c', hardenedCommand], {
             stdio: options.input === undefined ? ['ignore', 'pipe', 'pipe'] : ['pipe', 'pipe', 'pipe'],
             cwd: options.cwd,
+            env: {
+                ...process.env,
+                DEBIAN_FRONTEND: 'noninteractive',
+                SUDO_ASKPASS: '/bin/false',
+                SUDO_PROMPT: '',
+            },
         });
         let stdout = '';
         let stderr = '';
@@ -371,6 +430,17 @@ function runShellCommand(command, timeoutMs = 120_000, options = {}) {
         });
         child.stderr.on('data', (chunk) => {
             stderr += String(chunk);
+            if (!settled && isSudoPasswordPrompt(stderr)) {
+                settled = true;
+                clearTimeout(timer);
+                child.kill('SIGTERM');
+                resolve({
+                    ok: false,
+                    code: null,
+                    stdout,
+                    stderr: `${stderr.trim()}\nBlocked non-interactive sudo prompt. Configure passwordless sudo for this exact command or remove sudo from the Growth Engineer connector command.`,
+                });
+            }
         });
         if (options.input !== undefined) {
             child.stdin.end(options.input);
@@ -489,6 +559,15 @@ function getCadenceDefinitions(config) {
 }
 function cadenceIsDue(cadence, state) {
     const lastRanAt = state?.cadences?.[cadence.key]?.lastRanAt;
+    const intervalMinutes = Number(cadence.intervalMinutes || 0);
+    if (intervalMinutes > 0) {
+        if (!lastRanAt)
+            return true;
+        const last = Date.parse(String(lastRanAt));
+        if (!Number.isFinite(last))
+            return true;
+        return Date.now() - last >= Math.max(1, intervalMinutes) * 60 * 1000;
+    }
     const intervalDays = Number(cadence.intervalDays || 1);
     if (!lastRanAt)
         return true;
@@ -498,11 +577,7 @@ function cadenceIsDue(cadence, state) {
     return Date.now() - last >= Math.max(1, intervalDays) * 24 * 60 * 60 * 1000;
 }
 function getDueCadences(config, state) {
-    const due = getCadenceDefinitions(config).filter((cadence) => cadenceIsDue(cadence, state));
-    if (due.length > 0)
-        return due;
-    const daily = getCadenceDefinitions(config).find((cadence) => cadence.key === 'daily');
-    return daily ? [daily] : [];
+    return getCadenceDefinitions(config).filter((cadence) => cadenceIsDue(cadence, state));
 }
 function markCadencesRan(state, cadences, ranAt) {
     const nextCadences = { ...(state?.cadences || {}) };
@@ -521,6 +596,7 @@ function getConnectorEntries(statusPayload) {
         status: String(value?.status || 'unknown'),
         detail: String(value?.detail || ''),
         nextAction: typeof value?.nextAction === 'string' ? value.nextAction : null,
+        accounts: Array.isArray(value?.accounts) ? value.accounts : [],
     }));
 }
 function getUnhealthyConfiguredConnectors(statusPayload) {
@@ -551,26 +627,208 @@ function humanConnectorName(key) {
         return 'GitHub';
     return key;
 }
+function connectorWizardKey(key) {
+    if (key === 'analyticscli')
+        return 'analytics';
+    if (key === 'appStoreConnect')
+        return 'asc';
+    if (key === 'revenuecat')
+        return 'revenuecat';
+    if (key === 'sentry')
+        return 'sentry';
+    if (key === 'github')
+        return 'github';
+    return '';
+}
+function buildConnectorWizardCommand(configPath, entry) {
+    const connector = connectorWizardKey(entry.key);
+    if (!connector)
+        return null;
+    return `npx -y @analyticscli/growth-engineer@preview wizard --connectors ${quote(connector)}`;
+}
+function conciseConnectorDetail(entry) {
+    const detail = String(entry?.detail || '').replace(/\s+/g, ' ').trim();
+    if (/SENTRY_AUTH_TOKEN is required|SENTRY_AUTH_TOKEN.*missing/i.test(detail)) {
+        return 'SENTRY_AUTH_TOKEN missing for source collection.';
+    }
+    if (/source .*disabled|still disabled/i.test(detail)) {
+        return 'source is still disabled after setup.';
+    }
+    if (!detail)
+        return 'needs attention.';
+    return detail.length > 180 ? `${detail.slice(0, 177)}...` : detail;
+}
+function isAscWebAuthIssue(entry) {
+    if (entry.key !== 'appStoreConnect')
+        return false;
+    const text = `${entry.detail || ''}\n${entry.nextAction || ''}`.toLowerCase();
+    return (text.includes('asc web auth') ||
+        text.includes('asc_web_apple_id') ||
+        text.includes('web analytics') ||
+        text.includes('webauth') ||
+        text.includes('web auth'));
+}
 function buildConnectorHealthAlert(statusPayload, unhealthyConnectors) {
-    const lines = [
-        `OpenClaw Growth connector health needs attention (${new Date().toISOString()}).`,
-        `Config: ${statusPayload?.configPath || DEFAULT_CONFIG_PATH}`,
-        '',
-        'Unhealthy connector(s):',
-    ];
+    const configPath = statusPayload?.configPath || DEFAULT_CONFIG_PATH;
+    const lines = [`OpenClaw connector health: ${unhealthyConnectors.length} issue(s)`];
     for (const entry of unhealthyConnectors) {
-        lines.push(`- ${humanConnectorName(entry.key)}: ${entry.status} - ${entry.detail}`);
-        if (entry.nextAction) {
-            lines.push(`  Next: ${entry.nextAction}`);
+        lines.push(`- ${humanConnectorName(entry.key)}: ${entry.status} - ${conciseConnectorDetail(entry)}`);
+        const command = buildConnectorWizardCommand(configPath, entry);
+        if (command) {
+            lines.push(`  Fix: \`${command}\``);
         }
-        if (entry.key === 'appStoreConnect' && entry.status === 'partial') {
-            lines.push('  Note: ASC uses API-key batch reports by default. Experimental ASC web analytics should only be requested when a needed metric is unavailable through API reports.');
+        if (isAscWebAuthIssue(entry)) {
+            lines.push('  ASC web-auth only: `ASC_WEB_APPLE_ID="<apple-id>" asc web auth login --apple-id "$ASC_WEB_APPLE_ID"`');
         }
     }
-    lines.push('');
-    lines.push('Do not send secrets through chat or social channels. Refresh credentials only in the host terminal or secret store.');
+    lines.push('Secrets stay in the host terminal or secret store.');
     return `${lines.join('\n')}\n`;
 }
+function sourceFailureConnectorKey(failure) {
+    const service = String(failure?.service || '').toLowerCase();
+    const key = String(failure?.key || '').toLowerCase();
+    const source = String(failure?.source || '').toLowerCase();
+    if (service.includes('sentry') || key === 'glitchtip')
+        return 'sentry';
+    if (source === 'sentry' || source === 'glitchtip')
+        return 'sentry';
+    if (service.includes('revenuecat'))
+        return 'revenuecat';
+    if (service.includes('paddle'))
+        return 'paddle';
+    if (service.includes('seo') || service.includes('gsc') || service.includes('search-console') || service.includes('dataforseo'))
+        return 'seo';
+    if (key === 'paddle')
+        return 'paddle';
+    if (key === 'seo')
+        return 'seo';
+    if (service.includes('coolify'))
+        return 'coolify';
+    if (service.includes('github'))
+        return 'github';
+    if (key === 'analytics')
+        return 'analyticscli';
+    return String(failure?.key || 'source');
+}
+function getSentryAccountTargets(config) {
+    const accounts = Array.isArray(config?.sources?.sentry?.accounts) ? config.sources.sentry.accounts : [];
+    if (accounts.length === 0)
+        return [];
+    return accounts.map((account, index) => ({
+        id: String(account?.id || account?.key || account?.label || `sentry_${index + 1}`)
+            .trim()
+            .replace(/[^a-zA-Z0-9._-]+/g, '_'),
+        label: String(account?.label || account?.name || account?.id || `Sentry ${index + 1}`).trim(),
+        baseUrl: String(account?.baseUrl || account?.base_url || account?.url || 'https://sentry.io').trim(),
+        org: String(account?.org || account?.organization || '').trim(),
+        projects: Array.isArray(account?.projects)
+            ? account.projects.map((project) => String(typeof project === 'string' ? project : project?.project || project?.slug || '').trim()).filter(Boolean)
+            : account?.project
+                ? [String(account.project).trim()].filter(Boolean)
+                : [],
+        environment: String(account?.environment || process.env.SENTRY_ENVIRONMENT || 'production').trim(),
+    }));
+}
+function buildSourceFailureStatusPayload(configPath, sourceFailures, config = null) {
+    const connectors = {};
+    for (const failure of sourceFailures) {
+        const key = sourceFailureConnectorKey(failure);
+        const detail = `Source collection failed during scheduled run: ${failure.detail}`;
+        const retryable = Boolean(failure.retryable || failure.transient);
+        connectors[key] = {
+            status: 'partial',
+            detail,
+            accounts: key === 'sentry' ? getSentryAccountTargets(config) : [],
+            nextAction: retryable
+                ? 'Provider returned a transient upstream/network error after retry. Rerun the Growth Engineer later; if it repeats, check the provider status page and connector credentials.'
+                : 'Run the connector wizard or source command on the host terminal and fix the reported source error.',
+        };
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        configPath,
+        connectors,
+        sourceFailures,
+    };
+}
+async function recordSourceCollectionFailures({ config, configPath, state, statePath, runtimeDir, sourceFailures }) {
+    if (sourceFailures.length === 0) {
+        return {
+            ...state,
+            lastSourceCollectionFailures: [],
+        };
+    }
+    const healthState = state?.connectorHealth || {};
+    const checkedAt = new Date().toISOString();
+    const statusPayload = buildSourceFailureStatusPayload(configPath, sourceFailures, config);
+    const unhealthyConnectors = getUnhealthyConfiguredConnectors(statusPayload);
+    const fingerprint = buildConnectorHealthFingerprint(unhealthyConnectors);
+    const previousExternallyDeliveredFingerprint = healthState.lastExternalAlertedFingerprint || null;
+    let alertTriggered = false;
+    let alertDeliveries = [];
+    const nextHealthState = {
+        ...healthState,
+        lastCheckedAt: checkedAt,
+        lastStatusOk: false,
+        lastFingerprint: fingerprint,
+        activeIncidentFingerprint: fingerprint,
+        lastError: sourceFailures.map((failure) => `${failure.key || failure.source}: ${failure.detail}`).join('\n'),
+    };
+    if (previousExternallyDeliveredFingerprint !== fingerprint) {
+        const message = buildConnectorHealthAlert(statusPayload, unhealthyConnectors);
+        const paths = await writeConnectorHealthAlert(runtimeDir, message, statusPayload, unhealthyConnectors, fingerprint);
+        const deliveries = await deliverConnectorHealthAlert({
+            config,
+            configPath,
+            message,
+            statusPayload,
+            unhealthyConnectors,
+            fingerprint,
+        });
+        alertTriggered = true;
+        alertDeliveries = deliveries;
+        nextHealthState.lastAlertedAt = checkedAt;
+        nextHealthState.lastAlertedFingerprint = fingerprint;
+        nextHealthState.lastAlertMarkdownPath = paths.markdownPath;
+        nextHealthState.lastAlertJsonPath = paths.jsonPath;
+        nextHealthState.lastAlertDeliveries = deliveries;
+        nextHealthState.lastAlertExternalSent = hasSuccessfulExternalDelivery(deliveries);
+        if (nextHealthState.lastAlertExternalSent) {
+            nextHealthState.lastExternalAlertedAt = checkedAt;
+            nextHealthState.lastExternalAlertedFingerprint = fingerprint;
+        }
+    }
+    const nextState = {
+        ...state,
+        connectorHealth: nextHealthState,
+        lastSourceCollectionFailures: sourceFailures,
+    };
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    await fs.writeFile(statePath, JSON.stringify(nextState, null, 2), 'utf8');
+    await appendSchedulerProof('source_collection_degraded', {
+        configPath,
+        statePath,
+        checkedAt,
+        sourceFailures: sourceFailures.map((failure) => ({
+            key: failure.key,
+            detail: failure.detail,
+            retryable: failure.retryable,
+        })),
+        unhealthyConnectors: unhealthyConnectors.map((entry) => ({
+            key: entry.key,
+            status: entry.status,
+            detail: entry.detail,
+        })),
+        alertTriggered,
+        deliveryCount: alertDeliveries.length,
+        externalDeliverySent: alertTriggered ? hasSuccessfulExternalDelivery(alertDeliveries) : false,
+        socialOutput: alertTriggered ? 'CONNECTOR_HEALTH_ALERT' : 'HEARTBEAT_OK',
+        socialReason: alertTriggered
+            ? 'new or changed source-collection connector incident'
+            : 'source-collection connector incident unchanged',
+    });
+    return nextState;
+}
 async function writeConnectorHealthAlert(runtimeDir, message, statusPayload, unhealthyConnectors, fingerprint) {
     const alertDir = path.join(runtimeDir, 'connector-health');
     await ensureDir(alertDir);
@@ -752,6 +1010,38 @@ function hasExternalNotificationChannel(channels) {
 function hasSuccessfulExternalDelivery(results) {
     return results.some((result) => result?.sent === true && result?.external === true);
 }
+function truncateMessageText(value, maxLength = 96) {
+    const text = String(value || '').replace(/\s+/g, ' ').trim();
+    if (text.length <= maxLength)
+        return text;
+    return `${text.slice(0, Math.max(0, maxLength - 3)).trim()}...`;
+}
+function issueProjectLabel(issue) {
+    return String(issue?.app || issue?.source_project || issue?.sourceProject || issue?.project || 'unscoped').trim();
+}
+function issueSourceUrl(issue) {
+    const direct = String(issue?.source_url || issue?.sourceUrl || issue?.issue_url || issue?.issueUrl || '').trim();
+    if (direct)
+        return direct;
+    const body = String(issue?.body || '');
+    const match = body.match(/(?:Issue link|Permalink):\s*(https?:\/\/\S+)/i);
+    return match ? match[1].replace(/[).,;]+$/, '') : '';
+}
+function formatIssueSummaryLine(issue, maxTitleLength = 92) {
+    const title = truncateMessageText(issue?.title, maxTitleLength);
+    const url = issueSourceUrl(issue);
+    return url ? `${title} (${url})` : title;
+}
+function groupIssuesByProject(issues, maxIssues = 4) {
+    const grouped = new Map();
+    for (const issue of issues.slice(0, maxIssues)) {
+        const label = issueProjectLabel(issue);
+        const bucket = grouped.get(label) || [];
+        bucket.push(issue);
+        grouped.set(label, bucket);
+    }
+    return [...grouped.entries()];
+}
 async function deliverConnectorHealthAlert({ config, configPath, message, statusPayload, unhealthyConnectors, fingerprint }) {
     const channels = getConnectorHealthChannels(config);
     if (config?.notifications?.connectorHealth?.enabled === false) {
@@ -830,6 +1120,33 @@ function buildGrowthRunSummaryMessage({ issuesPayload, activeCadences, sourceFil
         ? activeCadences.map((cadence) => cadence.title || cadence.key).join(', ')
         : 'ad-hoc growth pass';
     const sourceNames = Object.keys(sourceFiles || {}).sort().join(', ') || 'none';
+    const issues = Array.isArray(issuesPayload?.issues) ? issuesPayload.issues : [];
+    if (isShortOperationalCadence(activeCadences)) {
+        const heading = activeCadences.some((cadence) => String(cadence?.key) === 'healthcheck')
+            ? 'OpenClaw healthcheck'
+            : 'OpenClaw daily';
+        const lines = [
+            `${heading}: ${issueCount > 0 ? `${issueCount} finding(s)` : 'OK'}`,
+        ];
+        if (issueCount > 0) {
+            const groupedIssues = groupIssuesByProject(issues, 4);
+            if (groupedIssues.length > 0) {
+                lines.push('Top by project:');
+                for (const [project, projectIssues] of groupedIssues) {
+                    const formatted = projectIssues.map((issue) => formatIssueSummaryLine(issue, 84)).filter(Boolean);
+                    if (formatted.length > 0)
+                        lines.push(`- ${project}: ${formatted.join(' | ')}`);
+                }
+            }
+            lines.push(createdGitHubArtifact
+                ? 'Action: GitHub artifact attempted.'
+                : 'Action: external alert only.');
+        }
+        if (charts.length > 0) {
+            lines.push(`Charts: ${charts.length}`);
+        }
+        return `${lines.join('\n')}\n`;
+    }
     const lines = [
         `OpenClaw Growth run finished (${new Date().toISOString()}).`,
         `Cadence: ${cadenceNames}`,
@@ -848,16 +1165,26 @@ function buildGrowthRunSummaryMessage({ issuesPayload, activeCadences, sourceFil
             lines.push(`- ${chart.caption}: ${chart.filePath}`);
         }
     }
-    const issues = Array.isArray(issuesPayload?.issues) ? issuesPayload.issues.slice(0, 3) : [];
-    if (issues.length > 0) {
+    const topIssues = issues.slice(0, isDeepAnalysisCadence(activeCadences) ? 5 : 3);
+    if (topIssues.length > 0) {
         lines.push('');
-        lines.push('Top findings:');
-        for (const issue of issues) {
+        lines.push(isDeepAnalysisCadence(activeCadences) ? 'App-by-app findings and next steps:' : 'Top findings:');
+        for (const issue of topIssues) {
             lines.push(`- ${issue.title} (${issue.priority || 'medium'}, ${issue.area || 'general'})`);
+            if (isDeepAnalysisCadence(activeCadences)) {
+                for (const evidence of firstEvidenceLines(issue, 2)) {
+                    lines.push(`  Evidence: ${evidence}`);
+                }
+                if (issue.expected_impact) {
+                    lines.push(`  Impact: ${issue.expected_impact}`);
+                }
+            }
         }
     }
     lines.push('');
-    lines.push('No secrets were included. Use the generated issue drafts or OpenClaw chat handoff for details.');
+    lines.push(isDeepAnalysisCadence(activeCadences)
+        ? 'No secrets were included. Full details are in the generated issue drafts, charts, and OpenClaw chat handoff.'
+        : 'No secrets were included.');
     return `${lines.join('\n')}\n`;
 }
 async function writeConfiguredOpenClawChatGrowthSummary(configPath, channel, message, issuesPayload, activeCadences, fingerprint, charts) {
@@ -1006,6 +1333,10 @@ async function maybeRunConnectorHealthCheck({ config, configPath, state, statePa
             statePath,
             intervalMinutes,
             lastCheckedAt: healthState.lastCheckedAt || null,
+            persistedLastStatusOk: healthState.lastStatusOk !== false,
+            activeIncidentFingerprint: healthState.activeIncidentFingerprint || null,
+            socialOutput: 'HEARTBEAT_OK',
+            socialReason: 'connector health was not due; persisted unhealthy state is not a new event',
         });
         return state;
     }
@@ -1053,6 +1384,8 @@ async function maybeRunConnectorHealthCheck({ config, configPath, state, statePa
         lastError: null,
     };
     const previousExternallyDeliveredFingerprint = healthState.lastExternalAlertedFingerprint || null;
+    let alertTriggered = false;
+    let alertDeliveries = [];
     if (unhealthyConnectors.length === 0) {
         nextHealthState.activeIncidentFingerprint = null;
         nextHealthState.lastExternalAlertedFingerprint = null;
@@ -1075,6 +1408,8 @@ async function maybeRunConnectorHealthCheck({ config, configPath, state, statePa
             unhealthyConnectors,
             fingerprint,
         });
+        alertTriggered = true;
+        alertDeliveries = deliveries;
         nextHealthState.lastAlertedAt = checkedAt;
         nextHealthState.lastAlertedFingerprint = fingerprint;
         nextHealthState.lastAlertMarkdownPath = paths.markdownPath;
@@ -1105,9 +1440,27 @@ async function maybeRunConnectorHealthCheck({ config, configPath, state, statePa
             detail: entry.detail,
         })),
         alertMarkdownPath: nextHealthState.lastAlertMarkdownPath || null,
-        deliveryCount: Array.isArray(nextHealthState.lastAlertDeliveries) ? nextHealthState.lastAlertDeliveries.length : 0,
-        externalDeliverySent: nextHealthState.lastAlertExternalSent === true,
+        alertTriggered,
+        deliveryCount: alertDeliveries.length,
+        externalDeliverySent: alertTriggered ? hasSuccessfulExternalDelivery(alertDeliveries) : false,
+        socialOutput: alertTriggered ? 'CONNECTOR_HEALTH_ALERT' : 'HEARTBEAT_OK',
+        socialReason: alertTriggered
+            ? 'new or changed connector-health incident'
+            : unhealthyConnectors.length > 0
+                ? 'connector-health incident unchanged'
+                : healthState.lastStatusOk === false
+                    ? 'connector health recovered'
+                    : 'connector health unchanged healthy',
     });
+    if (unhealthyConnectors.length > 0 && !alertTriggered) {
+        await appendSchedulerProof('connector_health_unchanged', {
+            configPath,
+            statePath,
+            checkedAt,
+            fingerprint,
+            socialOutput: 'HEARTBEAT_OK',
+        });
+    }
     return nextState;
 }
 function buildIssueFingerprint(issuesPayload) {
@@ -1116,6 +1469,30 @@ function buildIssueFingerprint(issuesPayload) {
         : [];
     return sha256(titles.join('\n'));
 }
+function isShortOperationalCadence(cadences) {
+    if (!Array.isArray(cadences) || cadences.length === 0)
+        return false;
+    return cadences.every((cadence) => {
+        const key = String(cadence?.key || '').toLowerCase();
+        return key === 'healthcheck' || key === 'daily' || cadence?.criticalOnly === true;
+    });
+}
+function isDeepAnalysisCadence(cadences) {
+    if (!Array.isArray(cadences))
+        return false;
+    return cadences.some((cadence) => ['weekly', 'monthly', 'quarterly', 'six_months', 'yearly'].includes(String(cadence?.key || '').toLowerCase()));
+}
+function firstEvidenceLines(issue, maxLines = 2) {
+    const body = String(issue?.body || '');
+    const evidenceMatch = body.match(/## Evidence\n([\s\S]*?)(?:\n## |\n?$)/);
+    if (!evidenceMatch)
+        return [];
+    return evidenceMatch[1]
+        .split('\n')
+        .map((line) => line.replace(/^-\s*/, '').trim())
+        .filter(Boolean)
+        .slice(0, maxLines);
+}
 async function runAnalyzer({ config, runtimeDir, sourceFiles, createGitHubArtifact, githubArtifactMode = getActionMode(config), chartManifestPath, cadencePlanPath, }) {
     await ensureDir(runtimeDir);
     if (!sourceFiles.analytics) {
@@ -1138,9 +1515,18 @@ async function runAnalyzer({ config, runtimeDir, sourceFiles, createGitHubArtifa
     if (sourceFiles.revenuecat) {
         args.push('--revenuecat', sourceFiles.revenuecat);
     }
+    if (sourceFiles.paddle) {
+        args.push('--source', `paddle=${sourceFiles.paddle}`);
+    }
+    if (sourceFiles.seo) {
+        args.push('--source', `seo=${sourceFiles.seo}`);
+    }
     if (sourceFiles.sentry) {
         args.push('--sentry', sourceFiles.sentry);
     }
+    if (sourceFiles.coolify) {
+        args.push('--source', `coolify=${sourceFiles.coolify}`);
+    }
     if (sourceFiles.feedback) {
         args.push('--feedback', sourceFiles.feedback);
     }
@@ -1184,10 +1570,13 @@ async function runAnalyzer({ config, runtimeDir, sourceFiles, createGitHubArtifa
         analyzerStdout: analyzer.stdout.trim(),
     };
 }
-async function maybeGenerateCharts({ config, payloads, runtimeDir }) {
+async function maybeGenerateCharts({ config, payloads, runtimeDir, activeCadences }) {
     if (!config.charting?.enabled) {
         return null;
     }
+    if (!isDeepAnalysisCadence(activeCadences)) {
+        return null;
+    }
     const analyticsPayload = payloads.analytics;
     if (!analyticsPayload) {
         return null;
@@ -1262,6 +1651,7 @@ async function resolveSourcePayloadWithCursor(sourceConfig, sourceName, cursorSt
             payload: null,
             nextCursor: cursorState || null,
             resolvedCommand: null,
+            failure: null,
         };
     }
     if (sourceConfig.mode === 'command') {
@@ -1269,9 +1659,34 @@ async function resolveSourcePayloadWithCursor(sourceConfig, sourceName, cursorSt
             throw new Error(`Source "${sourceName}" has mode=command but no command configured.`);
         }
         const resolvedCommand = resolveCursorAwareCommand(withActiveConfigArg(replaceLegacyRuntimeScriptCommand(sourceConfig.command), configPath), sourceConfig, cursorState);
-        const result = await runShellCommand(String(resolvedCommand), 120_000, { cwd: commandCwd });
+        let result = await runShellCommand(String(resolvedCommand), 120_000, { cwd: commandCwd });
+        let retried = false;
+        if (!result.ok && isTransientNetworkFailure(result.stderr || result.stdout)) {
+            retried = true;
+            await sleep(1_500);
+            result = await runShellCommand(String(resolvedCommand), 120_000, { cwd: commandCwd });
+        }
         if (!result.ok) {
-            throw new Error(`Source "${sourceName}" command failed: ${result.stderr || `exit ${result.code}`}`);
+            const detail = `${retried ? 'transient network error persisted after retry: ' : ''}${result.stderr || `exit ${result.code}`}`;
+            if (shouldDegradeTransientSourceFailure(sourceConfig, sourceName, retried)) {
+                return {
+                    payload: null,
+                    nextCursor: cursorState || null,
+                    resolvedCommand,
+                    failure: {
+                        key: sourceName,
+                        label: sourceConfig.label || sourceName,
+                        service: sourceConfig.service || sourceName,
+                        source: sourceName,
+                        transient: true,
+                        retryable: true,
+                        retried: true,
+                        at: new Date().toISOString(),
+                        detail,
+                    },
+                };
+            }
+            throw new Error(`Source "${sourceName}" command failed: ${detail}`);
         }
         const fetchedAt = new Date().toISOString();
         try {
@@ -1282,9 +1697,11 @@ async function resolveSourcePayloadWithCursor(sourceConfig, sourceName, cursorSt
                         lastCollectedAt: fetchedAt,
                         updatedAt: fetchedAt,
                         lastCommand: resolvedCommand,
+                        lastRetriedTransientFailureAt: retried ? fetchedAt : null,
                     }
                     : cursorState || null,
                 resolvedCommand,
+                failure: null,
             };
         }
         catch {
@@ -1298,15 +1715,36 @@ async function resolveSourcePayloadWithCursor(sourceConfig, sourceName, cursorSt
         payload: await readJson(path.resolve(String(sourceConfig.path))),
         nextCursor: cursorState || null,
         resolvedCommand: null,
+        failure: null,
     };
 }
 async function loadSourcePayloads(config, state, configPath) {
     const payloads = {};
     const sourceCursors = { ...(state?.sourceCursors || {}) };
+    const sourceFailures = [];
     const commandCwd = getProjectCommandCwd(config);
     for (const source of getAllSourceEntries(config)) {
         const currentCursor = sourceCursors[source.key] || null;
-        const result = await resolveSourcePayloadWithCursor(source, source.key, currentCursor, commandCwd, configPath);
+        let result;
+        try {
+            result = await resolveSourcePayloadWithCursor(source, source.key, currentCursor, commandCwd, configPath);
+        }
+        catch (error) {
+            if (source.key === 'analytics') {
+                throw error;
+            }
+            const detail = error instanceof Error ? error.message : String(error);
+            sourceFailures.push({
+                key: source.key,
+                label: source.label || source.key,
+                service: source.service || source.key,
+                detail,
+                retryable: isTransientNetworkFailure(detail),
+                failedAt: new Date().toISOString(),
+            });
+            process.stderr.write(`[${new Date().toISOString()}] Optional source "${source.key}" failed; continuing without it: ${detail}\n`);
+            continue;
+        }
         const payload = result.payload;
         if (payload) {
             payloads[source.key] = payload;
@@ -1314,10 +1752,22 @@ async function loadSourcePayloads(config, state, configPath) {
         if (result.nextCursor) {
             sourceCursors[source.key] = result.nextCursor;
         }
+        if (result.failure) {
+            sourceFailures.push(result.failure);
+            await appendSchedulerProof('source_collection_degraded', {
+                configPath,
+                source: result.failure.source,
+                transient: result.failure.transient,
+                retried: result.failure.retried,
+                detail: result.failure.detail,
+                socialOutput: 'HEARTBEAT_OK',
+            });
+        }
     }
     return {
         payloads,
         sourceCursors,
+        sourceFailures,
     };
 }
 async function materializeSourceFiles(config, payloads, runtimeDir) {
@@ -1350,6 +1800,20 @@ async function runOnce(configPath, statePath) {
         argv: process.argv.slice(2),
     });
     const config = await readJson(configPath);
+    const cronDeliveryRepair = await repairOpenClawCronDeliveryStore({
+        configPath,
+        config,
+        readFile: fs.readFile,
+        writeFile: fs.writeFile,
+    });
+    if (cronDeliveryRepair.repaired) {
+        await appendSchedulerProof('openclaw_cron_delivery_repaired', {
+            configPath,
+            statePath,
+            path: cronDeliveryRepair.path,
+            repairedCount: cronDeliveryRepair.repairedCount,
+        });
+    }
     await applyOpenClawSecretRefs(config);
     const inferredGitHubRepo = await inferGitHubRepo(config);
     if (inferredGitHubRepo) {
@@ -1374,26 +1838,36 @@ async function runOnce(configPath, statePath) {
         runtimeDir,
     });
     const activeCadences = getDueCadences(config, stateAfterHealthCheck);
-    const { payloads, sourceCursors } = await loadSourcePayloads(config, stateAfterHealthCheck, configPath);
+    const { payloads, sourceCursors, sourceFailures } = await loadSourcePayloads(config, stateAfterHealthCheck, configPath);
+    const stateAfterSourceCollection = await recordSourceCollectionFailures({
+        config,
+        configPath,
+        state: stateAfterHealthCheck,
+        statePath,
+        runtimeDir,
+        sourceFailures,
+    });
     const currentHashes = computeSourceHashes(payloads);
-    const changed = hasSourceChanges(stateAfterHealthCheck.sourceHashes, currentHashes);
-    if (!changed && config.schedule?.skipIfNoDataChange !== false) {
-        process.stdout.write(`[${new Date().toISOString()}] No data changes. Skip run.\n`);
+    if (activeCadences.length === 0) {
+        process.stdout.write(`[${new Date().toISOString()}] No scheduled cadence due. Skip run.\n`);
         const completedAt = new Date().toISOString();
         await fs.mkdir(path.dirname(statePath), { recursive: true });
         await fs.writeFile(statePath, JSON.stringify({
             ...stateAfterHealthCheck,
+            ...stateAfterSourceCollection,
             sourceHashes: currentHashes,
             sourceCursors,
+            lastSourceFailures: sourceFailures,
             lastRunAt: completedAt,
-            skippedReason: 'no_data_change',
+            skippedReason: 'cadence_not_due',
         }, null, 2), 'utf8');
         await appendSchedulerProof('runner_completed', {
             configPath,
             statePath,
             completedAt,
-            skippedReason: 'no_data_change',
-            activeCadences: activeCadences.map((cadence) => cadence.key),
+            skippedReason: 'cadence_not_due',
+            sourceFailures,
+            socialOutput: 'HEARTBEAT_OK',
         });
         return;
     }
@@ -1409,6 +1883,7 @@ async function runOnce(configPath, statePath) {
         config,
         payloads,
         runtimeDir,
+        activeCadences,
     });
     const dryRun = await runAnalyzer({
         config,
@@ -1419,19 +1894,29 @@ async function runOnce(configPath, statePath) {
         cadencePlanPath,
     });
     const issueFingerprint = buildIssueFingerprint(dryRun.issuesPayload);
-    const unchangedIssueSet = issueFingerprint === stateAfterHealthCheck.lastIssueFingerprint;
-    if (unchangedIssueSet && config.schedule?.skipIfIssueSetUnchanged !== false) {
-        process.stdout.write(`[${new Date().toISOString()}] Issue set unchanged. Skip GitHub creation.\n`);
+    const unchangedIssueSet = issueFingerprint === stateAfterSourceCollection.lastIssueFingerprint;
+    if (unchangedIssueSet &&
+        config.schedule?.skipIfIssueSetUnchanged !== false) {
+        process.stdout.write(`[${new Date().toISOString()}] Issue set unchanged. Skip GitHub creation and external growth notification.\n`);
         const completedAt = new Date().toISOString();
         await fs.mkdir(path.dirname(statePath), { recursive: true });
         await fs.writeFile(statePath, JSON.stringify({
             ...stateAfterHealthCheck,
+            ...stateAfterSourceCollection,
             sourceHashes: currentHashes,
             sourceCursors,
+            lastSourceFailures: sourceFailures,
             lastIssueFingerprint: issueFingerprint,
             lastRunAt: completedAt,
             lastOutFile: dryRun.outFile,
-            cadences: markCadencesRan(stateAfterHealthCheck, activeCadences, completedAt),
+            cadences: markCadencesRan(stateAfterSourceCollection, activeCadences, completedAt),
+            lastGrowthRunNotifications: [
+                {
+                    sent: false,
+                    target: 'growth_run',
+                    detail: 'issue set unchanged; external growth notification suppressed',
+                },
+            ],
             skippedReason: 'issue_set_unchanged',
         }, null, 2), 'utf8');
         await appendSchedulerProof('runner_completed', {
@@ -1441,10 +1926,17 @@ async function runOnce(configPath, statePath) {
             skippedReason: 'issue_set_unchanged',
             activeCadences: activeCadences.map((cadence) => cadence.key),
             outFile: dryRun.outFile,
+            issueCount: Number(dryRun.issuesPayload?.issue_count || 0),
+            sourceFailures,
+            externalGrowthNotification: 'suppressed_unchanged_issue_set',
+            socialOutput: 'HEARTBEAT_OK',
         });
         return;
     }
-    const shouldCreateGitHubArtifact = createGitHubArtifact && Number(dryRun.issuesPayload?.issue_count || 0) > 0;
+    const issueSetChangedOrExplicitlyAllowed = !unchangedIssueSet || config.schedule?.skipIfIssueSetUnchanged === false;
+    const shouldCreateGitHubArtifact = createGitHubArtifact &&
+        Number(dryRun.issuesPayload?.issue_count || 0) > 0 &&
+        issueSetChangedOrExplicitlyAllowed;
     if (shouldCreateGitHubArtifact) {
         for (const githubArtifactMode of githubArtifactModes) {
             await runAnalyzer({
@@ -1466,12 +1958,14 @@ async function runOnce(configPath, statePath) {
     await fs.mkdir(path.dirname(statePath), { recursive: true });
     await fs.writeFile(statePath, JSON.stringify({
         ...stateAfterHealthCheck,
+        ...stateAfterSourceCollection,
         sourceHashes: currentHashes,
         sourceCursors,
+        lastSourceFailures: sourceFailures,
         lastIssueFingerprint: issueFingerprint,
         lastRunAt: completedAt,
         lastOutFile: dryRun.outFile,
-        cadences: markCadencesRan(stateAfterHealthCheck, activeCadences, completedAt),
+        cadences: markCadencesRan(stateAfterSourceCollection, activeCadences, completedAt),
         lastGrowthRunNotifications: await deliverGrowthRunSummary({
             config,
             configPath,
@@ -1492,6 +1986,7 @@ async function runOnce(configPath, statePath) {
         activeCadences: activeCadences.map((cadence) => cadence.key),
         outFile: dryRun.outFile,
         issueCount: Number(dryRun.issuesPayload?.issue_count || 0),
+        sourceFailures,
         createdGitHubArtifact: shouldCreateGitHubArtifact,
     });
 }