@analyticscli/growth-engineer 0.1.1-preview.0 → 0.1.1-preview.10

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

@@ -11,7 +11,11 @@ const DEFAULT_CONFIG_PATH = 'data/openclaw-growth-engineer/config.json';
 const DEFAULT_STATE_PATH = 'data/openclaw-growth-engineer/state.json';
 const DEFAULT_SCHEDULER_PROOF_PATH = 'data/openclaw-growth-engineer/runtime/scheduler-proof.jsonl';
 const DEFAULT_CONNECTOR_HEALTH_INTERVAL_MINUTES = 360;
+const DEFAULT_DAILY_ISSUE_EVENT_GROWTH_MULTIPLIER = 2;
+const DEFAULT_DAILY_ISSUE_EVENT_GROWTH_MIN_DELTA = 10;
+const DEFAULT_DAILY_RUNNER_FAILURE_RETENTION_DAYS = 14;
 const SELF_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const SELF_UPDATE_SKILL_SLUG_CANDIDATES = ['growth-engineer', 'openclaw-growth-engineer'];
 const RUNTIME_DIR = path.dirname(fileURLToPath(import.meta.url));
 let schedulerProofPath = path.resolve(DEFAULT_SCHEDULER_PROOF_PATH);
 const DEFAULT_CADENCES = [
@@ -144,6 +148,7 @@ function resolveRuntimeScriptPath(scriptName) {
     const candidates = [
         path.join(RUNTIME_DIR, scriptName),
         path.resolve('scripts', scriptName),
+        path.resolve('skills/growth-engineer/scripts', scriptName),
         path.resolve('skills/openclaw-growth-engineer/scripts', scriptName),
     ];
     return candidates.find((candidate) => existsSync(candidate)) || path.join(RUNTIME_DIR, scriptName);
@@ -164,7 +169,7 @@ 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 || ''));
+    return /(?:^|\s)(?:node\s+)?(?:\S*\/)?(?:export-paddle-summary|export-sentry-summary|export-coolify-summary)\.mjs(?:\s|$)/.test(String(command || ''));
 }
 function withActiveConfigArg(command, configPath) {
     const trimmed = String(command || '').trim();
@@ -247,9 +252,13 @@ function isSentryCompatibleSource(sourceConfig, sourceName) {
 function shouldDegradeTransientSourceFailure(sourceConfig, sourceName, retried) {
     if (!retried)
         return false;
+    if (sourceConfig?.degradeTransientFailures === false)
+        return false;
     if (!isRequiredSource(sourceConfig, sourceName))
         return true;
-    return isSentryCompatibleSource(sourceConfig, sourceName);
+    if (isSentryCompatibleSource(sourceConfig, sourceName))
+        return true;
+    return sourceConfig?.degradeRequiredTransientFailures !== false;
 }
 function isTruthyEnv(value) {
     return ['1', 'true', 'yes', 'y', 'on'].includes(String(value || '').trim().toLowerCase());
@@ -327,6 +336,23 @@ async function rerunCurrentProcessWithoutSelfUpdate() {
         child.on('close', (code) => resolve(code));
     });
 }
+function getSelfUpdateSkillCandidates(workspaceRoot) {
+    const explicit = String(process.env.OPENCLAW_GROWTH_SKILL_SLUG || '').trim();
+    const uniqueSlugs = [...new Set([explicit, ...SELF_UPDATE_SKILL_SLUG_CANDIDATES].filter(Boolean))];
+    return uniqueSlugs.map((slug) => {
+        const skillRoot = path.join(workspaceRoot, 'skills', slug);
+        return {
+            slug,
+            skillRoot,
+            originPath: path.join(skillRoot, '.clawhub/origin.json'),
+            runnerPath: path.join(skillRoot, 'scripts/openclaw-growth-runner.mjs'),
+            bootstrapPath: path.join(skillRoot, 'scripts/bootstrap-openclaw-workspace.sh'),
+        };
+    });
+}
+function resolveInstalledSelfUpdateSkill(workspaceRoot) {
+    return getSelfUpdateSkillCandidates(workspaceRoot).find((candidate) => existsSync(candidate.originPath)) || null;
+}
 async function maybeSelfUpdateFromClawHub(args) {
     if (args.noSelfUpdate)
         return false;
@@ -337,26 +363,27 @@ async function maybeSelfUpdateFromClawHub(args) {
     if (isFalseyEnv(process.env.OPENCLAW_GROWTH_SELF_UPDATE))
         return false;
     const workspaceRoot = process.cwd();
-    const skillOriginPath = path.join(workspaceRoot, 'skills/openclaw-growth-engineer/.clawhub/origin.json');
-    if (!existsSync(skillOriginPath))
+    const installedSkill = resolveInstalledSelfUpdateSkill(workspaceRoot);
+    if (!installedSkill)
         return false;
     if (!(await commandExists('npx')))
         return false;
     const force = String(process.env.OPENCLAW_GROWTH_SELF_UPDATE || '').trim().toLowerCase() === 'always';
     if (!(await shouldRunSelfUpdate(workspaceRoot, force)))
         return false;
-    const beforeOrigin = await readJsonOptional(skillOriginPath, null);
+    const beforeOrigin = await readJsonOptional(installedSkill.originPath, null);
     const beforeVersion = String(beforeOrigin?.installedVersion || '');
-    process.stdout.write('Checking for OpenClaw Growth Engineer skill updates...\n');
-    const updateResult = await runShellCommand('npx -y clawhub --no-input --dir skills update openclaw-growth-engineer --force', 120_000);
-    const afterOrigin = await readJsonOptional(skillOriginPath, null);
+    process.stdout.write(`Checking for Growth Engineer skill updates (${installedSkill.slug})...\n`);
+    const updateResult = await runShellCommand(`npx -y clawhub --no-input --dir skills update ${quote(installedSkill.slug)} --force`, 120_000);
+    const afterOrigin = await readJsonOptional(installedSkill.originPath, null);
     const afterVersion = String(afterOrigin?.installedVersion || beforeVersion || '');
     const workspaceRunnerPath = path.resolve(process.argv[1] || 'scripts/openclaw-growth-runner.mjs');
-    const skillRunnerPath = path.join(workspaceRoot, 'skills/openclaw-growth-engineer/scripts/openclaw-growth-runner.mjs');
-    const runtimeOutdated = !(await filesHaveSameContent(workspaceRunnerPath, skillRunnerPath));
+    const runtimeOutdated = !(await filesHaveSameContent(workspaceRunnerPath, installedSkill.runnerPath));
     await writeSelfUpdateState(workspaceRoot, {
         lastCheckedAt: new Date().toISOString(),
         ok: updateResult.ok,
+        skillSlug: installedSkill.slug,
+        skillRoot: installedSkill.skillRoot,
         previousVersion: beforeVersion || null,
         installedVersion: afterVersion || null,
     }).catch(() => { });
@@ -370,7 +397,7 @@ async function maybeSelfUpdateFromClawHub(args) {
     process.stdout.write(afterVersion && afterVersion !== beforeVersion
         ? `Updated OpenClaw Growth Engineer skill ${beforeVersion || 'unknown'} -> ${afterVersion}. Refreshing workspace runtime...\n`
         : 'Refreshing workspace runtime from the installed OpenClaw Growth Engineer skill...\n');
-    const bootstrapResult = await runShellCommand('bash skills/openclaw-growth-engineer/scripts/bootstrap-openclaw-workspace.sh', 60_000);
+    const bootstrapResult = await runShellCommand(`bash ${quote(installedSkill.bootstrapPath)}`, 60_000);
     if (!bootstrapResult.ok) {
         process.stdout.write('Workspace runtime refresh failed; continuing with current process.\n');
         return false;
@@ -399,6 +426,27 @@ function resolveShellCommand() {
 function hardenUnattendedShellCommand(command) {
     return String(command || '').replace(/(^|[;&|]\s*)sudo(?!\s+-n(?:\s|$))(?=\s|$)/g, '$1sudo -n');
 }
+function redactCommandForDiagnostics(command) {
+    const raw = String(command || '').trim();
+    if (!raw)
+        return '';
+    return raw
+        .replace(/((?:^|\s)(?:[A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|PASS|KEY|AUTH|CREDENTIAL)[A-Z0-9_]*)=)(?:"[^"]*"|'[^']*'|\S+)/gi, '$1[redacted]')
+        .replace(/((?:^|\s)--(?:token|access-token|api-key|key|secret|password|pass|authorization|auth|bearer)(?:=|\s+))(?:"[^"]*"|'[^']*'|\S+)/gi, '$1[redacted]');
+}
+function truncateDiagnosticText(value, maxLength = 2000) {
+    const text = String(value || '').trim();
+    if (text.length <= maxLength)
+        return text;
+    return `${text.slice(0, maxLength - 1)}…`;
+}
+function buildSourceCommandFailureMessage(sourceName, resolvedCommand, detail) {
+    const safeCommand = redactCommandForDiagnostics(resolvedCommand);
+    const safeDetail = truncateDiagnosticText(detail);
+    return safeCommand
+        ? `Source "${sourceName}" command failed: command \`${safeCommand}\`; ${safeDetail}`
+        : `Source "${sourceName}" command failed: ${safeDetail}`;
+}
 function isSudoPasswordPrompt(stderr) {
     return /sudo: (?:a password is required|a terminal is required to read the password|no tty present)/i.test(String(stderr || ''));
 }
@@ -410,6 +458,7 @@ function runShellCommand(command, timeoutMs = 120_000, options = {}) {
             cwd: options.cwd,
             env: {
                 ...process.env,
+                ...(options.env || {}),
                 DEBIAN_FRONTEND: 'noninteractive',
                 SUDO_ASKPASS: '/bin/false',
                 SUDO_PROMPT: '',
@@ -644,7 +693,8 @@ function buildConnectorWizardCommand(configPath, entry) {
     const connector = connectorWizardKey(entry.key);
     if (!connector)
         return null;
-    return `npx -y @analyticscli/growth-engineer@preview wizard --connectors ${quote(connector)}`;
+    const configArg = configPath ? ` --config ${quote(configPath)}` : '';
+    return `npx -y @analyticscli/growth-engineer@preview wizard${configArg} --connectors ${quote(connector)}`;
 }
 function conciseConnectorDetail(entry) {
     const detail = String(entry?.detail || '').replace(/\s+/g, ' ').trim();
@@ -851,6 +901,8 @@ function notificationChannelKey(channel) {
         return `slack:${channel?.label || channel?.webhookEnv || 'slack'}`;
     if (type === 'webhook')
         return `webhook:${channel?.label || channel?.urlEnv || channel?.webhookEnv || 'webhook'}`;
+    if (type === 'discord')
+        return `discord:${channel?.label || channel?.command || 'discord'}`;
     if (type === 'command')
         return `command:${channel?.label || channel?.command || 'command'}`;
     return `${type}:${channel?.label || type}`;
@@ -907,7 +959,7 @@ function getDeliveryNotificationChannels(config, kind) {
     }
     if (deliveries.discord?.enabled) {
         channels.push({
-            type: 'command',
+            type: 'discord',
             label: deliveries.discord.label || 'discord',
             command: deliveries.discord.command || '',
         });
@@ -1001,7 +1053,23 @@ async function sendCommandConnectorHealthAlert(channel, message) {
         sent: result.ok,
         external: true,
         target: channel.label || 'command',
-        detail: result.ok ? result.stdout.trim() : result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`,
+        detail: result.ok ? 'sent' : result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`,
+    };
+}
+async function sendDiscordConnectorHealthAlert(channel, message, statusPayload, unhealthyConnectors, fingerprint) {
+    if (!channel.command) {
+        return { sent: false, target: channel.label || 'discord', detail: 'discord command not configured' };
+    }
+    const payload = buildDiscordConnectorHealthPayload(message, statusPayload, unhealthyConnectors, fingerprint);
+    const result = await runShellCommand(String(channel.command), 60_000, {
+        input: JSON.stringify(payload),
+        env: { OPENCLAW_DISCORD_DELIVERY_FORMAT: 'embed' },
+    });
+    return {
+        sent: result.ok,
+        external: true,
+        target: channel.label || 'discord',
+        detail: result.ok ? 'sent' : result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`,
     };
 }
 function hasExternalNotificationChannel(channels) {
@@ -1010,6 +1078,57 @@ function hasExternalNotificationChannel(channels) {
 function hasSuccessfulExternalDelivery(results) {
     return results.some((result) => result?.sent === true && result?.external === true);
 }
+function discordTruncate(value, maxLength) {
+    const text = String(value || '').replace(/\s+/g, ' ').trim();
+    if (text.length <= maxLength)
+        return text;
+    return `${text.slice(0, Math.max(0, maxLength - 1)).trim()}…`;
+}
+function discordField(name, value, inline = false) {
+    return {
+        name: discordTruncate(name, 256) || 'Detail',
+        value: discordTruncate(value, 1024) || '-',
+        inline,
+    };
+}
+function connectorStatusColor(unhealthyConnectors) {
+    return unhealthyConnectors.some((entry) => String(entry?.status || '').toLowerCase() === 'blocked')
+        ? 0xd92d20
+        : 0xf79009;
+}
+function buildDiscordConnectorHealthPayload(message, statusPayload, unhealthyConnectors, fingerprint) {
+    const fields = unhealthyConnectors.slice(0, 10).map((entry) => {
+        const command = buildConnectorWizardCommand(statusPayload?.configPath || DEFAULT_CONFIG_PATH, entry);
+        const parts = [
+            `Status: ${entry.status || 'blocked'}`,
+            conciseConnectorDetail(entry),
+            command ? `Fix: \`${command}\`` : null,
+            isAscWebAuthIssue(entry)
+                ? 'ASC web-auth only: `ASC_WEB_APPLE_ID="<apple-id>" asc web auth login --apple-id "$ASC_WEB_APPLE_ID"`'
+                : null,
+        ].filter(Boolean);
+        return discordField(humanConnectorName(entry.key), parts.join('\n'));
+    });
+    if (unhealthyConnectors.length > 10) {
+        fields.push(discordField('More issues', `${unhealthyConnectors.length - 10} additional connector(s) need attention.`));
+    }
+    return {
+        content: '',
+        embeds: [
+            {
+                title: `OpenClaw connector health: ${unhealthyConnectors.length} issue(s)`,
+                description: 'Secrets stay in the host terminal or secret store.',
+                color: connectorStatusColor(unhealthyConnectors),
+                fields,
+                footer: {
+                    text: `CONNECTOR_HEALTH_ALERT • ${String(fingerprint || '').slice(0, 12)}`,
+                },
+                timestamp: statusPayload?.generatedAt || new Date().toISOString(),
+            },
+        ],
+        fallbackText: message,
+    };
+}
 function truncateMessageText(value, maxLength = 96) {
     const text = String(value || '').replace(/\s+/g, ' ').trim();
     if (text.length <= maxLength)
@@ -1042,6 +1161,323 @@ function groupIssuesByProject(issues, maxIssues = 4) {
     }
     return [...grouped.entries()];
 }
+function getDailyIssueDedupeConfig(config) {
+    const raw = config?.schedule?.dailyIssueDedupe || config?.notifications?.growthRun?.dailyIssueDedupe || {};
+    const multiplier = Number(raw.eventGrowthMultiplier ?? raw.multiplier);
+    const minDelta = Number(raw.eventGrowthMinDelta ?? raw.minDelta);
+    return {
+        enabled: raw.enabled !== false,
+        eventGrowthMultiplier: Number.isFinite(multiplier) && multiplier > 1
+            ? multiplier
+            : DEFAULT_DAILY_ISSUE_EVENT_GROWTH_MULTIPLIER,
+        eventGrowthMinDelta: Number.isFinite(minDelta) && minDelta > 0
+            ? minDelta
+            : DEFAULT_DAILY_ISSUE_EVENT_GROWTH_MIN_DELTA,
+    };
+}
+function getDailyRunnerFailureDedupeConfig(config) {
+    const raw = config?.schedule?.dailyRunnerFailureDedupe || config?.notifications?.growthRun?.dailyRunnerFailureDedupe || {};
+    const retentionDays = Number(raw.retentionDays);
+    return {
+        enabled: raw.enabled !== false,
+        retentionDays: Number.isFinite(retentionDays) && retentionDays > 0
+            ? retentionDays
+            : DEFAULT_DAILY_RUNNER_FAILURE_RETENTION_DAYS,
+    };
+}
+function resolveDailyIssueDedupeTimeZone(config) {
+    return String(config?.schedule?.timezone ||
+        config?.automation?.openclawCron?.timezone ||
+        process.env.TZ ||
+        'UTC').trim() || 'UTC';
+}
+function normalizeRunnerFailureForFingerprint(errorMessage) {
+    return redactCommandForDiagnostics(errorMessage)
+        .replace(/\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\b/g, '[timestamp]')
+        .replace(/--since(?:=|\s+)(?:"[^"]*"|'[^']*'|\S+)/g, '--since [timestamp]')
+        .replace(/--until(?:=|\s+)(?:"[^"]*"|'[^']*'|\S+)/g, '--until [timestamp]')
+        .replace(/\bpid\s+\d+\b/gi, 'pid [pid]')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function buildRunnerFailureFingerprint(errorMessage) {
+    return sha256(normalizeRunnerFailureForFingerprint(errorMessage));
+}
+function pruneDailyRunnerFailures(failures, now, retentionDays) {
+    const cutoffMs = now.getTime() - retentionDays * 24 * 60 * 60 * 1000;
+    return Object.fromEntries(Object.entries(failures || {}).filter(([, entry]) => {
+        const lastSeenMs = Date.parse(String(entry?.lastSeenAt || entry?.firstSeenAt || ''));
+        return !Number.isFinite(lastSeenMs) || lastSeenMs >= cutoffMs;
+    }));
+}
+function parseFailureArgs(argv) {
+    const args = {
+        config: DEFAULT_CONFIG_PATH,
+        state: DEFAULT_STATE_PATH,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        const next = argv[i + 1];
+        if (token === '--config' && next) {
+            args.config = next;
+            i += 1;
+        }
+        else if (token === '--state' && next) {
+            args.state = next;
+            i += 1;
+        }
+    }
+    return args;
+}
+async function recordRunnerFailure({ configPath, statePath, error, argv = [], now = new Date() }) {
+    const errorMessage = truncateDiagnosticText(error instanceof Error ? error.message : String(error));
+    const config = await readJsonOptional(configPath, {});
+    const state = await readJsonOptional(statePath, {
+        sourceHashes: {},
+        lastIssueFingerprint: null,
+        lastRunAt: null,
+        sourceCursors: {},
+    });
+    const dedupeConfig = getDailyRunnerFailureDedupeConfig(config);
+    const timeZone = resolveDailyIssueDedupeTimeZone(config);
+    const date = formatDateInTimeZone(now, timeZone);
+    const fingerprint = buildRunnerFailureFingerprint(errorMessage);
+    const nowIso = now.toISOString();
+    const previousDailyFailures = state?.dailyRunnerFailures?.date === date
+        ? state.dailyRunnerFailures
+        : null;
+    const previousFailures = previousDailyFailures?.failures && typeof previousDailyFailures.failures === 'object'
+        ? previousDailyFailures.failures
+        : {};
+    const failures = pruneDailyRunnerFailures(previousFailures, now, dedupeConfig.retentionDays);
+    const previousEntry = failures[fingerprint] || null;
+    const suppressed = dedupeConfig.enabled && Boolean(previousEntry);
+    const nextEntry = {
+        ...(previousEntry || {}),
+        fingerprint,
+        error: errorMessage,
+        normalizedError: normalizeRunnerFailureForFingerprint(errorMessage),
+        firstSeenAt: previousEntry?.firstSeenAt || nowIso,
+        lastSeenAt: nowIso,
+    };
+    if (suppressed) {
+        nextEntry.suppressedCount = Number(previousEntry?.suppressedCount || 0) + 1;
+    }
+    else {
+        nextEntry.lastReportedAt = nowIso;
+        nextEntry.reportCount = Number(previousEntry?.reportCount || 0) + 1;
+    }
+    failures[fingerprint] = nextEntry;
+    const nextState = {
+        ...state,
+        dailyRunnerFailures: {
+            date,
+            timeZone,
+            failures,
+            updatedAt: nowIso,
+        },
+        lastRunnerFailure: {
+            fingerprint,
+            error: errorMessage,
+            failedAt: nowIso,
+            suppressed,
+        },
+    };
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    await fs.writeFile(statePath, JSON.stringify(nextState, null, 2), 'utf8');
+    await appendSchedulerProof(suppressed ? 'runner_failed_suppressed' : 'runner_failed', {
+        configPath,
+        statePath,
+        error: errorMessage,
+        errorFingerprint: fingerprint,
+        date,
+        timeZone,
+        argv,
+        suppressed,
+        reportCount: nextEntry.reportCount || 0,
+        suppressedCount: nextEntry.suppressedCount || 0,
+        socialOutput: suppressed ? 'HEARTBEAT_OK' : 'RUNNER_FAILED',
+        socialReason: suppressed
+            ? 'runner failure unchanged and already reported today'
+            : 'new runner failure for current day',
+    });
+    return {
+        suppressed,
+        exitCode: suppressed ? 0 : 1,
+        fingerprint,
+    };
+}
+function formatDateInTimeZone(date, timeZone) {
+    try {
+        const parts = new Intl.DateTimeFormat('en-CA', {
+            timeZone,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+        }).formatToParts(date);
+        const byType = Object.fromEntries(parts.map((part) => [part.type, part.value]));
+        if (byType.year && byType.month && byType.day) {
+            return `${byType.year}-${byType.month}-${byType.day}`;
+        }
+    }
+    catch {
+        // Fall back to UTC below for invalid host timezone settings.
+    }
+    return date.toISOString().slice(0, 10);
+}
+function normalizeIssueIdentityPart(value) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, ' ');
+}
+function buildDailyIssueKey(issue) {
+    const stableIdentity = [
+        issueSourceUrl(issue),
+        issue?.source_url,
+        issue?.sourceUrl,
+        issue?.issue_url,
+        issue?.issueUrl,
+        issue?.signal_id,
+        issue?.signalId,
+        issue?.id,
+    ]
+        .map((value) => String(value || '').trim())
+        .find(Boolean);
+    const fallbackIdentity = [
+        issueProjectLabel(issue),
+        issue?.source,
+        issue?.area,
+        issue?.title,
+    ]
+        .map(normalizeIssueIdentityPart)
+        .filter(Boolean)
+        .join('|');
+    return sha256(stableIdentity || fallbackIdentity || stableStringify(issue));
+}
+function coerceIssueNumber(value) {
+    if (value === null || value === undefined || value === '')
+        return null;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    const normalized = String(value).replace(/,/g, '').trim();
+    if (!normalized)
+        return null;
+    const number = Number(normalized);
+    return Number.isFinite(number) ? number : null;
+}
+function issueEventCount(issue) {
+    const direct = [
+        issue?.events,
+        issue?.eventCount,
+        issue?.event_count,
+        issue?.current_value,
+        issue?.currentValue,
+        issue?.count,
+    ];
+    for (const value of direct) {
+        const number = coerceIssueNumber(value);
+        if (number !== null)
+            return number;
+    }
+    const text = [
+        issue?.impact,
+        issue?.summary,
+        ...(Array.isArray(issue?.evidence) ? issue.evidence : []),
+        issue?.body,
+    ]
+        .filter(Boolean)
+        .join('\n');
+    const match = text.match(/\bEvents?:\s*([0-9][0-9,]*(?:\.[0-9]+)?)/i);
+    return match ? coerceIssueNumber(match[1]) : null;
+}
+function isDrasticDailyIssueEventGrowth(currentEvents, previousEntry, dedupeConfig) {
+    if (currentEvents === null || currentEvents === undefined)
+        return false;
+    const previousEvents = coerceIssueNumber(previousEntry?.lastReportedEvents ?? previousEntry?.lastSeenEvents);
+    if (previousEvents === null || previousEvents < 0)
+        return false;
+    const requiredEvents = Math.max(previousEvents * dedupeConfig.eventGrowthMultiplier, previousEvents + dedupeConfig.eventGrowthMinDelta);
+    return currentEvents >= requiredEvents;
+}
+function applyDailyIssueDedupe(issuesPayload, state, config, activeCadences, now = new Date()) {
+    const issues = Array.isArray(issuesPayload?.issues) ? issuesPayload.issues : [];
+    const dedupeConfig = getDailyIssueDedupeConfig(config);
+    if (!dedupeConfig.enabled || !isShortOperationalCadence(activeCadences) || issues.length === 0) {
+        return {
+            issuesPayload,
+            dailyIssueReports: state?.dailyIssueReports || null,
+            suppressedCount: 0,
+            reportedCount: issues.length,
+            hasDrasticEventGrowth: false,
+        };
+    }
+    const timeZone = resolveDailyIssueDedupeTimeZone(config);
+    const date = formatDateInTimeZone(now, timeZone);
+    const nowIso = now.toISOString();
+    const previousState = state?.dailyIssueReports?.date === date ? state.dailyIssueReports : null;
+    const previousIssues = previousState?.issues && typeof previousState.issues === 'object'
+        ? previousState.issues
+        : {};
+    const nextIssues = { ...previousIssues };
+    const reportableIssues = [];
+    let suppressedCount = 0;
+    let hasDrasticEventGrowth = false;
+    for (const issue of issues) {
+        const key = buildDailyIssueKey(issue);
+        const previousEntry = previousIssues[key] || null;
+        const events = issueEventCount(issue);
+        const shouldReport = !previousEntry || isDrasticDailyIssueEventGrowth(events, previousEntry, dedupeConfig);
+        const reportReason = !previousEntry ? 'new_daily_issue' : 'event_growth';
+        const nextEntry = {
+            ...(previousEntry || {}),
+            title: String(issue?.title || previousEntry?.title || '').slice(0, 240),
+            app: issueProjectLabel(issue),
+            sourceUrl: issueSourceUrl(issue) || previousEntry?.sourceUrl || null,
+            lastSeenAt: nowIso,
+            lastSeenEvents: events ?? previousEntry?.lastSeenEvents ?? null,
+        };
+        if (shouldReport) {
+            reportableIssues.push(issue);
+            if (previousEntry)
+                hasDrasticEventGrowth = true;
+            nextEntry.lastReportedAt = nowIso;
+            nextEntry.lastReportedEvents = events ?? previousEntry?.lastReportedEvents ?? null;
+            nextEntry.lastReportReason = reportReason;
+            nextEntry.reportCount = Number(previousEntry?.reportCount || 0) + 1;
+        }
+        else {
+            suppressedCount += 1;
+            nextEntry.suppressedCount = Number(previousEntry?.suppressedCount || 0) + 1;
+        }
+        nextIssues[key] = nextEntry;
+    }
+    return {
+        issuesPayload: {
+            ...issuesPayload,
+            issue_count: reportableIssues.length,
+            issues: reportableIssues,
+            suppressed_issue_count: suppressedCount,
+            daily_issue_dedupe: {
+                date,
+                timeZone,
+                suppressedCount,
+                reportedCount: reportableIssues.length,
+                eventGrowthMultiplier: dedupeConfig.eventGrowthMultiplier,
+                eventGrowthMinDelta: dedupeConfig.eventGrowthMinDelta,
+            },
+        },
+        dailyIssueReports: {
+            date,
+            timeZone,
+            issues: nextIssues,
+            updatedAt: nowIso,
+        },
+        suppressedCount,
+        reportedCount: reportableIssues.length,
+        hasDrasticEventGrowth,
+    };
+}
 async function deliverConnectorHealthAlert({ config, configPath, message, statusPayload, unhealthyConnectors, fingerprint }) {
     const channels = getConnectorHealthChannels(config);
     if (config?.notifications?.connectorHealth?.enabled === false) {
@@ -1062,6 +1498,9 @@ async function deliverConnectorHealthAlert({ config, configPath, message, status
             else if (channel.type === 'webhook') {
                 results.push(await sendWebhookConnectorHealthAlert(channel, message, statusPayload, unhealthyConnectors, fingerprint));
             }
+            else if (channel.type === 'discord') {
+                results.push(await sendDiscordConnectorHealthAlert(channel, message, statusPayload, unhealthyConnectors, fingerprint));
+            }
             else if (channel.type === 'command') {
                 results.push(await sendCommandConnectorHealthAlert(channel, message));
             }
@@ -1142,6 +1581,10 @@ function buildGrowthRunSummaryMessage({ issuesPayload, activeCadences, sourceFil
                 ? 'Action: GitHub artifact attempted.'
                 : 'Action: external alert only.');
         }
+        const suppressedIssueCount = Number(issuesPayload?.suppressed_issue_count || 0);
+        if (suppressedIssueCount > 0) {
+            lines.push(`Suppressed today: ${suppressedIssueCount} previously reported finding(s).`);
+        }
         if (charts.length > 0) {
             lines.push(`Charts: ${charts.length}`);
         }
@@ -1187,6 +1630,67 @@ function buildGrowthRunSummaryMessage({ issuesPayload, activeCadences, sourceFil
         : 'No secrets were included.');
     return `${lines.join('\n')}\n`;
 }
+function growthRunTitle(activeCadences) {
+    if (isShortOperationalCadence(activeCadences)) {
+        return activeCadences.some((cadence) => String(cadence?.key) === 'healthcheck')
+            ? 'OpenClaw healthcheck'
+            : 'OpenClaw daily';
+    }
+    if (isDeepAnalysisCadence(activeCadences))
+        return 'OpenClaw growth review';
+    return 'OpenClaw growth run';
+}
+function buildDiscordGrowthRunPayload(message, issuesPayload, activeCadences, sourceFiles, fingerprint, createdGitHubArtifact, charts = []) {
+    const issues = Array.isArray(issuesPayload?.issues) ? issuesPayload.issues : [];
+    const issueCount = Number(issuesPayload?.issue_count || 0);
+    const fields = [
+        discordField('Cadence', activeCadences.length > 0
+            ? activeCadences.map((cadence) => cadence.title || cadence.key).join(', ')
+            : 'ad-hoc growth pass', false),
+        discordField('Sources', Object.keys(sourceFiles || {}).sort().join(', ') || 'none', true),
+        discordField('Findings', String(issueCount), true),
+    ];
+    if (createdGitHubArtifact) {
+        fields.push(discordField('Action', 'GitHub artifact creation was attempted.', true));
+    }
+    const suppressedIssueCount = Number(issuesPayload?.suppressed_issue_count || 0);
+    if (suppressedIssueCount > 0) {
+        fields.push(discordField('Suppressed today', `${suppressedIssueCount} previously reported finding(s).`, true));
+    }
+    if (charts.length > 0) {
+        fields.push(discordField('Charts', String(charts.length), true));
+    }
+    const groupedIssues = isShortOperationalCadence(activeCadences)
+        ? groupIssuesByProject(issues, 4).map(([project, projectIssues]) => ({
+            name: project,
+            value: projectIssues.map((issue) => formatIssueSummaryLine(issue, 84)).filter(Boolean).join('\n'),
+        }))
+        : issues.slice(0, isDeepAnalysisCadence(activeCadences) ? 5 : 3).map((issue) => ({
+            name: `${issue.priority || 'medium'} • ${issue.area || 'general'}`,
+            value: formatIssueSummaryLine(issue, 96),
+        }));
+    for (const entry of groupedIssues) {
+        if (entry.value)
+            fields.push(discordField(entry.name, entry.value));
+    }
+    const summary = String(issuesPayload?.summary || '').trim();
+    return {
+        content: '',
+        embeds: [
+            {
+                title: `${growthRunTitle(activeCadences)}: ${issueCount > 0 ? `${issueCount} finding(s)` : 'OK'}`,
+                description: discordTruncate(summary || 'No secrets were included.', 500),
+                color: issueCount > 0 ? 0xf79009 : 0x12b76a,
+                fields: fields.slice(0, 20),
+                footer: {
+                    text: `GROWTH_RUN • ${String(fingerprint || '').slice(0, 12)}`,
+                },
+                timestamp: new Date().toISOString(),
+            },
+        ],
+        fallbackText: message,
+    };
+}
 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');
@@ -1276,7 +1780,23 @@ async function sendCommandGrowthSummary(channel, message) {
         sent: result.ok,
         external: true,
         target: channel.label || 'command',
-        detail: result.ok ? result.stdout.trim() : result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`,
+        detail: result.ok ? 'sent' : result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`,
+    };
+}
+async function sendDiscordGrowthSummary(channel, message, issuesPayload, activeCadences, sourceFiles, fingerprint, createdGitHubArtifact, charts) {
+    if (!channel.command) {
+        return { sent: false, target: channel.label || 'discord', detail: 'discord command not configured' };
+    }
+    const payload = buildDiscordGrowthRunPayload(message, issuesPayload, activeCadences, sourceFiles, fingerprint, createdGitHubArtifact, charts);
+    const result = await runShellCommand(String(channel.command), 60_000, {
+        input: JSON.stringify(payload),
+        env: { OPENCLAW_DISCORD_DELIVERY_FORMAT: 'embed' },
+    });
+    return {
+        sent: result.ok,
+        external: true,
+        target: channel.label || 'discord',
+        detail: result.ok ? 'sent' : result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`,
     };
 }
 async function deliverGrowthRunSummary({ config, configPath, issuesPayload, activeCadences, sourceFiles, fingerprint, createdGitHubArtifact, chartManifestPath, }) {
@@ -1307,6 +1827,9 @@ async function deliverGrowthRunSummary({ config, configPath, issuesPayload, acti
             else if (channel.type === 'webhook') {
                 results.push(await sendWebhookGrowthSummary(channel, message, issuesPayload, activeCadences, fingerprint, charts));
             }
+            else if (channel.type === 'discord') {
+                results.push(await sendDiscordGrowthSummary(channel, message, issuesPayload, activeCadences, sourceFiles, fingerprint, createdGitHubArtifact, charts));
+            }
             else if (channel.type === 'command') {
                 results.push(await sendCommandGrowthSummary(channel, message));
             }
@@ -1686,7 +2209,7 @@ async function resolveSourcePayloadWithCursor(sourceConfig, sourceName, cursorSt
                     },
                 };
             }
-            throw new Error(`Source "${sourceName}" command failed: ${detail}`);
+            throw new Error(buildSourceCommandFailureMessage(sourceName, resolvedCommand, detail));
         }
         const fetchedAt = new Date().toISOString();
         try {
@@ -1893,8 +2416,52 @@ async function runOnce(configPath, statePath) {
         chartManifestPath,
         cadencePlanPath,
     });
-    const issueFingerprint = buildIssueFingerprint(dryRun.issuesPayload);
-    const unchangedIssueSet = issueFingerprint === stateAfterSourceCollection.lastIssueFingerprint;
+    const dailyIssueDedupe = applyDailyIssueDedupe(dryRun.issuesPayload, stateAfterSourceCollection, config, activeCadences);
+    const deliverableIssuesPayload = dailyIssueDedupe.issuesPayload;
+    const issueFingerprint = buildIssueFingerprint(deliverableIssuesPayload);
+    const unchangedIssueSet = issueFingerprint === stateAfterSourceCollection.lastIssueFingerprint &&
+        !dailyIssueDedupe.hasDrasticEventGrowth;
+    if (Number(dryRun.issuesPayload?.issue_count || 0) > 0 &&
+        Number(deliverableIssuesPayload?.issue_count || 0) === 0 &&
+        dailyIssueDedupe.suppressedCount > 0) {
+        process.stdout.write(`[${new Date().toISOString()}] All findings were already reported today. 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,
+            dailyIssueReports: dailyIssueDedupe.dailyIssueReports,
+            lastIssueFingerprint: issueFingerprint,
+            lastRunAt: completedAt,
+            lastOutFile: dryRun.outFile,
+            cadences: markCadencesRan(stateAfterSourceCollection, activeCadences, completedAt),
+            lastGrowthRunNotifications: [
+                {
+                    sent: false,
+                    target: 'growth_run',
+                    detail: `all ${dailyIssueDedupe.suppressedCount} finding(s) already reported today; external growth notification suppressed`,
+                },
+            ],
+            skippedReason: 'daily_issue_dedupe',
+        }, null, 2), 'utf8');
+        await appendSchedulerProof('runner_completed', {
+            configPath,
+            statePath,
+            completedAt,
+            skippedReason: 'daily_issue_dedupe',
+            activeCadences: activeCadences.map((cadence) => cadence.key),
+            outFile: dryRun.outFile,
+            issueCount: Number(dryRun.issuesPayload?.issue_count || 0),
+            suppressedIssueCount: dailyIssueDedupe.suppressedCount,
+            sourceFailures,
+            externalGrowthNotification: 'suppressed_daily_issue_dedupe',
+            socialOutput: 'HEARTBEAT_OK',
+        });
+        return;
+    }
     if (unchangedIssueSet &&
         config.schedule?.skipIfIssueSetUnchanged !== false) {
         process.stdout.write(`[${new Date().toISOString()}] Issue set unchanged. Skip GitHub creation and external growth notification.\n`);
@@ -1906,6 +2473,7 @@ async function runOnce(configPath, statePath) {
             sourceHashes: currentHashes,
             sourceCursors,
             lastSourceFailures: sourceFailures,
+            dailyIssueReports: dailyIssueDedupe.dailyIssueReports,
             lastIssueFingerprint: issueFingerprint,
             lastRunAt: completedAt,
             lastOutFile: dryRun.outFile,
@@ -1935,7 +2503,7 @@ async function runOnce(configPath, statePath) {
     }
     const issueSetChangedOrExplicitlyAllowed = !unchangedIssueSet || config.schedule?.skipIfIssueSetUnchanged === false;
     const shouldCreateGitHubArtifact = createGitHubArtifact &&
-        Number(dryRun.issuesPayload?.issue_count || 0) > 0 &&
+        Number(deliverableIssuesPayload?.issue_count || 0) > 0 &&
         issueSetChangedOrExplicitlyAllowed;
     if (shouldCreateGitHubArtifact) {
         for (const githubArtifactMode of githubArtifactModes) {
@@ -1962,6 +2530,7 @@ async function runOnce(configPath, statePath) {
         sourceHashes: currentHashes,
         sourceCursors,
         lastSourceFailures: sourceFailures,
+        dailyIssueReports: dailyIssueDedupe.dailyIssueReports,
         lastIssueFingerprint: issueFingerprint,
         lastRunAt: completedAt,
         lastOutFile: dryRun.outFile,
@@ -1969,7 +2538,7 @@ async function runOnce(configPath, statePath) {
         lastGrowthRunNotifications: await deliverGrowthRunSummary({
             config,
             configPath,
-            issuesPayload: dryRun.issuesPayload,
+            issuesPayload: deliverableIssuesPayload,
             activeCadences,
             sourceFiles,
             fingerprint: issueFingerprint,
@@ -2010,22 +2579,42 @@ async function main() {
             await runOnce(configPath, statePath);
         }
         catch (error) {
-            await appendSchedulerProof('runner_failed', {
+            const failureDecision = await recordRunnerFailure({
                 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`);
+                error,
+                argv: process.argv.slice(2),
+            }).catch(async () => {
+                await appendSchedulerProof('runner_failed', {
+                    configPath,
+                    statePath,
+                    error: error instanceof Error ? error.message : String(error),
+                }).catch(() => { });
+                return null;
+            });
+            process.stderr.write(`[${new Date().toISOString()}] Run failed${failureDecision?.suppressed ? ' (already reported today)' : ''}: ${error instanceof Error ? error.message : String(error)}\n`);
         }
         await sleep(intervalMinutes * 60_000);
     }
 }
 main().catch(async (error) => {
-    await appendSchedulerProof('runner_failed', {
-        error: error instanceof Error ? error.message : String(error),
+    const fallbackArgs = parseFailureArgs(process.argv.slice(2));
+    const configPath = path.resolve(fallbackArgs.config);
+    const statePath = path.resolve(fallbackArgs.state);
+    useSchedulerProofPathForStatePath(statePath);
+    const failureDecision = await recordRunnerFailure({
+        configPath,
+        statePath,
+        error,
         argv: process.argv.slice(2),
-    }).catch(() => { });
+    }).catch(async () => {
+        await appendSchedulerProof('runner_failed', {
+            error: error instanceof Error ? error.message : String(error),
+            argv: process.argv.slice(2),
+        }).catch(() => { });
+        return null;
+    });
     process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-    process.exitCode = 1;
+    process.exitCode = failureDecision?.exitCode ?? 1;
 });
 //# sourceMappingURL=openclaw-growth-runner.mjs.map