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

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

@@ -5,14 +5,15 @@ import process from 'node:process';
 import { createHash } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { getActionMode, getAllSourceEntries, getGitHubArtifactModes, getGitHubRequirementText, shouldAutoCreateGitHubArtifact, } from './openclaw-growth-shared.mjs';
+import { deriveRuntimeDirFromStatePath, deriveSchedulerProofPathFromStatePath, getActionMode, getAllSourceEntries, getGitHubArtifactModes, getGitHubRequirementText, 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: 'daily',
@@ -146,6 +147,24 @@ function replaceLegacyRuntimeScriptCommand(command) {
         return trimmed;
     return trimmed.replace(/^node\s+scripts\/(export-analytics-summary\.mjs|export-revenuecat-summary\.mjs|export-sentry-summary\.mjs|export-asc-summary\.mjs|openclaw-growth-engineer\.mjs|openclaw-growth-status\.mjs|openclaw-growth-preflight\.mjs|openclaw-growth-runner\.mjs)(?=\s|$)/, (_match, scriptName) => nodeRuntimeScriptCommand(scriptName));
 }
+function commandHasConfigArg(command) {
+    return /(?:^|\s)--config(?:=|\s|$)/.test(String(command || ''));
+}
+function commandShouldReceiveActiveConfig(command) {
+    return /(?:^|\s)(?:node\s+)?(?:\S*\/)?(?:export-analytics-summary|export-revenuecat-summary|export-sentry-summary|export-asc-summary)\.mjs(?:\s|$)/.test(String(command || ''));
+}
+function withActiveConfigArg(command, configPath) {
+    const trimmed = String(command || '').trim();
+    if (!trimmed || !configPath || !commandShouldReceiveActiveConfig(trimmed)) {
+        return trimmed;
+    }
+    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);
@@ -161,6 +180,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');
 }
@@ -529,7 +564,7 @@ function buildConnectorHealthAlert(statusPayload, unhealthyConnectors) {
             lines.push(`  Next: ${entry.nextAction}`);
         }
         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.');
+            lines.push('  Note: ASC uses API-key batch reports by default. Experimental ASC web analytics should only be requested when a needed metric is unavailable through API reports.');
         }
     }
     lines.push('');
@@ -550,20 +585,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) {
@@ -582,19 +640,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');
@@ -607,8 +683,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) {
@@ -624,6 +701,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()}`,
     };
@@ -651,6 +729,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()}`,
     };
@@ -662,10 +741,17 @@ 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);
+}
 async function deliverConnectorHealthAlert({ config, configPath, message, statusPayload, unhealthyConnectors, fingerprint }) {
     const channels = getConnectorHealthChannels(config);
     if (config?.notifications?.connectorHealth?.enabled === false) {
@@ -701,48 +787,23 @@ 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 || {},
-        });
-    }
-    if (deliveries.discord?.enabled) {
-        channels.push({
-            type: 'command',
-            label: 'discord',
-            command: deliveries.discord.command || 'node scripts/discord-openclaw-bridge.mjs send --stdin',
-        });
-    }
-    return channels;
+    return mergeNotificationChannelsWithDeliveries(configuredChannels, getDeliveryNotificationChannels(config, 'growthRun'));
 }
 async function readChartAttachments(chartManifestPath) {
     if (!chartManifestPath)
@@ -800,9 +861,8 @@ function buildGrowthRunSummaryMessage({ issuesPayload, activeCadences, sourceFil
     return `${lines.join('\n')}\n`;
 }
 async function writeConfiguredOpenClawChatGrowthSummary(configPath, channel, message, issuesPayload, activeCadences, fingerprint, charts) {
-    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');
+    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');
@@ -822,8 +882,9 @@ async function writeConfiguredOpenClawChatGrowthSummary(configPath, channel, mes
     }, 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) {
@@ -839,6 +900,7 @@ 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()}`,
     };
@@ -873,6 +935,7 @@ async function sendWebhookGrowthSummary(channel, message, issuesPayload, activeC
     });
     return {
         sent: response.ok,
+        external: true,
         target: channel.label || 'webhook',
         detail: response.ok ? `HTTP ${response.status}` : `HTTP ${response.status}: ${await response.text()}`,
     };
@@ -884,6 +947,7 @@ 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}`,
     };
@@ -937,6 +1001,12 @@ 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,
+        });
         return state;
     }
     await ensureDir(runtimeDir);
