@analyticscli/growth-engineer 0.1.0-preview.8 → 0.1.0

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

@@ -4,63 +4,76 @@ import path from 'node:path';
 import process from 'node:process';
 import { createHash } from 'node:crypto';
 import { spawn } from 'node:child_process';
-import { getActionMode, getAllSourceEntries, getGitHubRequirementText, shouldAutoCreateGitHubArtifact, } from './openclaw-growth-shared.mjs';
+import { fileURLToPath } from 'node:url';
+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';
-const DEFAULT_RUNTIME_DIR = 'data/openclaw-growth-engineer/runtime';
+const DEFAULT_SCHEDULER_PROOF_PATH = 'data/openclaw-growth-engineer/runtime/scheduler-proof.jsonl';
 const DEFAULT_CONNECTOR_HEALTH_INTERVAL_MINUTES = 360;
 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',
@@ -68,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.',
     },
@@ -127,6 +140,50 @@ Default state:  ${DEFAULT_STATE_PATH}
 `);
     process.exit(exitCode);
 }
+function resolveRuntimeScriptPath(scriptName) {
+    const candidates = [
+        path.join(RUNTIME_DIR, scriptName),
+        path.resolve('scripts', scriptName),
+        path.resolve('skills/openclaw-growth-engineer/scripts', scriptName),
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) || path.join(RUNTIME_DIR, scriptName);
+}
+function nodeRuntimeScriptCommand(scriptName) {
+    return `node ${quote(resolveRuntimeScriptPath(scriptName))}`;
+}
+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-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 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 || !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)}`)
+            .replace(/(^|\s)--config\s+(?:"[^"]*"|'[^']*'|\S+)/, `$1--config ${quote(configPath)}`);
+    }
+    return `${trimmed} --config ${quote(configPath)}`;
+}
 async function readJson(filePath) {
     const raw = await fs.readFile(filePath, 'utf8');
     return JSON.parse(raw);
@@ -142,6 +199,22 @@ async function readJsonOptional(filePath, fallback) {
 async function ensureDir(dirPath) {
     await fs.mkdir(dirPath, { recursive: true });
 }
+async function appendSchedulerProof(event, details = {}) {
+    const proofPath = schedulerProofPath;
+    const entry = {
+        ts: new Date().toISOString(),
+        event,
+        pid: process.pid,
+        cwd: process.cwd(),
+        ...details,
+    };
+    await fs.mkdir(path.dirname(proofPath), { recursive: true });
+    await fs.appendFile(proofPath, `${JSON.stringify(entry)}\n`, 'utf8');
+}
+function useSchedulerProofPathForStatePath(statePath) {
+    schedulerProofPath = path.resolve(deriveSchedulerProofPathFromStatePath(statePath));
+    return schedulerProofPath;
+}
 function sha256(input) {
     return createHash('sha256').update(input).digest('hex');
 }
@@ -151,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());
 }
@@ -296,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 = '';
@@ -317,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);
@@ -435,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;
@@ -444,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 || {}) };
@@ -467,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) {
@@ -497,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 web analytics uses a user-owned web session. If Apple expires it after a few hours, refresh it with `asc web auth login`; API-key ASC auth cannot replace this web session.');
+        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);
@@ -531,20 +843,43 @@ async function writeConnectorHealthAlert(runtimeDir, message, statusPayload, unh
     }, null, 2), 'utf8');
     return { markdownPath, jsonPath };
 }
