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

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);
@@ -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 || ''));
 }
@@ -644,7 +692,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();
@@ -1042,6 +1091,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) {
@@ -1142,6 +1508,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}`);
         }
@@ -1686,7 +2056,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 +2263,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 +2320,7 @@ async function runOnce(configPath, statePath) {
             sourceHashes: currentHashes,
             sourceCursors,
             lastSourceFailures: sourceFailures,
+            dailyIssueReports: dailyIssueDedupe.dailyIssueReports,
             lastIssueFingerprint: issueFingerprint,
             lastRunAt: completedAt,
             lastOutFile: dryRun.outFile,
@@ -1935,7 +2350,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 +2377,7 @@ async function runOnce(configPath, statePath) {
         sourceHashes: currentHashes,
         sourceCursors,
         lastSourceFailures: sourceFailures,
+        dailyIssueReports: dailyIssueDedupe.dailyIssueReports,
         lastIssueFingerprint: issueFingerprint,
         lastRunAt: completedAt,
         lastOutFile: dryRun.outFile,
@@ -1969,7 +2385,7 @@ async function runOnce(configPath, statePath) {
         lastGrowthRunNotifications: await deliverGrowthRunSummary({
             config,
             configPath,
-            issuesPayload: dryRun.issuesPayload,
+            issuesPayload: deliverableIssuesPayload,
             activeCadences,
             sourceFiles,
             fingerprint: issueFingerprint,
@@ -2010,22 +2426,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