@@ -962,6 +1032,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);
@@ -975,11 +1052,10 @@ 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;
     if (unhealthyConnectors.length === 0) {
         nextHealthState.activeIncidentFingerprint = null;
+        nextHealthState.lastExternalAlertedFingerprint = null;
         if (healthState.lastStatusOk === false) {
             nextHealthState.lastRecoveredAt = checkedAt;
         }
@@ -988,7 +1064,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({
@@ -1004,6 +1080,11 @@ async function maybeRunConnectorHealthCheck({ config, configPath, state, statePa
         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,
@@ -1011,6 +1092,22 @@ 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,
+        deliveryCount: Array.isArray(nextHealthState.lastAlertDeliveries) ? nextHealthState.lastAlertDeliveries.length : 0,
+        externalDeliverySent: nextHealthState.lastAlertExternalSent === true,
+    });
     return nextState;
 }
 function buildIssueFingerprint(issuesPayload) {
@@ -1159,7 +1256,7 @@ 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,
@@ -1171,7 +1268,7 @@ async function resolveSourcePayloadWithCursor(sourceConfig, sourceName, cursorSt
         if (!sourceConfig.command) {
             throw new Error(`Source "${sourceName}" has mode=command but no command configured.`);
         }
-        const resolvedCommand = resolveCursorAwareCommand(replaceLegacyRuntimeScriptCommand(sourceConfig.command), sourceConfig, cursorState);
+        const resolvedCommand = resolveCursorAwareCommand(withActiveConfigArg(replaceLegacyRuntimeScriptCommand(sourceConfig.command), configPath), sourceConfig, cursorState);
         const result = await runShellCommand(String(resolvedCommand), 120_000, { cwd: commandCwd });
         if (!result.ok) {
             throw new Error(`Source "${sourceName}" command failed: ${result.stderr || `exit ${result.code}`}`);
@@ -1203,13 +1300,13 @@ async function resolveSourcePayloadWithCursor(sourceConfig, sourceName, cursorSt
         resolvedCommand: null,
     };
 }
-async function loadSourcePayloads(config, state) {
+async function loadSourcePayloads(config, state, configPath) {
     const payloads = {};
     const sourceCursors = { ...(state?.sourceCursors || {}) };
     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);
+        const result = await resolveSourcePayloadWithCursor(source, source.key, currentCursor, commandCwd, configPath);
         const payload = result.payload;
         if (payload) {
             payloads[source.key] = payload;
@@ -1247,6 +1344,11 @@ 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);
     await applyOpenClawSecretRefs(config);
     const inferredGitHubRepo = await inferGitHubRepo(config);
@@ -1263,7 +1365,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,
@@ -1272,19 +1374,27 @@ async function runOnce(configPath, statePath) {
         runtimeDir,
     });
     const activeCadences = getDueCadences(config, stateAfterHealthCheck);
-    const { payloads, sourceCursors } = await loadSourcePayloads(config, stateAfterHealthCheck);
+    const { payloads, sourceCursors } = await loadSourcePayloads(config, stateAfterHealthCheck, configPath);
     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`);
+        const completedAt = new Date().toISOString();
         await fs.mkdir(path.dirname(statePath), { recursive: true });
         await fs.writeFile(statePath, JSON.stringify({
             ...stateAfterHealthCheck,
             sourceHashes: currentHashes,
             sourceCursors,
-            lastRunAt: new Date().toISOString(),
+            lastRunAt: completedAt,
             skippedReason: 'no_data_change',
         }, null, 2), 'utf8');
+        await appendSchedulerProof('runner_completed', {
+            configPath,
+            statePath,
+            completedAt,
+            skippedReason: 'no_data_change',
+            activeCadences: activeCadences.map((cadence) => cadence.key),
+        });
         return;
     }
     const githubArtifactModes = getGitHubArtifactModes(config).filter((mode) => shouldAutoCreateGitHubArtifact(config, mode));
@@ -1312,17 +1422,26 @@ async function runOnce(configPath, statePath) {
     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 completedAt = new Date().toISOString();
         await fs.mkdir(path.dirname(statePath), { recursive: true });
         await fs.writeFile(statePath, JSON.stringify({
             ...stateAfterHealthCheck,
             sourceHashes: currentHashes,
             sourceCursors,
             lastIssueFingerprint: issueFingerprint,
-            lastRunAt: new Date().toISOString(),
+            lastRunAt: completedAt,
             lastOutFile: dryRun.outFile,
-            cadences: markCadencesRan(stateAfterHealthCheck, activeCadences, new Date().toISOString()),
+            cadences: markCadencesRan(stateAfterHealthCheck, activeCadences, completedAt),
             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,
+        });
         return;
     }
     const shouldCreateGitHubArtifact = createGitHubArtifact && Number(dryRun.issuesPayload?.issue_count || 0) > 0;
@@ -1343,15 +1462,16 @@ async function runOnce(configPath, statePath) {
     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,
         sourceHashes: currentHashes,
         sourceCursors,
         lastIssueFingerprint: issueFingerprint,
-        lastRunAt: new Date().toISOString(),
+        lastRunAt: completedAt,
         lastOutFile: dryRun.outFile,
-        cadences: markCadencesRan(stateAfterHealthCheck, activeCadences, new Date().toISOString()),
+        cadences: markCadencesRan(stateAfterHealthCheck, activeCadences, completedAt),
         lastGrowthRunNotifications: await deliverGrowthRunSummary({
             config,
             configPath,
@@ -1364,6 +1484,16 @@ async function runOnce(configPath, statePath) {
         }),
         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),
+        createdGitHubArtifact: shouldCreateGitHubArtifact,
+    });
 }
 async function main() {
     await loadOpenClawGrowthSecrets();
@@ -1371,6 +1501,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;
@@ -1384,12 +1515,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;
 });