-function getConnectorHealthChannels(config) {
-    const configuredChannels = Array.isArray(config?.notifications?.connectorHealth?.channels)
-        ? config.notifications.connectorHealth.channels.filter((channel) => channel?.enabled !== false)
-        : [];
-    if (configuredChannels.length > 0)
-        return configuredChannels;
+function notificationChannelKey(channel) {
+    const type = String(channel?.type || 'openclaw-chat');
+    if (type === 'openclaw-chat')
+        return 'openclaw-chat';
+    if (type === 'slack')
+        return `slack:${channel?.label || channel?.webhookEnv || 'slack'}`;
+    if (type === 'webhook')
+        return `webhook:${channel?.label || channel?.urlEnv || channel?.webhookEnv || 'webhook'}`;
+    if (type === 'command')
+        return `command:${channel?.label || channel?.command || 'command'}`;
+    return `${type}:${channel?.label || type}`;
+}
+function mergeNotificationChannelsWithDeliveries(configuredChannels, deliveryChannels) {
+    const configured = Array.isArray(configuredChannels) ? configuredChannels : [];
+    const seen = new Set(configured.map((channel) => notificationChannelKey(channel)));
+    const channels = configured.filter((channel) => channel?.enabled !== false);
+    for (const channel of deliveryChannels) {
+        if (!seen.has(notificationChannelKey(channel))) {
+            channels.push(channel);
+        }
+    }
+    return channels;
+}
+function getDeliveryNotificationChannels(config, kind) {
     const channels = [];
     const deliveries = config?.deliveries || {};
     if (deliveries.openclawChat?.enabled) {
+        const isConnectorHealth = kind === 'connectorHealth';
         channels.push({
             type: 'openclaw-chat',
             label: 'openclaw_chat',
-            markdownPath: deliveries.openclawChat.connectorHealthMarkdownPath || deliveries.openclawChat.markdownPath,
-            jsonPath: deliveries.openclawChat.connectorHealthJsonPath || deliveries.openclawChat.jsonPath,
+            markdownPath: isConnectorHealth
+                ? deliveries.openclawChat.connectorHealthMarkdownPath || deliveries.openclawChat.markdownPath
+                : deliveries.openclawChat.growthRunMarkdownPath || '.openclaw/chat/growth-summary.md',
+            jsonPath: isConnectorHealth
+                ? deliveries.openclawChat.connectorHealthJsonPath || deliveries.openclawChat.jsonPath
+                : deliveries.openclawChat.growthRunJsonPath || '.openclaw/chat/growth-summary.json',
         });
     }
     if (deliveries.slack?.enabled) {
@@ -563,19 +898,37 @@ function getConnectorHealthChannels(config) {
             headers: deliveries.webhook.headers || {},
         });
     }
+    if (deliveries.command?.enabled) {
+        channels.push({
+            type: 'command',
+            label: deliveries.command.label || 'command',
+            command: deliveries.command.command || '',
+        });
+    }
     if (deliveries.discord?.enabled) {
         channels.push({
             type: 'command',
-            label: 'discord',
-            command: deliveries.discord.command || 'node scripts/discord-openclaw-bridge.mjs send --stdin',
+            label: deliveries.discord.label || 'discord',
+            command: deliveries.discord.command || '',
         });
     }
     return channels;
 }
+function getConnectorHealthChannels(config) {
+    const configuredChannels = Array.isArray(config?.notifications?.connectorHealth?.channels)
+        ? config.notifications.connectorHealth.channels
+        : [];
+    return mergeNotificationChannelsWithDeliveries(configuredChannels, getDeliveryNotificationChannels(config, 'connectorHealth'));
+}
+function resolveOpenClawChatDeliveryPath(channelPath, fallbackPath) {
+    const targetPath = String(channelPath || fallbackPath || '').trim();
+    if (!targetPath)
+        return path.resolve(process.cwd(), fallbackPath);
+    return path.isAbsolute(targetPath) ? targetPath : path.resolve(process.cwd(), targetPath);
+}
 async function writeConfiguredOpenClawChatAlert(configPath, channel, message, statusPayload, unhealthyConnectors, fingerprint) {
-    const baseDir = path.dirname(path.resolve(configPath));
-    const markdownPath = path.resolve(baseDir, channel.markdownPath || '.openclaw/chat/connector-health.md');
-    const jsonPath = path.resolve(baseDir, channel.jsonPath || '.openclaw/chat/connector-health.json');
+    const markdownPath = resolveOpenClawChatDeliveryPath(channel.markdownPath, '.openclaw/chat/connector-health.md');
+    const jsonPath = resolveOpenClawChatDeliveryPath(channel.jsonPath, '.openclaw/chat/connector-health.json');
     await fs.mkdir(path.dirname(markdownPath), { recursive: true });
     await fs.mkdir(path.dirname(jsonPath), { recursive: true });
     await fs.writeFile(markdownPath, message, 'utf8');
@@ -588,8 +941,9 @@ async function writeConfiguredOpenClawChatAlert(configPath, channel, message, st
     }, null, 2), 'utf8');
     return {
         sent: true,
+        external: false,
         target: channel.label || 'openclaw_chat',
-        detail: `wrote ${markdownPath} and ${jsonPath}`,
+        detail: `wrote local OpenClaw chat outbox ${markdownPath} and ${jsonPath}`,
     };
 }
 async function sendSlackConnectorHealthAlert(channel, message) {
@@ -605,6 +959,7 @@ async function sendSlackConnectorHealthAlert(channel, message) {
     });
     return {
         sent: response.ok,
+        external: true,
         target: channel.label || 'slack',
         detail: response.ok ? `HTTP ${response.status}` : `HTTP ${response.status}: ${await response.text()}`,
     };
@@ -632,6 +987,7 @@ async function sendWebhookConnectorHealthAlert(channel, message, statusPayload,
     });
     return {
         sent: response.ok,
+        external: true,
         target: channel.label || 'webhook',
         detail: response.ok ? `HTTP ${response.status}` : `HTTP ${response.status}: ${await response.text()}`,
     };
@@ -643,10 +999,49 @@ async function sendCommandConnectorHealthAlert(channel, message) {
     const result = await runShellCommand(String(channel.command), 60_000, { input: message });
     return {
         sent: result.ok,
+        external: true,
         target: channel.label || 'command',
         detail: result.ok ? result.stdout.trim() : result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`,
     };
 }
+function hasExternalNotificationChannel(channels) {
+    return channels.some((channel) => channel?.type && channel.type !== 'openclaw-chat');
+}
+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) {
@@ -682,55 +1077,76 @@ async function deliverConnectorHealthAlert({ config, configPath, message, status
             });
         }
     }
+    if (!hasSuccessfulExternalDelivery(results)) {
+        results.push({
+            sent: false,
+            external: true,
+            target: 'external_notification',
+            detail: hasExternalNotificationChannel(channels)
+                ? 'No external notification channel successfully sent the alert.'
+                : 'Alert written locally, but no external notification channel configured.',
+        });
+    }
     return results;
 }
 function getGrowthRunChannels(config) {
     const configuredChannels = Array.isArray(config?.notifications?.growthRun?.channels)
-        ? config.notifications.growthRun.channels.filter((channel) => channel?.enabled !== false)
+        ? config.notifications.growthRun.channels
         : [];
-    if (configuredChannels.length > 0)
-        return configuredChannels;
-    const channels = [];
-    const deliveries = config?.deliveries || {};
-    if (deliveries.openclawChat?.enabled) {
-        channels.push({
-            type: 'openclaw-chat',
-            label: 'openclaw_chat',
-            markdownPath: deliveries.openclawChat.growthRunMarkdownPath || '.openclaw/chat/growth-summary.md',
-            jsonPath: deliveries.openclawChat.growthRunJsonPath || '.openclaw/chat/growth-summary.json',
-        });
-    }
-    if (deliveries.slack?.enabled) {
-        channels.push({
-            type: 'slack',
-            label: 'slack',
-            webhookEnv: deliveries.slack.webhookEnv || 'SLACK_WEBHOOK_URL',
-        });
-    }
-    if (deliveries.webhook?.enabled) {
-        channels.push({
-            type: 'webhook',
-            label: 'webhook',
-            urlEnv: deliveries.webhook.urlEnv || 'OPENCLAW_WEBHOOK_URL',
-            method: deliveries.webhook.method || 'POST',
-            headers: deliveries.webhook.headers || {},
-        });
+    return mergeNotificationChannelsWithDeliveries(configuredChannels, getDeliveryNotificationChannels(config, 'growthRun'));
+}
+async function readChartAttachments(chartManifestPath) {
+    if (!chartManifestPath)
+        return [];
+    try {
+        const manifest = await readJson(chartManifestPath);
+        return Array.isArray(manifest?.charts)
+            ? manifest.charts
+                .map((chart) => ({
+                signalId: String(chart.signal_id || chart.signalId || '').trim(),
+                filePath: String(chart.file_path || chart.filePath || '').trim(),
+                caption: String(chart.caption || chart.title || 'Data chart').trim(),
+            }))
+                .filter((chart) => chart.filePath)
+            : [];
     }
-    if (deliveries.discord?.enabled) {
-        channels.push({
-            type: 'command',
-            label: 'discord',
-            command: deliveries.discord.command || 'node scripts/discord-openclaw-bridge.mjs send --stdin',
-        });
+    catch {
+        return [];
     }
-    return channels;
 }
-function buildGrowthRunSummaryMessage({ issuesPayload, activeCadences, sourceFiles, createdGitHubArtifact }) {
+function buildGrowthRunSummaryMessage({ issuesPayload, activeCadences, sourceFiles, createdGitHubArtifact, charts = [] }) {
     const issueCount = Number(issuesPayload?.issue_count || 0);
     const cadenceNames = activeCadences.length > 0
         ? 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}`,
@@ -743,22 +1159,37 @@ function buildGrowthRunSummaryMessage({ issuesPayload, activeCadences, sourceFil
     if (createdGitHubArtifact) {
         lines.push('GitHub artifact creation was attempted for the generated proposals.');
     }
-    const issues = Array.isArray(issuesPayload?.issues) ? issuesPayload.issues.slice(0, 3) : [];
-    if (issues.length > 0) {
+    if (charts.length > 0) {
+        lines.push(`Charts generated: ${charts.length}`);
+        for (const chart of charts.slice(0, 5)) {
+            lines.push(`- ${chart.caption}: ${chart.filePath}`);
+        }
+    }
+    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) {
-    const baseDir = path.dirname(path.resolve(configPath));
-    const markdownPath = path.resolve(baseDir, channel.markdownPath || '.openclaw/chat/growth-summary.md');
-    const jsonPath = path.resolve(baseDir, channel.jsonPath || '.openclaw/chat/growth-summary.json');
+async function writeConfiguredOpenClawChatGrowthSummary(configPath, channel, message, issuesPayload, activeCadences, fingerprint, charts) {
+    const markdownPath = resolveOpenClawChatDeliveryPath(channel.markdownPath, '.openclaw/chat/growth-summary.md');
+    const jsonPath = resolveOpenClawChatDeliveryPath(channel.jsonPath, '.openclaw/chat/growth-summary.json');
     await fs.mkdir(path.dirname(markdownPath), { recursive: true });
     await fs.mkdir(path.dirname(jsonPath), { recursive: true });
     await fs.writeFile(markdownPath, message, 'utf8');
@@ -769,11 +1200,18 @@ async function writeConfiguredOpenClawChatGrowthSummary(configPath, channel, mes
         activeCadences,
         issueCount: Number(issuesPayload?.issue_count || 0),
         issues: Array.isArray(issuesPayload?.issues) ? issuesPayload.issues : [],
+        charts,
+        attachments: charts.map((chart) => ({
+            type: 'image/png',
+            path: chart.filePath,
+            caption: chart.caption,
+        })),
     }, null, 2), 'utf8');
     return {
         sent: true,
+        external: false,
         target: channel.label || 'openclaw_chat',
-        detail: `wrote ${markdownPath} and ${jsonPath}`,
+        detail: `wrote local OpenClaw chat outbox ${markdownPath} and ${jsonPath}`,
     };
 }
 async function sendSlackGrowthSummary(channel, message) {
@@ -789,11 +1227,12 @@ async function sendSlackGrowthSummary(channel, message) {
     });
     return {
         sent: response.ok,
+        external: true,
         target: channel.label || 'slack',
         detail: response.ok ? `HTTP ${response.status}` : `HTTP ${response.status}: ${await response.text()}`,
     };
 }
-async function sendWebhookGrowthSummary(channel, message, issuesPayload, activeCadences, fingerprint) {
+async function sendWebhookGrowthSummary(channel, message, issuesPayload, activeCadences, fingerprint, charts) {
     const urlEnv = channel.urlEnv || channel.webhookEnv || 'OPENCLAW_WEBHOOK_URL';
     const webhookUrl = process.env[urlEnv];
     if (!webhookUrl) {
@@ -813,10 +1252,17 @@ async function sendWebhookGrowthSummary(channel, message, issuesPayload, activeC
             activeCadences,
             issueCount: Number(issuesPayload?.issue_count || 0),
             issues: Array.isArray(issuesPayload?.issues) ? issuesPayload.issues : [],
+            charts,
+            attachments: charts.map((chart) => ({
+                type: 'image/png',
+                path: chart.filePath,
+                caption: chart.caption,
+            })),
         }),
     });
     return {
         sent: response.ok,
+        external: true,
         target: channel.label || 'webhook',
         detail: response.ok ? `HTTP ${response.status}` : `HTTP ${response.status}: ${await response.text()}`,
     };
@@ -828,11 +1274,12 @@ async function sendCommandGrowthSummary(channel, message) {
     const result = await runShellCommand(String(channel.command), 60_000, { input: message });
     return {
         sent: result.ok,
+        external: true,
         target: channel.label || 'command',
         detail: result.ok ? result.stdout.trim() : result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`,
     };
 }
-async function deliverGrowthRunSummary({ config, configPath, issuesPayload, activeCadences, sourceFiles, fingerprint, createdGitHubArtifact, }) {
+async function deliverGrowthRunSummary({ config, configPath, issuesPayload, activeCadences, sourceFiles, fingerprint, createdGitHubArtifact, chartManifestPath, }) {
     if (config?.notifications?.growthRun?.enabled === false) {
         return [{ sent: false, target: 'notifications', detail: 'growth run notifications disabled' }];
     }
@@ -840,23 +1287,25 @@ async function deliverGrowthRunSummary({ config, configPath, issuesPayload, acti
     if (channels.length === 0) {
         return [{ sent: false, target: 'none', detail: 'no growth run notification channels configured' }];
     }
+    const charts = await readChartAttachments(chartManifestPath);
     const message = buildGrowthRunSummaryMessage({
         issuesPayload,
         activeCadences,
         sourceFiles,
         createdGitHubArtifact,
+        charts,
     });
     const results = [];
     for (const channel of channels) {
         try {
             if (channel.type === 'openclaw-chat') {
-                results.push(await writeConfiguredOpenClawChatGrowthSummary(configPath, channel, message, issuesPayload, activeCadences, fingerprint));
+                results.push(await writeConfiguredOpenClawChatGrowthSummary(configPath, channel, message, issuesPayload, activeCadences, fingerprint, charts));
             }
             else if (channel.type === 'slack') {
                 results.push(await sendSlackGrowthSummary(channel, message));
             }
             else if (channel.type === 'webhook') {
-                results.push(await sendWebhookGrowthSummary(channel, message, issuesPayload, activeCadences, fingerprint));
+                results.push(await sendWebhookGrowthSummary(channel, message, issuesPayload, activeCadences, fingerprint, charts));
             }
             else if (channel.type === 'command') {
                 results.push(await sendCommandGrowthSummary(channel, message));
@@ -879,12 +1328,21 @@ async function maybeRunConnectorHealthCheck({ config, configPath, state, statePa
     const healthState = state?.connectorHealth || {};
     const intervalMinutes = getConnectorHealthIntervalMinutes(config);
     if (!isDue(healthState.lastCheckedAt, intervalMinutes)) {
+        await appendSchedulerProof('connector_health_not_due', {
+            configPath,
+            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;
     }
     await ensureDir(runtimeDir);
     const statusCommand = [
-        'node',
-        'scripts/openclaw-growth-status.mjs',
+        nodeRuntimeScriptCommand('openclaw-growth-status.mjs'),
         '--config',
         quote(configPath),
         '--timeout-ms',
@@ -905,6 +1363,13 @@ async function maybeRunConnectorHealthCheck({ config, configPath, state, statePa
         };
         await fs.mkdir(path.dirname(statePath), { recursive: true });
         await fs.writeFile(statePath, JSON.stringify(nextState, null, 2), 'utf8');
+        await appendSchedulerProof('connector_health_check_failed', {
+            configPath,
+            statePath,
+            intervalMinutes,
+            checkedAt,
+            error: nextState.connectorHealth.lastError,
+        });
         return nextState;
     }
     const unhealthyConnectors = getUnhealthyConfiguredConnectors(statusPayload);
@@ -918,11 +1383,12 @@ async function maybeRunConnectorHealthCheck({ config, configPath, state, statePa
         connectedConnectors,
         lastError: null,
     };
-    const previousIncidentFingerprint = healthState.lastStatusOk === false
-        ? healthState.activeIncidentFingerprint || healthState.lastAlertedFingerprint || null
-        : null;
+    const previousExternallyDeliveredFingerprint = healthState.lastExternalAlertedFingerprint || null;
+    let alertTriggered = false;
+    let alertDeliveries = [];
     if (unhealthyConnectors.length === 0) {
         nextHealthState.activeIncidentFingerprint = null;
+        nextHealthState.lastExternalAlertedFingerprint = null;
         if (healthState.lastStatusOk === false) {
             nextHealthState.lastRecoveredAt = checkedAt;
         }
@@ -931,7 +1397,7 @@ async function maybeRunConnectorHealthCheck({ config, configPath, state, statePa
         nextHealthState.activeIncidentFingerprint = fingerprint;
     }
     if (unhealthyConnectors.length > 0 &&
-        previousIncidentFingerprint !== fingerprint) {
+        previousExternallyDeliveredFingerprint !== fingerprint) {
         const message = buildConnectorHealthAlert(statusPayload, unhealthyConnectors);
         const paths = await writeConnectorHealthAlert(runtimeDir, message, statusPayload, unhealthyConnectors, fingerprint);
         const deliveries = await deliverConnectorHealthAlert({
@@ -942,11 +1408,18 @@ async function maybeRunConnectorHealthCheck({ config, configPath, state, statePa
             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,
@@ -954,6 +1427,40 @@ async function maybeRunConnectorHealthCheck({ config, configPath, state, statePa
     };
     await fs.mkdir(path.dirname(statePath), { recursive: true });
     await fs.writeFile(statePath, JSON.stringify(nextState, null, 2), 'utf8');
+    await appendSchedulerProof('connector_health_checked', {
+        configPath,
+        statePath,
+        intervalMinutes,
+        checkedAt,
+        lastStatusOk: nextHealthState.lastStatusOk,
+        connectedConnectors,
+        unhealthyConnectors: unhealthyConnectors.map((entry) => ({
+            key: entry.key,
+            status: entry.status,
+            detail: entry.detail,
+        })),
+        alertMarkdownPath: nextHealthState.lastAlertMarkdownPath || null,
+        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) {
@@ -962,14 +1469,38 @@ function buildIssueFingerprint(issuesPayload) {
         : [];
     return sha256(titles.join('\n'));
 }
-async function runAnalyzer({ config, runtimeDir, sourceFiles, createGitHubArtifact, chartManifestPath, cadencePlanPath, }) {
+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) {
         throw new Error('Analytics source is required (enable and configure `sources.analytics`).');
     }
     const outFile = path.resolve(config.project?.outFile || 'data/openclaw-growth-engineer/issues.generated.json');
     const args = [
-        'scripts/openclaw-growth-engineer.mjs',
+        resolveRuntimeScriptPath('openclaw-growth-engineer.mjs'),
         '--analytics',
         sourceFiles.analytics,
         '--repo-root',
@@ -984,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);
     }
@@ -997,8 +1537,8 @@ async function runAnalyzer({ config, runtimeDir, sourceFiles, createGitHubArtifa
     }
     if (createGitHubArtifact) {
         const repo = String(config.project?.githubRepo || '').trim();
-        args.push(getActionMode(config) === 'pull_request' ? '--create-pull-requests' : '--create-issues', '--repo', repo);
-        if (getActionMode(config) === 'pull_request') {
+        args.push(githubArtifactMode === 'pull_request' ? '--create-pull-requests' : '--create-issues', '--repo', repo);
+        if (githubArtifactMode === 'pull_request') {
             args.push('--allow-proposal-pull-requests');
         }
         const labels = Array.isArray(config.project?.labels) ? config.project.labels : [];
@@ -1030,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;
@@ -1046,7 +1589,7 @@ async function maybeGenerateCharts({ config, payloads, runtimeDir }) {
     await fs.writeFile(analyticsForChartsPath, JSON.stringify(analyticsPayload, null, 2), 'utf8');
     const defaultCommand = [
         'python3',
-        'scripts/openclaw-growth-charts.py',
+        resolveRuntimeScriptPath('openclaw-growth-charts.py'),
         '--analytics',
         analyticsForChartsPath,
         '--out-dir',
@@ -1102,22 +1645,48 @@ function resolveCursorAwareCommand(command, sourceConfig, cursorState) {
     const lookback = normalizeLookback(sourceConfig?.initialLookback, '30d');
     return `${rawCommand} --last ${quote(lookback)}`;
 }
-async function resolveSourcePayloadWithCursor(sourceConfig, sourceName, cursorState, commandCwd = process.cwd()) {
+async function resolveSourcePayloadWithCursor(sourceConfig, sourceName, cursorState, commandCwd = process.cwd(), configPath = null) {
     if (!sourceConfig || sourceConfig.enabled === false) {
         return {
             payload: null,
             nextCursor: cursorState || null,
             resolvedCommand: null,
+            failure: null,
         };
     }
     if (sourceConfig.mode === 'command') {
         if (!sourceConfig.command) {
             throw new Error(`Source "${sourceName}" has mode=command but no command configured.`);
         }
-        const resolvedCommand = resolveCursorAwareCommand(sourceConfig.command, sourceConfig, cursorState);
-        const result = await runShellCommand(String(resolvedCommand), 120_000, { cwd: commandCwd });
+        const resolvedCommand = resolveCursorAwareCommand(withActiveConfigArg(replaceLegacyRuntimeScriptCommand(sourceConfig.command), configPath), sourceConfig, cursorState);
+        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 {
@@ -1128,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 {
@@ -1144,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) {
+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);
+        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;
@@ -1160,10 +1752,22 @@ async function loadSourcePayloads(config, state) {
         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) {
@@ -1190,7 +1794,26 @@ function hasSourceChanges(previousHashes, currentHashes) {
     return false;
 }
 async function runOnce(configPath, statePath) {
+    await appendSchedulerProof('runner_invoked', {
+        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) {
@@ -1206,7 +1829,7 @@ async function runOnce(configPath, statePath) {
         lastRunAt: null,
         sourceCursors: {},
     });
-    const runtimeDir = path.resolve(DEFAULT_RUNTIME_DIR);
+    const runtimeDir = path.resolve(deriveRuntimeDirFromStatePath(statePath));
     const stateAfterHealthCheck = await maybeRunConnectorHealthCheck({
         config,
         configPath,
@@ -1215,22 +1838,41 @@ async function runOnce(configPath, statePath) {
         runtimeDir,
     });
     const activeCadences = getDueCadences(config, stateAfterHealthCheck);
-    const { payloads, sourceCursors } = await loadSourcePayloads(config, stateAfterHealthCheck);
+    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,
-            lastRunAt: new Date().toISOString(),
-            skippedReason: 'no_data_change',
+            lastSourceFailures: sourceFailures,
+            lastRunAt: completedAt,
+            skippedReason: 'cadence_not_due',
         }, null, 2), 'utf8');
+        await appendSchedulerProof('runner_completed', {
+            configPath,
+            statePath,
+            completedAt,
+            skippedReason: 'cadence_not_due',
+            sourceFailures,
+            socialOutput: 'HEARTBEAT_OK',
+        });
         return;
     }
-    const createGitHubArtifact = shouldAutoCreateGitHubArtifact(config) && Boolean(String(config.project?.githubRepo || '').trim());
+    const githubArtifactModes = getGitHubArtifactModes(config).filter((mode) => shouldAutoCreateGitHubArtifact(config, mode));
+    const createGitHubArtifact = githubArtifactModes.length > 0 && Boolean(String(config.project?.githubRepo || '').trim());
     const sourceFiles = await materializeSourceFiles(config, payloads, runtimeDir);
     const cadencePlanPath = path.join(runtimeDir, 'cadence-plan.json');
     await fs.writeFile(cadencePlanPath, JSON.stringify({
@@ -1241,6 +1883,7 @@ async function runOnce(configPath, statePath) {
         config,
         payloads,
         runtimeDir,
+        activeCadences,
     });
     const dryRun = await runAnalyzer({
         config,
@@ -1251,46 +1894,78 @@ 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: new Date().toISOString(),
+            lastRunAt: completedAt,
             lastOutFile: dryRun.outFile,
-            cadences: markCadencesRan(stateAfterHealthCheck, activeCadences, new Date().toISOString()),
+            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', {
+            configPath,
+            statePath,
+            completedAt,
+            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) {
-        await runAnalyzer({
-            config,
-            runtimeDir,
-            sourceFiles,
-            createGitHubArtifact: true,
-            chartManifestPath,
-            cadencePlanPath,
-        });
-        process.stdout.write(`[${new Date().toISOString()}] Created GitHub ${getActionMode(config) === 'pull_request' ? 'pull requests' : 'issues'}.\n`);
+        for (const githubArtifactMode of githubArtifactModes) {
+            await runAnalyzer({
+                config,
+                runtimeDir,
+                sourceFiles,
+                createGitHubArtifact: true,
+                githubArtifactMode,
+                chartManifestPath,
+                cadencePlanPath,
+            });
+        }
+        process.stdout.write(`[${new Date().toISOString()}] Created GitHub ${githubArtifactModes.map((mode) => (mode === 'pull_request' ? 'pull requests' : 'issues')).join(' and ')}.\n`);
     }
     else {
         process.stdout.write(`[${new Date().toISOString()}] Drafts generated only (${getActionMode(config)} auto-create disabled).\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: new Date().toISOString(),
+        lastRunAt: completedAt,
         lastOutFile: dryRun.outFile,
-        cadences: markCadencesRan(stateAfterHealthCheck, activeCadences, new Date().toISOString()),
+        cadences: markCadencesRan(stateAfterSourceCollection, activeCadences, completedAt),
         lastGrowthRunNotifications: await deliverGrowthRunSummary({
             config,
             configPath,
@@ -1299,9 +1974,21 @@ async function runOnce(configPath, statePath) {
             sourceFiles,
             fingerprint: issueFingerprint,
             createdGitHubArtifact: shouldCreateGitHubArtifact,
+            chartManifestPath,
         }),
         skippedReason: null,
     }, null, 2), 'utf8');
+    await appendSchedulerProof('runner_completed', {
+        configPath,
+        statePath,
+        completedAt,
+        skippedReason: null,
+        activeCadences: activeCadences.map((cadence) => cadence.key),
+        outFile: dryRun.outFile,
+        issueCount: Number(dryRun.issuesPayload?.issue_count || 0),
+        sourceFailures,
+        createdGitHubArtifact: shouldCreateGitHubArtifact,
+    });
 }
 async function main() {
     await loadOpenClawGrowthSecrets();
@@ -1309,6 +1996,7 @@ async function main() {
     await maybeSelfUpdateFromClawHub(args);
     const configPath = path.resolve(args.config);
     const statePath = path.resolve(args.state);
+    useSchedulerProofPathForStatePath(statePath);
     if (!args.loop) {
         await runOnce(configPath, statePath);
         return;
@@ -1322,12 +2010,21 @@ async function main() {
             await runOnce(configPath, statePath);
         }
         catch (error) {
+            await appendSchedulerProof('runner_failed', {
+                configPath,
+                statePath,
+                error: error instanceof Error ? error.message : String(error),
+            }).catch(() => { });
             process.stderr.write(`[${new Date().toISOString()}] Run failed: ${error instanceof Error ? error.message : String(error)}\n`);
         }
         await sleep(intervalMinutes * 60_000);
     }
 }
-main().catch((error) => {
+main().catch(async (error) => {
+    await appendSchedulerProof('runner_failed', {
+        error: error instanceof Error ? error.message : String(error),
+        argv: process.argv.slice(2),
+    }).catch(() => { });
     process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
     process.exitCode = 1;
 });