@analyticscli/growth-engineer 0.1.0-preview.1 → 0.1.0-preview.10

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

@@ -1,17 +1,30 @@
 #!/usr/bin/env node
-import { promises as fs } from 'node:fs';
+import { existsSync, promises as fs } from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline/promises';
 import { emitKeypressEvents } from 'node:readline';
 import { createPrivateKey } from 'node:crypto';
-import { buildExtraSourceConfig, getDefaultSourceCommand, getDefaultSourceHint, getDefaultSourcePath, } from './openclaw-growth-shared.mjs';
+import { fileURLToPath } from 'node:url';
+import { buildExtraSourceConfig, getDefaultSourceCommand, } from './openclaw-growth-shared.mjs';
 import { loadOpenClawGrowthSecrets } from './openclaw-growth-env.mjs';
 const DEFAULT_CONFIG_PATH = 'data/openclaw-growth-engineer/config.json';
 const SELF_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const ENABLE_ISOLATED_SECRET_RUNNER_WIZARD = false;
+const DEFAULT_GROWTH_INTERVAL_MINUTES = 1440;
+const DEFAULT_CONNECTOR_HEALTH_INTERVAL_MINUTES = 360;
+const GROWTH_ENGINEER_PACKAGE_SPEC = process.env.OPENCLAW_GROWTH_ENGINEER_PACKAGE || '@analyticscli/growth-engineer@preview';
+const RUNTIME_DIR = path.dirname(fileURLToPath(import.meta.url));
 const CONNECTOR_KEYS = ['analytics', 'github', 'revenuecat', 'sentry', 'asc'];
+class WizardAbortError extends Error {
+    exitCode;
+    constructor(message, exitCode = 130) {
+        super(message);
+        this.name = 'WizardAbortError';
+        this.exitCode = exitCode;
+    }
+}
 const CONNECTOR_DEFINITIONS = [
     {
         key: 'analytics',
@@ -47,33 +60,33 @@ const CONNECTOR_DEFINITIONS = [
 const DEFAULT_CADENCE_PLAN = [
     {
         key: 'daily',
-        title: 'Daily production guardrail',
+        title: 'Daily Sentry and production guardrail',
         intervalDays: 1,
         criticalOnly: true,
-        focusAreas: ['crash', 'conversion', 'paywall'],
-        sourcePriorities: ['sentry', 'glitchtip', 'analytics', 'asc_cli', 'revenuecat'],
-        objective: 'Only investigate critical production blockers and business anomalies: Sentry/GlitchTip production errors, crashes, very low users, conversion, purchases, or other urgent drops.',
-        instructions: 'Do exact root-cause analysis with connected production data, memory/state, release context, and recent code changes. Produce the fix or next debugging step; avoid generic growth ideas.',
+        focusAreas: ['sentry_errors', 'crash', 'onboarding', 'conversion', 'paywall', 'purchase'],
+        sourcePriorities: ['sentry', 'glitchtip', 'analytics', 'revenuecat', 'asc_cli', 'feedback', 'github'],
+        objective: 'Analyze every configured project for critical production blockers: Sentry/GlitchTip errors, crashes, onboarding or purchase drop-offs, zero-conversion days, missing buyers, very low users, and other silent business anomalies.',
+        instructions: 'Compare against recent baselines across connected sources and code changes. If the finding is critical, produce the exact fix or next debugging step and prefer a GitHub issue or draft PR when GitHub write access is configured; otherwise hand off via OpenClaw chat. Avoid generic growth ideas.',
     },
     {
         key: 'weekly',
-        title: 'Weekly conversion, traffic, and RevenueCat review',
+        title: 'Weekly executive product and growth summary',
         intervalDays: 7,
         criticalOnly: false,
-        focusAreas: ['conversion', 'paywall', 'onboarding', 'marketing', 'retention'],
-        sourcePriorities: ['analytics', 'revenuecat', 'asc_cli', 'feedback', 'sentry'],
-        objective: 'Analyze total conversion, traffic quality, activation, retention, RevenueCat trials/subscriptions/revenue/churn, source mix, reviews, releases, and stability.',
-        instructions: 'Pick one to three high-confidence growth bets with evidence, expected KPI movement, likely code/store surfaces, and verification plan.',
+        focusAreas: ['conversion', 'paywall', 'onboarding', 'marketing', 'retention', 'stability'],
+        sourcePriorities: ['analytics', 'revenuecat', 'asc_cli', 'feedback', 'sentry', 'github'],
+        objective: 'Create an executive summary across all configured projects, connectors, recent releases, code changes, revenue, activation, retention, reviews, and production stability.',
+        instructions: 'Pick one to three high-confidence improvements with evidence, expected KPI movement, likely code/store surfaces, owner-ready next steps, and a verification plan. Create GitHub issues or draft PR proposals only when the evidence is specific enough.',
     },
     {
         key: 'monthly',
-        title: 'Monthly business and product review',
+        title: 'Monthly deep product, business, and code review',
         intervalDays: 30,
         criticalOnly: false,
-        focusAreas: ['conversion', 'paywall', 'retention', 'marketing', 'onboarding'],
-        sourcePriorities: ['analytics', 'revenuecat', 'asc_cli', 'feedback', 'sentry'],
-        objective: 'Compare MRR, trial conversion, churn, acquisition quality, store conversion, retention, review themes, feature usage, and crash totals month-over-month.',
-        instructions: 'Decide what should be built, changed, or deleted next and explain why it should move revenue, activation, retention, or acquisition quality.',
+        focusAreas: ['conversion', 'paywall', 'retention', 'marketing', 'onboarding', 'codebase'],
+        sourcePriorities: ['analytics', 'revenuecat', 'asc_cli', 'feedback', 'sentry', 'github'],
+        objective: 'Compare all configured projects month-over-month: MRR, trial conversion, churn, acquisition quality, store conversion, retention, review themes, feature usage, crash totals, and codebase changes.',
+        instructions: 'Decide what should be built, changed, deleted, or instrumented next. Tie conclusions to connector data plus codebase evidence and explain why each recommendation should move revenue, activation, retention, stability, or acquisition quality.',
     },
     {
         key: 'quarterly',
@@ -81,8 +94,8 @@ const DEFAULT_CADENCE_PLAN = [
         intervalDays: 91,
         criticalOnly: false,
         focusAreas: ['marketing', 'paywall', 'retention', 'conversion', 'onboarding'],
-        sourcePriorities: ['analytics', 'revenuecat', 'asc_cli', 'feedback'],
-        objective: 'Revisit positioning, pricing/packaging, onboarding architecture, roadmap assumptions, tracking quality, and major funnel bets.',
+        sourcePriorities: ['analytics', 'revenuecat', 'asc_cli', 'feedback', 'github', 'sentry'],
+        objective: 'Revisit positioning, pricing/packaging, onboarding architecture, roadmap assumptions, tracking quality, codebase constraints, and major funnel bets across every configured project.',
         instructions: 'Find structural constraints and durable opportunities. Tie recommendations to cohort behavior, monetization, reviews, channel quality, and shipped changes.',
     },
     {
@@ -92,7 +105,7 @@ const DEFAULT_CADENCE_PLAN = [
         criticalOnly: false,
         focusAreas: ['retention', 'conversion', 'paywall', 'marketing', 'general'],
         sourcePriorities: ['analytics', 'revenuecat', 'asc_cli', 'feedback', 'sentry'],
-        objective: 'Audit connector coverage, SDK instrumentation, event taxonomy, data reliability, memory, growth loops, and whether strategy still matches the best users.',
+        objective: 'Audit connector coverage, SDK instrumentation, event taxonomy, data reliability, memory, growth loops, and whether product/code strategy still matches the best users across configured projects.',
         instructions: 'Prioritize measurement fixes and system changes that make future analysis more trustworthy. Identify stale events, missing attribution, weak identity, and misleading dashboards.',
     },
     {
@@ -102,7 +115,7 @@ const DEFAULT_CADENCE_PLAN = [
         criticalOnly: false,
         focusAreas: ['marketing', 'retention', 'paywall', 'conversion', 'general'],
         sourcePriorities: ['analytics', 'revenuecat', 'asc_cli', 'feedback', 'sentry'],
-        objective: 'Reset strategy from evidence: market/channel fit, monetization model, retention ceiling, product scope, and whether to double down, reposition, rebuild, or sunset major surfaces/features.',
+        objective: 'Reset strategy from evidence across every configured project: market/channel fit, monetization model, retention ceiling, product scope, and whether to double down, reposition, rebuild, or sunset major surfaces/features.',
         instructions: 'Use the full year of memory, releases, revenue, acquisition, reviews, code changes, and cohort behavior. Produce strategic experiments and stop-doing decisions.',
     },
 ];
@@ -210,6 +223,91 @@ function quote(value) {
     }
     return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }
+function resolveRuntimeScriptPath(scriptName) {
+    const candidates = [
+        path.join(RUNTIME_DIR, scriptName),
+        path.resolve('scripts', scriptName),
+        path.resolve('skills/openclaw-growth-engineer/scripts', scriptName),
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) || path.join(RUNTIME_DIR, scriptName);
+}
+function nodeRuntimeScriptCommand(scriptName) {
+    return `node ${quote(resolveRuntimeScriptPath(scriptName))}`;
+}
+function growthEngineerPackageCommand(args) {
+    return `npx -y ${quote(GROWTH_ENGINEER_PACKAGE_SPEC)} ${args}`;
+}
+function getWizardDefaultSourceCommand(sourceName) {
+    const normalized = String(sourceName || '').trim().toLowerCase();
+    if (normalized === 'analytics' || normalized === 'analyticscli') {
+        return nodeRuntimeScriptCommand('export-analytics-summary.mjs');
+    }
+    if (normalized === 'revenuecat' || normalized === 'revenue-cat') {
+        return nodeRuntimeScriptCommand('export-revenuecat-summary.mjs');
+    }
+    if (normalized === 'sentry' || normalized === 'glitchtip') {
+        return nodeRuntimeScriptCommand('export-sentry-summary.mjs');
+    }
+    if (normalized === 'feedback') {
+        return getDefaultSourceCommand('feedback');
+    }
+    if (['asc', 'asc-cli', 'app-store-connect', 'app_store_connect'].includes(normalized)) {
+        return nodeRuntimeScriptCommand('export-asc-summary.mjs');
+    }
+    return getDefaultSourceCommand(sourceName);
+}
+function replaceLegacyRuntimeScriptCommand(command) {
+    const trimmed = String(command || '').trim();
+    if (!trimmed)
+        return trimmed;
+    return trimmed.replace(/^node\s+scripts\/(export-analytics-summary\.mjs|export-revenuecat-summary\.mjs|export-sentry-summary\.mjs|export-asc-summary\.mjs|openclaw-growth-start\.mjs|openclaw-growth-status\.mjs|openclaw-growth-runner\.mjs|openclaw-growth-preflight\.mjs)(?=\s|$)/, (_match, scriptName) => nodeRuntimeScriptCommand(scriptName));
+}
+function normalizeWizardSourceCommand(sourceName, source) {
+    const current = replaceLegacyRuntimeScriptCommand(source?.command || '');
+    return current || getWizardDefaultSourceCommand(sourceName);
+}
+function migrateRuntimeSourceCommands(config) {
+    if (!config || typeof config !== 'object')
+        return config;
+    const sources = config.sources && typeof config.sources === 'object' ? config.sources : {};
+    const nextSources = { ...sources };
+    for (const sourceName of ['analytics', 'revenuecat', 'sentry']) {
+        if (nextSources[sourceName]?.mode === 'command') {
+            nextSources[sourceName] = {
+                ...nextSources[sourceName],
+                command: normalizeWizardSourceCommand(sourceName, nextSources[sourceName]),
+            };
+        }
+    }
+    if (Array.isArray(nextSources.extra)) {
+        nextSources.extra = nextSources.extra.map((source) => {
+            if (!source || source.mode !== 'command')
+                return source;
+            const service = String(source.service || source.key || '').toLowerCase();
+            const sourceName = ['asc', 'asc-cli', 'app-store-connect', 'app_store_connect'].includes(service)
+                ? 'asc'
+                : service;
+            return {
+                ...source,
+                command: normalizeWizardSourceCommand(sourceName, source),
+            };
+        });
+    }
+    return {
+        ...config,
+        sources: nextSources,
+    };
+}
+async function migrateRuntimeSourceCommandsFile(configPath) {
+    const existing = await readJsonIfPresent(configPath).catch(() => null);
+    if (!existing || typeof existing !== 'object')
+        return null;
+    const migrated = migrateRuntimeSourceCommands(existing);
+    if (JSON.stringify(existing.sources || {}) !== JSON.stringify(migrated.sources || {})) {
+        await writeJsonFile(configPath, migrated);
+    }
+    return migrated;
+}
 function normalizeConnectorKey(value) {
     const normalized = String(value || '').trim().toLowerCase().replace(/[_\s]+/g, '-');
     if (!normalized)
@@ -268,23 +366,28 @@ function withMissingRequiredAnalyticsConnector(selected) {
         return orderConnectors(selected);
     return orderConnectors(['analytics', ...selected]);
 }
-async function askConnectorSelection(rl) {
-    return askConnectorSelectionWithHealth(rl, {}, []);
-}
-async function askConnectorSelectionWithHealth(rl, healthByConnector = {}, initialSelected = []) {
+async function askConnectorSelectionWithHealth(rl, healthByConnector = {}, initialSelected = [], copy = {}) {
     if (!process.stdin.isTTY || !process.stdout.isTTY || !process.stdin.setRawMode) {
-        return await askConnectorSelectionByText(rl, healthByConnector);
+        return await askConnectorSelectionByText(rl, healthByConnector, copy);
     }
     rl.pause();
+    let completed = false;
     try {
-        return await askConnectorSelectionByKeys(healthByConnector, initialSelected);
+        const selected = await askConnectorSelectionByKeys(healthByConnector, initialSelected, copy);
+        completed = true;
+        return selected;
     }
     finally {
-        rl.resume();
+        if (completed) {
+            rl.resume();
+        }
+        else {
+            process.stdin.pause();
+        }
     }
 }
-async function askConnectorSelectionByText(rl, healthByConnector = {}) {
-    printConnectorIntro();
+async function askConnectorSelectionByText(rl, healthByConnector = {}, copy = {}) {
+    printConnectorIntro(copy);
     for (const group of connectorPickerGroups(healthByConnector)) {
         process.stdout.write(`${ANSI.bold}${group.title}${ANSI.reset}\n`);
         for (const connector of group.connectors) {
@@ -322,26 +425,117 @@ function orderConnectors(keys) {
     const selected = new Set(keys);
     return CONNECTOR_KEYS.filter((key) => selected.has(key));
 }
-function printConnectorIntro() {
-    process.stdout.write(`\n${ANSI.bold}OpenClaw connector setup${ANSI.reset}\n`);
-    process.stdout.write(`${ANSI.dim}Secrets stay local on this host. Do not paste them into any chat or social channel.${ANSI.reset}\n\n`);
+function printConnectorIntro(copy = {}) {
+    process.stdout.write(`\n${ANSI.bold}${copy.introTitle || 'OpenClaw connector setup'}${ANSI.reset}\n`);
+    const detail = copy.introDetail === undefined
+        ? 'You can configure connector secrets here. API keys stay in this host\'s local secrets file, not in chat or config JSON.'
+        : copy.introDetail;
+    if (detail) {
+        process.stdout.write(`${ANSI.dim}${detail}${ANSI.reset}\n`);
+    }
+    process.stdout.write('\n');
 }
-async function withTerminalLoading(message, task) {
-    const frames = ['-', '\\', '|', '/'];
-    let index = 0;
-    process.stdout.write(`${message} ${frames[index]}`);
-    const timer = setInterval(() => {
-        index = (index + 1) % frames.length;
-        process.stdout.write(`\r${message} ${frames[index]}`);
-    }, 120);
+async function askMenuChoice(rl, { title, subtitle = 'Use Up/Down to move, Enter to continue.', options, defaultValue, renderHeader, }) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY || !process.stdin.setRawMode) {
+        process.stdout.write(`\n${title}\n`);
+        options.forEach((option, index) => {
+            process.stdout.write(`  ${index + 1}) ${option.label}: ${option.detail}\n`);
+        });
+        const defaultIndex = Math.max(0, options.findIndex((option) => option.value === defaultValue));
+        const answer = await ask(rl, `Setup area (1-${options.length})`, String(defaultIndex + 1));
+        const selected = options[Number(answer.trim()) - 1] || options[defaultIndex];
+        return selected.value;
+    }
+    rl.pause();
+    let completed = false;
     try {
-        return await task;
+        const selected = await askMenuChoiceByKeys({ title, subtitle, options, defaultValue, renderHeader });
+        completed = true;
+        return selected;
     }
     finally {
-        clearInterval(timer);
-        process.stdout.write(`\r${message} done\n`);
+        if (completed) {
+            rl.resume();
+        }
+        else {
+            process.stdin.pause();
+        }
     }
 }
+async function askMenuChoiceByKeys({ title, subtitle, options, defaultValue, renderHeader, }) {
+    emitKeypressEvents(process.stdin);
+    const wasRaw = process.stdin.isRaw;
+    const wasPaused = process.stdin.isPaused();
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    let cursorIndex = Math.max(0, options.findIndex((option) => option.value === defaultValue));
+    return await new Promise((resolve, reject) => {
+        const cleanup = () => {
+            process.stdin.off('keypress', onKeypress);
+            process.stdin.setRawMode(Boolean(wasRaw));
+            if (wasPaused) {
+                process.stdin.pause();
+            }
+            process.stdout.write(ANSI.showCursor);
+        };
+        const render = () => {
+            process.stdout.write('\x1b[2J\x1b[H');
+            renderHeader?.();
+            process.stdout.write(`\n${ANSI.bold}${title}${ANSI.reset}\n`);
+            process.stdout.write(`${ANSI.dim}${subtitle}${ANSI.reset}\n\n`);
+            for (let index = 0; index < options.length; index += 1) {
+                const option = options[index];
+                const pointer = index === cursorIndex ? `${ANSI.cyan}>${ANSI.reset}` : ' ';
+                const number = `${index + 1})`;
+                process.stdout.write(`${pointer} ${number} ${ANSI.bold}${option.label}${ANSI.reset}\n`);
+                writeWrapped(option.detail, '     ', ANSI.dim);
+            }
+            process.stdout.write(`\n${ANSI.dim}Esc/Q cancels. Number keys 1-${options.length} select directly.${ANSI.reset}\n`);
+        };
+        const cancel = () => {
+            cleanup();
+            process.stdout.write('\n');
+            reject(new WizardAbortError('Setup cancelled.'));
+        };
+        const finish = () => {
+            cleanup();
+            process.stdout.write('\x1b[2J\x1b[H');
+            resolve(options[cursorIndex]?.value || defaultValue);
+        };
+        const onKeypress = (_text, key) => {
+            if (key?.ctrl && key?.name === 'c') {
+                cancel();
+                return;
+            }
+            if (key?.name === 'escape' || key?.name === 'q') {
+                cancel();
+                return;
+            }
+            if (key?.name === 'up' || key?.name === 'k') {
+                cursorIndex = (cursorIndex - 1 + options.length) % options.length;
+            }
+            else if (key?.name === 'down' || key?.name === 'j') {
+                cursorIndex = (cursorIndex + 1) % options.length;
+            }
+            else if (key?.name === 'return' || key?.name === 'enter') {
+                finish();
+                return;
+            }
+            else if (/^[1-9]$/.test(String(_text || ''))) {
+                const selectedIndex = Number(_text) - 1;
+                if (options[selectedIndex]) {
+                    cursorIndex = selectedIndex;
+                    finish();
+                    return;
+                }
+            }
+            render();
+        };
+        process.stdin.on('keypress', onKeypress);
+        process.stdout.write(ANSI.hideCursor);
+        render();
+    });
+}
 function normalizeConnectorProgressKey(key) {
     const normalized = String(key || '').trim().toLowerCase();
     if (normalized === 'analytics' || normalized === 'analyticscli')
@@ -439,9 +633,6 @@ function connectorStatusLabel(key, healthByConnector = {}) {
         return 'not configured';
     return `configured, ${connectorHealthLabel(health.status)}`;
 }
-function formatConnectorHealthLine(key, healthByConnector = {}) {
-    return `${ANSI.dim}${formatConnectorHealthText(key, healthByConnector)}${ANSI.reset}`;
-}
 function formatConnectorHealthText(key, healthByConnector = {}) {
     const health = getConnectorHealth(key, healthByConnector);
     const label = connectorStatusLabel(key, healthByConnector);
@@ -517,7 +708,7 @@ async function getConnectorPickerHealth(configPath, onProgress = () => { }) {
             },
         ]));
     }
-    const result = await runCommandCaptureWithProgress(`node scripts/openclaw-growth-status.mjs --config ${quote(configPath)} --json --progress-json`, onProgress);
+    const result = await runCommandCaptureWithProgress(`${nodeRuntimeScriptCommand('openclaw-growth-status.mjs')} --config ${quote(configPath)} --json --progress-json`, onProgress);
     const payload = parseJsonFromStdout(result.stdout);
     const connectors = payload?.connectors && typeof payload.connectors === 'object' ? payload.connectors : {};
     const healthByConnector = {
@@ -529,11 +720,11 @@ async function getConnectorPickerHealth(configPath, onProgress = () => { }) {
     };
     return Object.fromEntries(CONNECTOR_KEYS.map((key) => [key, getConnectorHealth(key, healthByConnector)]));
 }
-function renderConnectorPicker(cursorIndex, selected, required, healthByConnector = {}, warning = '') {
+function renderConnectorPicker(cursorIndex, selected, required, healthByConnector = {}, warning = '', copy = {}) {
     process.stdout.write('\x1b[2J\x1b[H');
-    printConnectorIntro();
-    process.stdout.write(`${ANSI.bold}Select connectors to set up or overwrite now${ANSI.reset}\n`);
-    writeWrapped('Use Up/Down to move, Space to toggle optional connectors, A to toggle all optional connectors, Enter to continue.', '', ANSI.dim);
+    printConnectorIntro(copy);
+    process.stdout.write(`${ANSI.bold}${copy.actionTitle || 'Select connectors to set up or overwrite now'}${ANSI.reset}\n`);
+    writeWrapped(copy.helpText || 'Use Up/Down to move, Space to toggle optional connectors, A to toggle all optional connectors, Enter to continue.', '', ANSI.dim);
     process.stdout.write('\n');
     let index = 0;
     for (const group of connectorPickerGroups(healthByConnector)) {
@@ -559,16 +750,18 @@ function renderConnectorPicker(cursorIndex, selected, required, healthByConnecto
     }
     process.stdout.write(`${ANSI.dim}Esc/Q cancels. Number keys 1-${CONNECTOR_DEFINITIONS.length} also toggle connectors.${ANSI.reset}\n`);
 }
-async function askConnectorSelectionByKeys(healthByConnector = {}, initialSelected = []) {
+async function askConnectorSelectionByKeys(healthByConnector = {}, initialSelected = [], copy = {}) {
     emitKeypressEvents(process.stdin);
     const wasRaw = process.stdin.isRaw;
     const wasPaused = process.stdin.isPaused();
     process.stdin.setRawMode(true);
     process.stdin.resume();
     let cursorIndex = 0;
-    const required = getRequiredConnectorKeys();
+    const required = copy.mode === 'input' ? new Set() : getRequiredConnectorKeys();
     const initial = new Set(initialSelected);
-    const selected = new Set(CONNECTOR_KEYS.filter((key) => required.has(key) || initial.has(key) || !isConnectorLocallyConfigured(key)));
+    const selected = new Set(CONNECTOR_KEYS.filter((key) => required.has(key) ||
+        initial.has(key) ||
+        (copy.mode !== 'input' && !isConnectorLocallyConfigured(key))));
     let warning = '';
     return await new Promise((resolve, reject) => {
         const displayItems = () => connectorPickerDisplayItems(healthByConnector);
@@ -586,7 +779,7 @@ async function askConnectorSelectionByKeys(healthByConnector = {}, initialSelect
             required.forEach((key) => selected.add(key));
             if (selected.size === 0) {
                 warning = 'No connectors selected. Select a connector to update or press Esc to cancel.';
-                renderConnectorPicker(cursorIndex, selected, required, healthByConnector, warning);
+                renderConnectorPicker(cursorIndex, selected, required, healthByConnector, warning, copy);
                 return;
             }
             cleanup();
@@ -596,7 +789,7 @@ async function askConnectorSelectionByKeys(healthByConnector = {}, initialSelect
         const cancel = () => {
             cleanup();
             process.stdout.write('\n');
-            reject(new Error('Connector setup cancelled.'));
+            reject(new WizardAbortError('Connector setup cancelled.'));
         };
         const toggleCurrent = () => {
             const connector = selectedDisplayConnector();
@@ -671,11 +864,11 @@ async function askConnectorSelectionByKeys(healthByConnector = {}, initialSelect
                     }
                 }
             }
-            renderConnectorPicker(cursorIndex, selected, required, healthByConnector, warning);
+            renderConnectorPicker(cursorIndex, selected, required, healthByConnector, warning, copy);
         };
         process.stdin.on('keypress', onKeypress);
         process.stdout.write(ANSI.hideCursor);
-        renderConnectorPicker(cursorIndex, selected, required, healthByConnector, warning);
+        renderConnectorPicker(cursorIndex, selected, required, healthByConnector, warning, copy);
     });
 }
 async function commandExists(commandName) {
@@ -914,16 +1107,16 @@ function summarizeFailureFix(connector, blockers) {
         if (/revoked|unauthorized|UNAUTHORIZED/i.test(combined)) {
             return 'Paste a fresh AnalyticsCLI readonly CLI token in the wizard, then let setup retest.';
         }
-        return 'Verify the AnalyticsCLI token can list projects. Per-project query failures are reported as warnings and should not block connector setup.';
+        return 'Verify the AnalyticsCLI token can list accessible projects. Per-project query failures are reported as warnings and should not block connector setup.';
     }
     if (connector === 'sentry') {
         if (/404|Not Found/i.test(combined)) {
-            return 'Rerun Sentry/GlitchTip setup and use the correct base URL + discovered org. If projects are discovered, accept/select those projects.';
+            return 'Rerun Sentry/GlitchTip setup and use the correct base URL + visible org. Project scope stays unpinned and is resolved from app context later.';
         }
-        return 'Verify the Sentry/GlitchTip token, base URL, org, and project list, then rerun setup.';
+        return 'Verify the Sentry/GlitchTip token, base URL, and org, then rerun setup.';
     }
     if (connector === 'github') {
-        return 'Set project.githubRepo only if you want GitHub issue/PR delivery now; otherwise leave GitHub deferred.';
+        return 'Verify the GitHub token. Repo scope is inferred from OPENCLAW_GITHUB_REPO, the local git remote, or runtime context.';
     }
     if (connector === 'revenuecat') {
         return 'Paste a RevenueCat v2 secret API key with read-only project permissions, then rerun setup.';
@@ -1048,11 +1241,6 @@ function printSetupSuccess(payload) {
         process.stdout.write(`${payload.message}\n`);
     }
 }
-function healthCheckFailures(payload) {
-    return Array.isArray(payload?.checks)
-        ? payload.checks.filter((check) => check?.status === 'fail')
-        : [];
-}
 function connectorFromCheckName(name) {
     const value = String(name || '');
     if (value.includes('analytics') || value.includes('ANALYTICSCLI'))
@@ -1111,146 +1299,12 @@ function cleanHealthDetail(detail) {
     }
     return truncate(raw, 180);
 }
-function actionForHealthFailure(failure, configPath) {
-    const name = String(failure?.name || '');
-    const detail = String(failure?.detail || '');
-    if (name === 'project:github-repo' || /project\.githubRepo/i.test(detail)) {
-        return `No action required for Sentry setup. Set project.githubRepo in ${configPath} only if you want GitHub issue/PR delivery now.`;
-    }
-    if (name.includes('analytics') || /ANALYTICSCLI|analytics/i.test(detail)) {
-        return 'Paste a fresh AnalyticsCLI readonly token, then let the wizard retest AnalyticsCLI.';
-    }
-    if (name.includes('sentry') || /Sentry|GlitchTip/i.test(detail)) {
-        return 'Only fix this if token, org, or base URL is missing or invalid.';
-    }
-    if (name.includes('github')) {
-        return 'Configure GitHub token/repo access, or leave GitHub delivery disabled.';
-    }
-    if (name.includes('revenuecat')) {
-        return 'Paste a RevenueCat v2 secret API key with read-only project permissions.';
-    }
-    if (name.includes('asc')) {
-        return 'Paste ASC API key details or rerun ASC setup when ready.';
-    }
-    return 'Use the connector setup flow below to refresh this configuration.';
-}
 function isDeferredGitHubFailure(failure) {
     const name = String(failure?.name || '');
     const detail = String(failure?.detail || '');
     return (name === 'project:github-repo' ||
         (name === 'connection:github' && /project\.githubRepo|repo is missing|repo is not configured/i.test(detail)));
 }
-function isDeferredSentryProjectFailure(failure) {
-    const name = String(failure?.name || '');
-    const detail = String(failure?.detail || '');
-    return name.includes('sentry') && /No Sentry projects configured/i.test(detail);
-}
-function summarizeHealthFailure(failure, configPath) {
-    const name = String(failure?.name || '');
-    const detail = String(failure?.detail || '');
-    const connector = connectorFromCheckName(`${name} ${detail}`) || 'setup';
-    if (connector === 'analytics' && /invalid token|unauthorized|token has been revoked/i.test(detail)) {
-        return {
-            connector,
-            status: 'token invalid or expired',
-            action: 'paste a fresh readonly token',
-        };
-    }
-    if (connector === 'sentry' && /No Sentry projects configured/i.test(detail)) {
-        return {
-            connector,
-            status: 'project scope deferred',
-            action: 'no user action; OpenClaw discovers visible projects from org + token',
-        };
-    }
-    if (connector === 'github' && isDeferredGitHubFailure(failure)) {
-        return {
-            connector,
-            status: 'repo not known yet',
-            action: `optional; set project.githubRepo in ${configPath} only for GitHub delivery`,
-        };
-    }
-    return {
-        connector,
-        status: cleanHealthDetail(detail),
-        action: actionForHealthFailure(failure, configPath),
-    };
-}
-function printHealthFailures(failures, configPath) {
-    const summarized = [];
-    const seen = new Set();
-    for (const failure of failures) {
-        if (isDeferredGitHubFailure(failure))
-            continue;
-        if (isDeferredSentryProjectFailure(failure))
-            continue;
-        const summary = summarizeHealthFailure(failure, configPath);
-        const key = `${summary.connector}:${summary.status}:${summary.action}`;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        summarized.push(summary);
-    }
-    if (summarized.length === 0) {
-        process.stdout.write('\nOnly deferred optional checks remain.\n\n');
-        return;
-    }
-    process.stdout.write('\nNeeds attention\n');
-    process.stdout.write('---------------\n');
-    for (const summary of summarized) {
-        process.stdout.write(`- ${connectorTitle(summary.connector)}: ${summary.status}\n`);
-        process.stdout.write(`  Next: ${summary.action}\n`);
-    }
-    process.stdout.write('\n');
-}
-function inferConnectorsFromHealthFailures(failures) {
-    const inferred = new Set();
-    for (const failure of failures) {
-        if (isDeferredGitHubFailure(failure))
-            continue;
-        if (isDeferredSentryProjectFailure(failure))
-            continue;
-        const connector = connectorFromCheckName(`${failure?.name || ''} ${failure?.detail || ''}`);
-        if (connector)
-            inferred.add(connector);
-    }
-    return orderConnectors([...inferred]);
-}
-async function getHealthCheckPlan(configPath, selected) {
-    const config = await readJsonIfPresent(configPath).catch(() => null);
-    const items = [
-        {
-            key: 'preflight',
-            label: 'Local preflight',
-            detail: 'config, dependencies, source wiring',
-            status: 'pending',
-        },
-    ];
-    const selectedSet = new Set(selected);
-    const hasAnalytics = selectedSet.has('analytics') ||
-        Boolean(process.env.ANALYTICSCLI_ACCESS_TOKEN?.trim() || process.env.ANALYTICSCLI_READONLY_TOKEN?.trim()) ||
-        (config?.sources?.analytics && config.sources.analytics.enabled !== false);
-    const sentryAccounts = Array.isArray(config?.sources?.sentry?.accounts) ? config.sources.sentry.accounts : [];
-    const hasSentry = selectedSet.has('sentry') ||
-        sentryAccounts.length > 0 ||
-        Boolean(process.env.SENTRY_AUTH_TOKEN?.trim() || process.env.GLITCHTIP_AUTH_TOKEN?.trim());
-    const hasRevenueCat = selectedSet.has('revenuecat') ||
-        Boolean(process.env.REVENUECAT_API_KEY?.trim()) ||
-        (config?.sources?.revenuecat && config.sources.revenuecat.enabled !== false);
-    const githubRepo = String(config?.project?.githubRepo || '').trim();
-    const hasGitHub = selectedSet.has('github') || Boolean(process.env.GITHUB_TOKEN?.trim()) || Boolean(githubRepo);
-    if (hasAnalytics)
-        items.push({ key: 'analytics', label: 'AnalyticsCLI', detail: 'token auth + readonly query', status: 'pending' });
-    if (hasSentry)
-        items.push({ key: 'sentry', label: 'Sentry / GlitchTip', detail: 'token/org API + project discovery', status: 'pending' });
-    if (hasRevenueCat)
-        items.push({ key: 'revenuecat', label: 'RevenueCat', detail: 'API key auth + project read', status: 'pending' });
-    if (hasGitHub && githubRepo)
-        items.push({ key: 'github', label: 'GitHub', detail: `repo access (${githubRepo})`, status: 'pending' });
-    if (hasGitHub && !githubRepo)
-        items.push({ key: 'github', label: 'GitHub', detail: 'skipped until repo is known', status: 'pending' });
-    return items;
-}
 function healthStatusLabel(status) {
     if (status === 'running')
         return 'running';
@@ -1299,9 +1353,6 @@ function updateHealthProgress(items, event) {
     }
     return false;
 }
-function allProgressItemsFinished(items) {
-    return items.length > 0 && items.every((item) => !['pending', 'running'].includes(String(item.status || '')));
-}
 function buildSetupTestProgressPlan(selected) {
     const selectedSet = new Set(selected);
     const items = [
@@ -1403,7 +1454,7 @@ async function runImmediateConnectorHealthCheck({ rl, configPath, connector, sec
         ...process.env,
         ...secrets,
     };
-    const command = `node scripts/openclaw-growth-start.mjs --config ${quote(configPath)} --setup-only --connectors ${quote(connector)} --only-connectors ${quote(connector)}`;
+    const command = `${nodeRuntimeScriptCommand('openclaw-growth-start.mjs')} --config ${quote(configPath)} --setup-only --connectors ${quote(connector)} --only-connectors ${quote(connector)}`;
     let result = await runSetupCommandWithProgress(command, env, [connector], `Checking ${connectorLabel(connector)} immediately after setup...`);
     let payload = parseJsonFromStdout(result.stdout);
     if (connector === 'asc') {
@@ -1430,39 +1481,6 @@ async function runImmediateConnectorHealthCheck({ rl, configPath, connector, sec
     process.stdout.write(`\n${connectorLabel(connector)} immediate health check passed or is only waiting on optional/deferred context.\n`);
     return { ok: true, retry: false, result, payload };
 }
-async function offerConfiguredConnectionFixes(rl, configPath, selected) {
-    if (!(await fileExists(configPath)))
-        return selected;
-    clearTerminal();
-    const plan = await getHealthCheckPlan(configPath, selected);
-    renderHealthProgress(plan, 'Starting live checks...');
-    const command = `node scripts/openclaw-growth-preflight.mjs --config ${quote(configPath)} --test-connections --progress-json`;
-    const result = await runCommandCaptureWithProgress(command, (event) => {
-        if (updateHealthProgress(plan, event)) {
-            renderHealthProgress(plan);
-        }
-    });
-    renderHealthProgress(plan, 'Checks finished.');
-    const payload = parseJsonFromStdout(result.stdout);
-    const failures = healthCheckFailures(payload).filter((failure) => !isDeferredGitHubFailure(failure) && !isDeferredSentryProjectFailure(failure));
-    if (payload?.ok === true || failures.length === 0) {
-        process.stdout.write('Configured connectors look healthy.\n\n');
-        return selected;
-    }
-    printHealthFailures(failures, configPath);
-    const inferred = inferConnectorsFromHealthFailures(failures);
-    if (inferred.length === 0) {
-        process.stdout.write('Continuing with the connector(s) you selected.\n\n');
-        return selected;
-    }
-    const fixNow = await askYesNo(rl, `Fix now (${inferred.join(', ')})?`, true);
-    clearTerminal();
-    if (!fixNow) {
-        process.stdout.write('Continuing with selected connector(s).\n\n');
-        return selected;
-    }
-    return orderConnectors([...new Set([...selected, ...inferred])]);
-}
 function getUserLocalBinDir() {
     return process.env.HOME ? path.join(process.env.HOME, '.local', 'bin') : null;
 }
@@ -1818,13 +1836,13 @@ function getGrowthRunCommand(config, displayConfigPath) {
     if (config?.security?.connectorSecrets?.mode === 'isolated-runner' && config.security.connectorSecrets.runCommand) {
         return config.security.connectorSecrets.runCommand;
     }
-    return `node scripts/openclaw-growth-runner.mjs --config ${displayConfigPath}`;
+    return growthEngineerPackageCommand(`run --config ${quote(displayConfigPath)}`);
 }
 function getConnectorHealthCommand(config, displayConfigPath) {
     if (config?.security?.connectorSecrets?.mode === 'isolated-runner' && config.security.connectorSecrets.healthCommand) {
         return config.security.connectorSecrets.healthCommand;
     }
-    return `node scripts/openclaw-growth-runner.mjs --config ${displayConfigPath}`;
+    return growthEngineerPackageCommand(`run --config ${quote(displayConfigPath)}`);
 }
 async function maybePromptSecret(rl, label, envName) {
     const existing = process.env[envName]?.trim();
@@ -1874,12 +1892,6 @@ function printSentryTokenGuidance({ baseUrl, tokenEnv }) {
         'Optional for richer release context: `project:releases`.',
     ]);
 }
-function parseCommaList(value) {
-    return String(value || '')
-        .split(',')
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-}
 function buildUrl(baseUrl, pathname, params = {}) {
     const url = new URL(pathname, `${String(baseUrl || 'https://sentry.io').replace(/\/$/, '')}/`);
     for (const [key, value] of Object.entries(params)) {
@@ -1904,7 +1916,7 @@ function apiListItems(payload) {
         return payload.teams;
     return [];
 }
-async function fetchSentryJsonPage({ baseUrl, token, url }) {
+async function fetchSentryJsonPage({ token, url }) {
     const normalizedToken = String(token || '').trim();
     const response = await fetch(url, {
         method: 'GET',
@@ -1938,7 +1950,7 @@ async function fetchSentryJsonList({ baseUrl, token, url }) {
     const pages = [];
     let nextUrl = url;
     for (let page = 0; nextUrl && page < 10; page += 1) {
-        const result = await fetchSentryJsonPage({ baseUrl, token, url: nextUrl });
+        const result = await fetchSentryJsonPage({ token, url: nextUrl });
         pages.push(result.detail);
         if (!result.ok)
             return { ...result, payload: items, detail: pages.join('; ') };
@@ -2069,7 +2081,7 @@ async function upsertSentryAccountsConfig(configPath, accounts) {
             ...(config.sources?.sentry || {}),
             enabled: true,
             mode: 'command',
-            command: getDefaultSourceCommand('sentry'),
+            command: getWizardDefaultSourceCommand('sentry'),
             accounts: [...merged.values()],
         },
     };
@@ -2482,13 +2494,13 @@ async function guideSentryConnector(rl, secrets) {
             org = await ask(rl, `Sentry org slug for ${label} (leave empty to defer)`, index === 0 ? process.env.SENTRY_ORG || '' : '');
         }
         const environment = await ask(rl, `Sentry environment for ${label}`, index === 0 ? process.env.SENTRY_ENVIRONMENT || 'production' : 'production');
-        let projects = [];
         if (org.trim() && token) {
-            process.stdout.write(`Discovering Sentry projects for ${label}...\n`);
+            process.stdout.write(`Checking visible Sentry projects for ${label} without pinning project scope...\n`);
             const discovery = await discoverSentryProjects({ baseUrl, token, org });
+            let verifiedVisibleProjects = false;
             if (discovery.ok && discovery.projects.length > 0) {
-                projects = discovery.projects;
-                process.stdout.write(`Configured ${projects.length} project(s): ${projects.slice(0, 8).join(', ')}${projects.length > 8 ? ', ...' : ''}\n`);
+                verifiedVisibleProjects = true;
+                process.stdout.write(`Found ${discovery.projects.length} visible project(s). Project scope remains unpinned so OpenClaw/Hermes can decide per run.\n`);
             }
             else {
                 const fallbackOrgs = discoveredOrganizations
@@ -2498,15 +2510,14 @@ async function guideSentryConnector(rl, secrets) {
                     process.stdout.write(`Trying visible org ${fallbackOrg}...\n`);
                     const fallbackDiscovery = await discoverSentryProjects({ baseUrl, token, org: fallbackOrg });
                     if (fallbackDiscovery.ok && fallbackDiscovery.projects.length > 0) {
-                        projects = fallbackDiscovery.projects;
-                        process.stdout.write(`Using org ${fallbackOrg}; configured ${projects.length} project(s): ${projects.slice(0, 8).join(', ')}${projects.length > 8 ? ', ...' : ''}\n`);
+                        org = fallbackOrg;
+                        verifiedVisibleProjects = true;
+                        process.stdout.write(`Using org ${fallbackOrg}; found ${fallbackDiscovery.projects.length} visible project(s). Project scope remains unpinned.\n`);
                         break;
                     }
                 }
-                if (projects.length === 0) {
-                    process.stdout.write(`Could not discover projects automatically (${discovery.detail}).\n`);
-                    const manualProjects = parseCommaList(await ask(rl, `Project slugs for ${label} (comma-separated, leave empty to let app context decide)`, ''));
-                    projects = manualProjects;
+                if (!verifiedVisibleProjects && !discovery.ok) {
+                    process.stdout.write(`Could not verify visible projects automatically (${discovery.detail}). Project scope will be resolved from app context later.\n`);
                 }
             }
         }
@@ -2519,7 +2530,6 @@ async function guideSentryConnector(rl, secrets) {
             baseUrl,
             tokenEnv,
             ...(org.trim() ? { org: org.trim() } : {}),
-            ...(projects.length > 0 ? { projects } : {}),
             ...(environment.trim() ? { environment: environment.trim() } : {}),
         });
         if (index === 0) {
@@ -2679,6 +2689,144 @@ async function maybeSelfUpdateFromClawHub(args) {
     const code = await rerunCurrentWizardWithoutSelfUpdate();
     process.exit(code ?? 0);
 }
+async function runConnectorSetupSteps({ rl, args, selected, healthByConnector, allowIsolationPrompt = true, }) {
+    clearTerminal();
+    printConnectorIntro();
+    process.stdout.write(`${ANSI.bold}Selected connectors${ANSI.reset}\n`);
+    for (const key of selected) {
+        process.stdout.write(`  - ${connectorLabel(key)}\n`);
+    }
+    process.stdout.write('\n');
+    const secrets = {};
+    let sentryAccounts = [];
+    if (selected.includes('analytics')) {
+        let forceFreshAnalyticsToken = shouldForceFreshAnalyticsToken(healthByConnector);
+        while (true) {
+            clearTerminal();
+            await guideAnalyticsConnector(rl, secrets, { forceFresh: forceFreshAnalyticsToken });
+            const check = await runImmediateConnectorHealthCheck({
+                rl,
+                configPath: args.config,
+                connector: 'analytics',
+                secrets,
+            });
+            if (!check.retry)
+                break;
+            forceFreshAnalyticsToken = true;
+        }
+    }
+    if (selected.includes('github')) {
+        while (true) {
+            clearTerminal();
+            await guideGitHubConnector(rl, secrets);
+            const check = await runImmediateConnectorHealthCheck({
+                rl,
+                configPath: args.config,
+                connector: 'github',
+                secrets,
+            });
+            if (!check.retry)
+                break;
+        }
+    }
+    if (selected.includes('revenuecat')) {
+        while (true) {
+            clearTerminal();
+            await guideRevenueCatConnector(rl, secrets);
+            const check = await runImmediateConnectorHealthCheck({
+                rl,
+                configPath: args.config,
+                connector: 'revenuecat',
+                secrets,
+            });
+            if (!check.retry)
+                break;
+        }
+    }
+    if (selected.includes('sentry')) {
+        while (true) {
+            clearTerminal();
+            sentryAccounts = await guideSentryConnector(rl, secrets);
+            const check = await runImmediateConnectorHealthCheck({
+                rl,
+                configPath: args.config,
+                connector: 'sentry',
+                secrets,
+                sentryAccounts,
+            });
+            if (!check.retry)
+                break;
+        }
+    }
+    if (selected.includes('asc')) {
+        while (true) {
+            clearTerminal();
+            await guideAscConnector(rl, secrets);
+            const check = await runImmediateConnectorHealthCheck({
+                rl,
+                configPath: args.config,
+                connector: 'asc',
+                secrets,
+            });
+            if (!check.retry)
+                break;
+        }
+    }
+    const secretsFile = resolveSecretsFile();
+    const wroteSecrets = Object.keys(secrets).length > 0;
+    clearTerminal();
+    if (wroteSecrets) {
+        await writeSecretsFile(secretsFile, secrets);
+        process.stdout.write(`\nSaved local secrets to ${secretsFile} with chmod 600.\n`);
+    }
+    else {
+        process.stdout.write('\nNo new secrets were written.\n');
+    }
+    if (sentryAccounts.length > 0 && await upsertSentryAccountsConfig(args.config, sentryAccounts)) {
+        process.stdout.write(`Configured ${sentryAccounts.length} Sentry-compatible account(s) in ${args.config}.\n`);
+    }
+    const env = {
+        ...process.env,
+        ...secrets,
+    };
+    const command = `${nodeRuntimeScriptCommand('openclaw-growth-start.mjs')} --config ${quote(args.config)} --setup-only --connectors ${quote(selected.join(','))}`;
+    let setupResult = await runSetupCommandWithProgress(command, env, selected, 'Testing connector setup...');
+    let setupPayload = parseJsonFromStdout(setupResult.stdout);
+    if (sentryAccounts.length > 0 && await upsertSentryAccountsConfig(args.config, sentryAccounts)) {
+        process.stdout.write(`Sentry-compatible account config is up to date in ${args.config}.\n`);
+    }
+    if (selected.includes('asc')) {
+        try {
+            const ascWebAuthChanged = await ensureAscWebAnalyticsAuth(rl, secrets);
+            if (ascWebAuthChanged) {
+                setupResult = await runSetupCommandWithProgress(command, env, selected, 'Retesting connector setup after ASC web analytics login...');
+                setupPayload = parseJsonFromStdout(setupResult.stdout);
+            }
+        }
+        catch (error) {
+            process.stdout.write(`ASC web analytics still needs attention: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    }
+    if (setupResult.ok && setupPayload?.ok !== false) {
+        printSetupSuccess(setupPayload);
+        if (wroteSecrets) {
+            process.stdout.write('Future OpenClaw Growth commands load this secrets file automatically.\n');
+        }
+        const configureIsolation = allowIsolationPrompt && ENABLE_ISOLATED_SECRET_RUNNER_WIZARD && await askYesNo(rl, 'Generate an isolated secret runner so OpenClaw can run health checks without reading API keys?', true);
+        if (configureIsolation) {
+            const config = await loadEditableConfig(args.config);
+            const secretAccess = await askSecretAccessModel(rl, path.resolve(args.config), config);
+            await writeJsonFile(path.resolve(args.config), config);
+            const manifestPath = await writeOpenClawJobManifest(path.resolve(args.config), config);
+            process.stdout.write(`Saved OpenClaw job manifest: ${manifestPath}\n`);
+            printSecretRunnerKitInstructions(secretAccess.kit);
+        }
+        return true;
+    }
+    printSetupFailure({ result: setupResult, payload: setupPayload, command });
+    process.exitCode = 1;
+    return false;
+}
 async function runConnectorSetupWizard(args) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         throw new Error('Connector wizard requires an interactive terminal.');
@@ -2687,151 +2835,18 @@ async function runConnectorSetupWizard(args) {
     try {
         clearTerminal();
         printConnectorIntro();
+        await migrateRuntimeSourceCommandsFile(args.config);
         const healthByConnector = await withConnectorHealthLoading((onProgress) => getConnectorPickerHealth(args.config, onProgress));
         const existingFixes = connectorKeysNeedingAttention(healthByConnector);
         const requestedConnectors = args.connectors ? parseConnectorList(args.connectors) : [];
         const chosenConnectors = requestedConnectors.length > 0
             ? orderConnectors([...new Set([...requestedConnectors, ...existingFixes])])
             : await askConnectorSelectionWithHealth(rl, healthByConnector, existingFixes);
-        let selected = withMissingRequiredAnalyticsConnector(chosenConnectors);
+        const selected = withMissingRequiredAnalyticsConnector(chosenConnectors);
         if (selected.length === 0) {
             throw new Error('No supported connectors selected. Use analytics, github, revenuecat, sentry, asc, or all.');
         }
-        clearTerminal();
-        printConnectorIntro();
-        process.stdout.write(`${ANSI.bold}Selected connectors${ANSI.reset}\n`);
-        for (const key of selected) {
-            process.stdout.write(`  - ${connectorLabel(key)}\n`);
-        }
-        process.stdout.write('\n');
-        const secrets = {};
-        let sentryAccounts = [];
-        if (selected.includes('analytics')) {
-            let forceFreshAnalyticsToken = shouldForceFreshAnalyticsToken(healthByConnector);
-            while (true) {
-                clearTerminal();
-                await guideAnalyticsConnector(rl, secrets, { forceFresh: forceFreshAnalyticsToken });
-                const check = await runImmediateConnectorHealthCheck({
-                    rl,
-                    configPath: args.config,
-                    connector: 'analytics',
-                    secrets,
-                });
-                if (!check.retry)
-                    break;
-                forceFreshAnalyticsToken = true;
-            }
-        }
-        if (selected.includes('github')) {
-            while (true) {
-                clearTerminal();
-                await guideGitHubConnector(rl, secrets);
-                const check = await runImmediateConnectorHealthCheck({
-                    rl,
-                    configPath: args.config,
-                    connector: 'github',
-                    secrets,
-                });
-                if (!check.retry)
-                    break;
-            }
-        }
-        if (selected.includes('revenuecat')) {
-            while (true) {
-                clearTerminal();
-                await guideRevenueCatConnector(rl, secrets);
-                const check = await runImmediateConnectorHealthCheck({
-                    rl,
-                    configPath: args.config,
-                    connector: 'revenuecat',
-                    secrets,
-                });
-                if (!check.retry)
-                    break;
-            }
-        }
-        if (selected.includes('sentry')) {
-            while (true) {
-                clearTerminal();
-                sentryAccounts = await guideSentryConnector(rl, secrets);
-                const check = await runImmediateConnectorHealthCheck({
-                    rl,
-                    configPath: args.config,
-                    connector: 'sentry',
-                    secrets,
-                    sentryAccounts,
-                });
-                if (!check.retry)
-                    break;
-            }
-        }
-        if (selected.includes('asc')) {
-            while (true) {
-                clearTerminal();
-                await guideAscConnector(rl, secrets);
-                const check = await runImmediateConnectorHealthCheck({
-                    rl,
-                    configPath: args.config,
-                    connector: 'asc',
-                    secrets,
-                });
-                if (!check.retry)
-                    break;
-            }
-        }
-        const secretsFile = resolveSecretsFile();
-        const wroteSecrets = Object.keys(secrets).length > 0;
-        clearTerminal();
-        if (wroteSecrets) {
-            await writeSecretsFile(secretsFile, secrets);
-            process.stdout.write(`\nSaved local secrets to ${secretsFile} with chmod 600.\n`);
-        }
-        else {
-            process.stdout.write('\nNo new secrets were written.\n');
-        }
-        if (sentryAccounts.length > 0 && await upsertSentryAccountsConfig(args.config, sentryAccounts)) {
-            process.stdout.write(`Configured ${sentryAccounts.length} Sentry-compatible account(s) in ${args.config}.\n`);
-        }
-        const env = {
-            ...process.env,
-            ...secrets,
-        };
-        const command = `node scripts/openclaw-growth-start.mjs --config ${quote(args.config)} --setup-only --connectors ${quote(selected.join(','))}`;
-        let setupResult = await runSetupCommandWithProgress(command, env, selected, 'Testing connector setup...');
-        let setupPayload = parseJsonFromStdout(setupResult.stdout);
-        if (sentryAccounts.length > 0 && await upsertSentryAccountsConfig(args.config, sentryAccounts)) {
-            process.stdout.write(`Sentry-compatible account config is up to date in ${args.config}.\n`);
-        }
-        if (selected.includes('asc')) {
-            try {
-                const ascWebAuthChanged = await ensureAscWebAnalyticsAuth(rl, secrets);
-                if (ascWebAuthChanged) {
-                    setupResult = await runSetupCommandWithProgress(command, env, selected, 'Retesting connector setup after ASC web analytics login...');
-                    setupPayload = parseJsonFromStdout(setupResult.stdout);
-                }
-            }
-            catch (error) {
-                process.stdout.write(`ASC web analytics still needs attention: ${error instanceof Error ? error.message : String(error)}\n`);
-            }
-        }
-        if (setupResult.ok && setupPayload?.ok !== false) {
-            printSetupSuccess(setupPayload);
-            if (wroteSecrets) {
-                process.stdout.write('Future OpenClaw Growth commands load this secrets file automatically.\n');
-            }
-            const configureIsolation = ENABLE_ISOLATED_SECRET_RUNNER_WIZARD && await askYesNo(rl, 'Generate an isolated secret runner so OpenClaw can run health checks without reading API keys?', true);
-            if (configureIsolation) {
-                const config = await loadEditableConfig(args.config);
-                const secretAccess = await askSecretAccessModel(rl, path.resolve(args.config), config);
-                await writeJsonFile(path.resolve(args.config), config);
-                const manifestPath = await writeOpenClawJobManifest(path.resolve(args.config), config);
-                process.stdout.write(`Saved OpenClaw job manifest: ${manifestPath}\n`);
-                printSecretRunnerKitInstructions(secretAccess.kit);
-            }
-            return;
-        }
-        printSetupFailure({ result: setupResult, payload: setupPayload, command });
-        process.exitCode = 1;
+        await runConnectorSetupSteps({ rl, args, selected, healthByConnector });
     }
     finally {
         rl.close();
@@ -2870,57 +2885,6 @@ async function askYesNo(rl, label, defaultYes = true) {
         }
     }
 }
-async function askChoice(rl, label, options, defaultValue) {
-    const normalizedDefault = options.includes(defaultValue) ? defaultValue : options[0];
-    while (true) {
-        const answer = (await rl.question(`${label} (${options.join('/')}) [${normalizedDefault}]: `))
-            .trim()
-            .toLowerCase();
-        if (!answer) {
-            return normalizedDefault;
-        }
-        if (options.includes(answer)) {
-            return answer;
-        }
-    }
-}
-async function askSourceConfig(rl, sourceName, defaultPath, hint, options = {}) {
-    const forceEnabled = Boolean(options.forceEnabled);
-    const defaultCommand = String(options.defaultCommand || getDefaultSourceCommand(sourceName) || '').trim();
-    const defaultMode = defaultCommand ? 'command' : 'file';
-    const defaultEnabled = options.defaultEnabled ?? sourceName === 'analytics';
-    const enabled = forceEnabled
-        ? true
-        : await askYesNo(rl, `Enable source "${sourceName}"?`, defaultEnabled);
-    if (!enabled) {
-        return {
-            enabled: false,
-            mode: 'file',
-            path: defaultPath,
-            hint,
-        };
-    }
-    process.stdout.write(`Where to get ${sourceName} data:\n${hint}\n`);
-    const modeInput = await ask(rl, 'Mode (file/command)', defaultMode);
-    const mode = modeInput.toLowerCase() === 'command' ? 'command' : 'file';
-    const value = await ask(rl, mode === 'file' ? `${sourceName} JSON file path` : `${sourceName} command`, mode === 'file' ? defaultPath : defaultCommand);
-    if (mode === 'file') {
-        return {
-            enabled: true,
-            mode,
-            path: value,
-            hint,
-        };
-    }
-    return {
-        enabled: true,
-        mode,
-        command: value,
-        hint,
-        ...(options.cursorMode ? { cursorMode: options.cursorMode } : {}),
-        ...(options.initialLookback ? { initialLookback: options.initialLookback } : {}),
-    };
-}
 function printCadencePlan(cadences) {
     process.stdout.write('\nDefault growth cadence:\n');
     for (const cadence of cadences) {
@@ -2930,16 +2894,28 @@ function printCadencePlan(cadences) {
     process.stdout.write('\n');
 }
 async function askToolUsage(rl) {
-    process.stdout.write('\nHow should OpenClaw Growth Engineer use this tool?\n');
-    process.stdout.write('  1) Production autopilot: notify, draft issues/PR handoffs, and analyze on schedule\n');
-    process.stdout.write('  2) Advisory only: analyze and write OpenClaw chat summaries, no GitHub artifacts by default\n');
-    process.stdout.write('  3) Manual reports: mostly one-off runs; keep scheduling conservative\n');
-    const answer = await ask(rl, 'Usage mode (1/2/3)', '1');
-    if (answer.trim() === '2')
-        return 'advisory';
-    if (answer.trim() === '3')
-        return 'manual_reports';
-    return 'production_autopilot';
+    return await askMenuChoice(rl, {
+        title: 'How should OpenClaw Growth Engineer run?',
+        subtitle: 'Use Up/Down to move, Enter to continue, or press 1-3.',
+        defaultValue: 'production_autopilot',
+        options: [
+            {
+                value: 'production_autopilot',
+                label: 'Production autopilot',
+                detail: 'Notify, draft issues/PR handoffs, and analyze on schedule.',
+            },
+            {
+                value: 'advisory',
+                label: 'Advisory only',
+                detail: 'Analyze and write OpenClaw chat summaries; no GitHub artifacts by default.',
+            },
+            {
+                value: 'manual_reports',
+                label: 'Manual reports',
+                detail: 'Mostly one-off runs with conservative scheduling.',
+            },
+        ],
+    });
 }
 async function askCadencePlan(rl) {
     const cadences = DEFAULT_CADENCE_PLAN.map((cadence) => ({ ...cadence }));
@@ -2964,27 +2940,45 @@ async function askCadencePlan(rl) {
     return cadences;
 }
 async function askWizardGoal(rl) {
-    process.stdout.write('\nWhat do you want to configure?\n');
-    process.stdout.write('  1) Full setup: project, schedule, outputs, and sources\n');
-    process.stdout.write('  2) Connectors: credentials and provider health checks\n');
-    process.stdout.write('  3) Intervals: growth cadence and connector health check interval\n');
-    process.stdout.write('  4) Output: summary, GitHub issues, draft PRs, and notifications\n');
-    const answer = await ask(rl, 'Setup area (1/2/3/4)', '1');
-    if (answer.trim() === '2')
-        return 'connectors';
-    if (answer.trim() === '3')
-        return 'intervals';
-    if (answer.trim() === '4')
-        return 'output';
-    return 'full';
+    return await askMenuChoice(rl, {
+        title: 'What do you want to configure?',
+        subtitle: 'Use Up/Down to move, Enter to continue, or press 1-4.',
+        defaultValue: 'full',
+        renderHeader: printWizardHeader,
+        options: [
+            {
+                value: 'connectors',
+                label: 'Connectors',
+                detail: 'Credentials, provider setup, and health checks.',
+            },
+            {
+                value: 'outputs_intervals',
+                label: 'Outputs and intervals',
+                detail: 'Daily/weekly/monthly jobs, GitHub issue/PR delivery, and OpenClaw chat notifications.',
+            },
+            {
+                value: 'full',
+                label: 'Full setup',
+                detail: 'Project, connectors, outputs, intervals, and sources.',
+            },
+            {
+                value: 'intervals',
+                label: 'Advanced intervals only',
+                detail: 'Runner wake-up interval and connector health check cadence.',
+            },
+        ],
+    });
+}
+function printWizardHeader() {
+    process.stdout.write('OpenClaw Growth Engineer - Setup Wizard\n');
+    process.stdout.write('This wizard can configure connector secrets. Normal config is written to config JSON; API keys stay in the local chmod 600 secrets file.\n\n');
 }
 async function buildDefaultWizardConfig() {
-    const detectedRepo = await detectGitHubRepo();
     return {
         version: 7,
         generatedAt: new Date().toISOString(),
         project: {
-            githubRepo: detectedRepo || '',
+            githubRepo: '',
             repoRoot: '.',
             outFile: 'data/openclaw-growth-engineer/issues.generated.json',
             maxIssues: 4,
@@ -2995,17 +2989,17 @@ async function buildDefaultWizardConfig() {
             analytics: {
                 enabled: true,
                 mode: 'command',
-                command: getDefaultSourceCommand('analytics'),
+                command: getWizardDefaultSourceCommand('analytics'),
             },
             revenuecat: {
                 enabled: false,
                 mode: 'command',
-                command: getDefaultSourceCommand('revenuecat'),
+                command: getWizardDefaultSourceCommand('revenuecat'),
             },
             sentry: {
-                enabled: false,
+                enabled: true,
                 mode: 'command',
-                command: getDefaultSourceCommand('sentry'),
+                command: getWizardDefaultSourceCommand('sentry'),
             },
             feedback: {
                 enabled: true,
@@ -3015,12 +3009,12 @@ async function buildDefaultWizardConfig() {
                 initialLookback: '30d',
             },
             extra: [
-                buildExtraSourceConfig('asc-cli', { enabled: false, mode: 'command', command: getDefaultSourceCommand('asc') }),
+                buildExtraSourceConfig('asc-cli', { enabled: false, mode: 'command', command: getWizardDefaultSourceCommand('asc') }),
             ],
         },
         schedule: {
-            intervalMinutes: 1440,
-            connectorHealthCheckIntervalMinutes: 720,
+            intervalMinutes: DEFAULT_GROWTH_INTERVAL_MINUTES,
+            connectorHealthCheckIntervalMinutes: DEFAULT_CONNECTOR_HEALTH_INTERVAL_MINUTES,
             skipIfNoDataChange: true,
             skipIfIssueSetUnchanged: true,
             cadences: DEFAULT_CADENCE_PLAN.map((cadence) => ({ ...cadence })),
@@ -3028,6 +3022,8 @@ async function buildDefaultWizardConfig() {
         actions: {
             autoCreateIssues: false,
             autoCreatePullRequests: false,
+            autoCreateWhenGitHubWriteAccess: true,
+            disableAutoCreateGitHubArtifacts: false,
             mode: 'issue',
             usageMode: 'production_autopilot',
             draftPullRequests: true,
@@ -3101,10 +3097,127 @@ async function buildDefaultWizardConfig() {
         },
     };
 }
+function buildRecommendedSourceConfig() {
+    return {
+        analytics: {
+            enabled: true,
+            mode: 'command',
+            command: getWizardDefaultSourceCommand('analytics'),
+        },
+        revenuecat: {
+            enabled: false,
+            mode: 'command',
+            command: getWizardDefaultSourceCommand('revenuecat'),
+        },
+        sentry: {
+            enabled: true,
+            mode: 'command',
+            command: getWizardDefaultSourceCommand('sentry'),
+        },
+        feedback: {
+            enabled: true,
+            mode: 'command',
+            command: getDefaultSourceCommand('feedback'),
+            cursorMode: 'auto_since_last_fetch',
+            initialLookback: '30d',
+        },
+        extra: [
+            buildExtraSourceConfig('asc-cli', { enabled: false, mode: 'command', command: getWizardDefaultSourceCommand('asc') }),
+        ],
+    };
+}
+function getInputChannelInitialSelection(config) {
+    const sources = config?.sources || {};
+    const extraSources = Array.isArray(sources.extra) ? sources.extra : [];
+    const selected = new Set();
+    const hasExplicitSources = Boolean(config?.sources);
+    if (!hasExplicitSources || sources.analytics?.enabled !== false)
+        selected.add('analytics');
+    if (sources.revenuecat?.enabled === true || isConnectorLocallyConfigured('revenuecat'))
+        selected.add('revenuecat');
+    if (!hasExplicitSources || sources.sentry?.enabled !== false)
+        selected.add('sentry');
+    if (extraSources.some((source) => ['asc', 'asc-cli', 'app-store-connect', 'app_store_connect'].includes(String(source?.service || source?.key || '').toLowerCase()) &&
+        source?.enabled !== false) ||
+        isConnectorLocallyConfigured('asc')) {
+        selected.add('asc');
+    }
+    if (config?.deliveries?.github?.enabled ||
+        config?.actions?.autoCreateIssues ||
+        config?.actions?.autoCreatePullRequests ||
+        isConnectorLocallyConfigured('github')) {
+        selected.add('github');
+    }
+    return orderConnectors([...selected]);
+}
+function buildSourceConfigFromInputChannels(selectedConnectors, existingSources = {}) {
+    const selected = new Set(selectedConnectors);
+    const recommended = buildRecommendedSourceConfig();
+    const migratedSources = migrateRuntimeSourceCommands({ sources: existingSources }).sources || {};
+    const existingExtra = Array.isArray(migratedSources.extra) ? migratedSources.extra : [];
+    const ascSource = existingExtra.find((source) => ['asc', 'asc-cli', 'app-store-connect', 'app_store_connect'].includes(String(source?.service || source?.key || '').toLowerCase()));
+    const nonAscExtra = existingExtra.filter((source) => source !== ascSource);
+    return {
+        ...recommended,
+        ...migratedSources,
+        analytics: {
+            ...recommended.analytics,
+            ...(migratedSources.analytics || {}),
+            command: normalizeWizardSourceCommand('analytics', {
+                ...recommended.analytics,
+                ...(migratedSources.analytics || {}),
+            }),
+            enabled: selected.has('analytics'),
+        },
+        revenuecat: {
+            ...recommended.revenuecat,
+            ...(migratedSources.revenuecat || {}),
+            command: normalizeWizardSourceCommand('revenuecat', {
+                ...recommended.revenuecat,
+                ...(migratedSources.revenuecat || {}),
+            }),
+            enabled: selected.has('revenuecat'),
+        },
+        sentry: {
+            ...recommended.sentry,
+            ...(migratedSources.sentry || {}),
+            command: normalizeWizardSourceCommand('sentry', {
+                ...recommended.sentry,
+                ...(migratedSources.sentry || {}),
+            }),
+            enabled: selected.has('sentry'),
+        },
+        feedback: {
+            ...recommended.feedback,
+            ...(migratedSources.feedback || {}),
+            enabled: selected.has('analytics'),
+        },
+        extra: [
+            ...nonAscExtra,
+            {
+                ...buildExtraSourceConfig('asc-cli', {
+                    enabled: selected.has('asc'),
+                    mode: 'command',
+                    command: getWizardDefaultSourceCommand('asc'),
+                }),
+                ...(ascSource || {}),
+                command: normalizeWizardSourceCommand('asc', {
+                    ...buildExtraSourceConfig('asc-cli', {
+                        enabled: selected.has('asc'),
+                        mode: 'command',
+                        command: getWizardDefaultSourceCommand('asc'),
+                    }),
+                    ...(ascSource || {}),
+                }),
+                enabled: selected.has('asc'),
+            },
+        ],
+    };
+}
 async function loadEditableConfig(configPath) {
     const existing = await readJsonIfPresent(configPath).catch(() => null);
     if (existing && typeof existing === 'object')
-        return existing;
+        return migrateRuntimeSourceCommands(existing);
     return await buildDefaultWizardConfig();
 }
 function mergeNotificationChannels(baseChannels, extraChannels) {
@@ -3148,28 +3261,39 @@ async function askNotificationChannels(rl, config) {
     return channels;
 }
 async function askOutputConfig(rl, config) {
-    process.stdout.write('\nOutput type\n');
-    process.stdout.write('  1) Summary only: OpenClaw chat handoff and notifications\n');
-    process.stdout.write('  2) GitHub issue drafts: generate issue-ready handoffs, no auto-create by default\n');
-    process.stdout.write('  3) GitHub pull request drafts: generate PR-oriented proposal branches when enabled\n');
+    printSection('Outputs and notifications', [
+        'OpenClaw chat is always enabled so the agent has a readable handoff.',
+        'GitHub issues or draft PRs are optional and only run when a token plus an inferred repo are available.',
+    ]);
     const currentMode = config?.actions?.mode || config?.deliveries?.github?.mode || 'issue';
     const currentAutoCreate = Boolean(config?.actions?.autoCreateIssues || config?.actions?.autoCreatePullRequests || config?.deliveries?.github?.autoCreate);
-    const defaultChoice = currentAutoCreate ? (currentMode === 'pull_request' ? '3' : '2') : '1';
-    const outputChoice = await ask(rl, 'Output type (1/2/3)', defaultChoice);
-    const summaryOnly = outputChoice.trim() === '1';
-    const mode = outputChoice.trim() === '3' ? 'pull_request' : 'issue';
-    const autoCreate = summaryOnly
-        ? false
-        : await askYesNo(rl, mode === 'pull_request'
-            ? 'Automatically create draft pull requests when new findings are found?'
-            : 'Automatically create GitHub issues when new findings are found?', currentAutoCreate);
+    const outputChoice = await askMenuChoice(rl, {
+        title: 'Output mode',
+        subtitle: 'Use Up/Down to move, Enter to continue, or press 1-3.',
+        defaultValue: currentAutoCreate ? (currentMode === 'pull_request' ? 'pull_request' : 'issue') : 'chat',
+        options: [
+            {
+                value: 'chat',
+                label: 'OpenClaw chat',
+                detail: 'Write readable summaries and leave GitHub as runtime fallback.',
+            },
+            {
+                value: 'issue',
+                label: 'GitHub issues',
+                detail: 'Auto-create issues for concrete findings when GitHub access allows it.',
+            },
+            {
+                value: 'pull_request',
+                label: 'Draft PR proposals',
+                detail: 'Auto-create draft PR-oriented proposal branches for implementation-ready fixes.',
+            },
+        ],
+    });
+    const summaryOnly = outputChoice === 'chat';
+    const mode = outputChoice === 'pull_request' ? 'pull_request' : 'issue';
+    const autoCreate = !summaryOnly;
     if (!summaryOnly) {
-        const detectedRepo = await detectGitHubRepo();
-        const currentRepo = config?.project?.githubRepo || detectedRepo || '';
-        config.project = {
-            ...(config.project || {}),
-            githubRepo: await ask(rl, 'GitHub repo for issue/PR delivery (owner/name)', currentRepo),
-        };
+        process.stdout.write('GitHub repo scope is not pinned by the wizard; OpenClaw/Hermes will infer it from OPENCLAW_GITHUB_REPO, the local git remote, or runtime context when creating issues/PRs.\n');
     }
     const channels = await askNotificationChannels(rl, config);
     const connectorHealthChannels = channels.map((channel) => {
@@ -3186,6 +3310,8 @@ async function askOutputConfig(rl, config) {
         mode,
         autoCreateIssues: mode === 'issue' && autoCreate,
         autoCreatePullRequests: mode === 'pull_request' && autoCreate,
+        autoCreateWhenGitHubWriteAccess: config.actions?.autoCreateWhenGitHubWriteAccess !== false,
+        disableAutoCreateGitHubArtifacts: config.actions?.disableAutoCreateGitHubArtifacts === true,
         draftPullRequests: true,
         proposalBranchPrefix: config?.actions?.proposalBranchPrefix || 'openclaw/proposals',
     };
@@ -3238,11 +3364,61 @@ async function askOutputConfig(rl, config) {
     };
     return config;
 }
+async function askGitHubArtifactDetails(rl, config) {
+    const githubEnabled = Boolean(config?.actions?.autoCreateIssues ||
+        config?.actions?.autoCreatePullRequests ||
+        config?.deliveries?.github?.enabled ||
+        config?.deliveries?.github?.autoCreate);
+    config.project = {
+        ...(config.project || {}),
+        githubRepo: '',
+        repoRoot: config.project?.repoRoot || '.',
+        outFile: config.project?.outFile || 'data/openclaw-growth-engineer/issues.generated.json',
+        maxIssues: Number(config.project?.maxIssues || 4),
+        titlePrefix: config.project?.titlePrefix || '[Growth]',
+        labels: Array.isArray(config.project?.labels) && config.project.labels.length > 0
+            ? config.project.labels
+            : ['ai-growth', 'autogenerated', 'product'],
+    };
+    if (!githubEnabled) {
+        return config;
+    }
+    process.stdout.write('\nGitHub repo scope is not pinned by the wizard. OpenClaw/Hermes infers it from OPENCLAW_GITHUB_REPO, the local git remote, or runtime context.\n');
+    const customize = await askYesNo(rl, 'Customize GitHub issue/PR limits, labels, or chart attachment settings?', false);
+    if (!customize) {
+        config.charting = {
+            ...(config.charting || {}),
+            enabled: config.charting?.enabled === true,
+            command: config.charting?.command || null,
+        };
+        return config;
+    }
+    const labelsRaw = await ask(rl, 'GitHub labels for created issues/PRs', config.project.labels.join(','));
+    config.project.labels = labelsRaw
+        .split(',')
+        .map((value) => value.trim())
+        .filter(Boolean);
+    config.project.maxIssues = Number.parseInt(await ask(rl, 'Maximum GitHub artifacts per run', String(config.project.maxIssues || 4)), 10) || 4;
+    config.project.titlePrefix = await ask(rl, 'GitHub artifact title prefix', config.project.titlePrefix || '[Growth]');
+    const enableCharting = await askYesNo(rl, 'Attach generated charts to GitHub artifacts when useful?', config.charting?.enabled === true);
+    config.charting = {
+        ...(config.charting || {}),
+        enabled: enableCharting,
+        command: enableCharting
+            ? await ask(rl, 'Optional chart command override', config.charting?.command || '')
+            : null,
+    };
+    return config;
+}
 async function askIntervalConfig(rl, config) {
+    printSection('Schedule and analysis depth', [
+        'The runner wakes up often, but larger reviews only run on their daily/weekly/monthly cadence.',
+        'Connector health checks are separate and default to every 6 hours.',
+    ]);
     const currentSchedule = config?.schedule || {};
-    const intervalMinutes = Number.parseInt(await ask(rl, 'Growth runner wake-up interval in minutes', String(currentSchedule.intervalMinutes || 1440)), 10) || 1440;
-    const connectorHealthCheckIntervalMinutes = Number.parseInt(await ask(rl, 'Connector health check interval in minutes', String(currentSchedule.connectorHealthCheckIntervalMinutes || 720)), 10) || 720;
     const usageMode = await askToolUsage(rl);
+    const intervalMinutes = Number.parseInt(await ask(rl, 'Growth runner wake-up interval in minutes', String(currentSchedule.intervalMinutes || DEFAULT_GROWTH_INTERVAL_MINUTES)), 10) || DEFAULT_GROWTH_INTERVAL_MINUTES;
+    const connectorHealthCheckIntervalMinutes = Number.parseInt(await ask(rl, 'Connector health check interval in minutes', String(currentSchedule.connectorHealthCheckIntervalMinutes || DEFAULT_CONNECTOR_HEALTH_INTERVAL_MINUTES)), 10) || DEFAULT_CONNECTOR_HEALTH_INTERVAL_MINUTES;
     const cadences = await askCadencePlan(rl);
     config.schedule = {
         ...currentSchedule,
@@ -3258,11 +3434,31 @@ async function askIntervalConfig(rl, config) {
     };
     return config;
 }
+async function askOutputsAndIntervalsConfig(rl, config) {
+    const withIntervals = await askIntervalConfig(rl, config);
+    const withOutput = await askOutputConfig(rl, withIntervals);
+    return await askGitHubArtifactDetails(rl, withOutput);
+}
+async function askInputSourceConfig(rl, config, configPath) {
+    config = migrateRuntimeSourceCommands(config);
+    await ensureDirForFile(configPath);
+    await writeJsonFile(configPath, config);
+    const healthByConnector = await withConnectorHealthLoading((onProgress) => getConnectorPickerHealth(configPath, onProgress));
+    const selected = await askConnectorSelectionWithHealth(rl, healthByConnector, getInputChannelInitialSelection(config), {
+        introTitle: 'Input channels',
+        introDetail: null,
+        actionTitle: 'Select input channels',
+        helpText: 'Use Up/Down to move, Space to toggle channels, A to toggle all channels, Enter to continue.',
+        mode: 'input',
+    });
+    config.sources = buildSourceConfigFromInputChannels(selected, config.sources || {});
+    return { config, selected, healthByConnector };
+}
 async function writeOpenClawJobManifest(configPath, config) {
     const manifestPath = path.resolve('.openclaw/jobs/openclaw-growth-engineer.json');
     const displayConfigPath = path.relative(process.cwd(), configPath) || configPath;
-    const intervalMinutes = Math.max(1, Number(config?.schedule?.intervalMinutes || 1440));
-    const connectorHealthCheckIntervalMinutes = Math.max(1, Number(config?.schedule?.connectorHealthCheckIntervalMinutes || 720));
+    const intervalMinutes = Math.max(1, Number(config?.schedule?.intervalMinutes || DEFAULT_GROWTH_INTERVAL_MINUTES));
+    const connectorHealthCheckIntervalMinutes = Math.max(1, Number(config?.schedule?.connectorHealthCheckIntervalMinutes || DEFAULT_CONNECTOR_HEALTH_INTERVAL_MINUTES));
     const actionMode = config?.actions?.mode || config?.deliveries?.github?.mode || 'issue';
     const growthRunCommand = getGrowthRunCommand(config, displayConfigPath);
     const connectorHealthCommand = getConnectorHealthCommand(config, displayConfigPath);
@@ -3317,8 +3513,7 @@ async function main() {
     }
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     try {
-        process.stdout.write('OpenClaw Growth Engineer - Setup Wizard\n');
-        process.stdout.write('This wizard writes non-secret config only. Connector secrets stay in the local secrets file.\n\n');
+        printWizardHeader();
         const goal = await askWizardGoal(rl);
         if (goal === 'connectors') {
             rl.close();
@@ -3336,160 +3531,40 @@ async function main() {
             process.stdout.write('OpenClaw can run and update growth jobs plus non-secret connector config from the manifest; connector API keys stay behind the connector wizard.\n');
             return;
         }
-        if (goal === 'output') {
-            const config = await askOutputConfig(rl, await loadEditableConfig(configPath));
+        if (goal === 'outputs_intervals') {
+            const config = await askOutputsAndIntervalsConfig(rl, await loadEditableConfig(configPath));
             const secretAccess = await askSecretAccessModel(rl, configPath, config);
             await writeJsonFile(configPath, config);
             const manifestPath = await writeOpenClawJobManifest(configPath, config);
-            process.stdout.write(`\nSaved output config: ${configPath}\n`);
+            process.stdout.write(`\nSaved output and interval config: ${configPath}\n`);
             process.stdout.write(`Saved OpenClaw job manifest: ${manifestPath}\n`);
             printSecretRunnerKitInstructions(secretAccess.kit);
-            process.stdout.write('Connector-health alerts are deduped per unhealthy incident and sent through configured channels.\n');
+            process.stdout.write('Daily checks prioritize Sentry and production anomalies; larger cadences analyze all configured projects and connectors.\n');
             return;
         }
-        const detectedRepo = await detectGitHubRepo();
-        const githubRepo = await ask(rl, 'GitHub repo (owner/name, optional; leave empty to infer later)', detectedRepo || '');
-        const labelsRaw = await ask(rl, 'Issue labels (comma-separated)', 'ai-growth,autogenerated,product');
-        const labels = labelsRaw
-            .split(',')
-            .map((value) => value.trim())
-            .filter(Boolean);
-        const maxIssues = Number.parseInt(await ask(rl, 'Max issues per run', '4'), 10) || 4;
-        const intervalMinutes = Number.parseInt(await ask(rl, 'Check interval in minutes', '1440'), 10) || 1440;
-        const usageMode = await askToolUsage(rl);
-        const cadences = await askCadencePlan(rl);
-        const actionMode = await askChoice(rl, 'Preferred GitHub artifact mode', ['issue', 'pull_request'], 'issue');
-        const analytics = await askSourceConfig(rl, 'analytics', 'data/openclaw-growth-engineer/analytics_summary.example.json', getDefaultSourceHint('analytics'), {
-            forceEnabled: true,
-            defaultCommand: getDefaultSourceCommand('analytics'),
-        });
-        const revenuecat = await askSourceConfig(rl, 'revenuecat', 'data/openclaw-growth-engineer/revenuecat_summary.example.json', getDefaultSourceHint('revenuecat'));
-        const sentry = await askSourceConfig(rl, 'sentry', 'data/openclaw-growth-engineer/sentry_summary.example.json', getDefaultSourceHint('sentry'));
-        const feedback = await askSourceConfig(rl, 'feedback', 'data/openclaw-growth-engineer/feedback_summary.example.json', getDefaultSourceHint('feedback'), {
-            defaultEnabled: true,
-            defaultCommand: getDefaultSourceCommand('feedback'),
-            cursorMode: 'auto_since_last_fetch',
-            initialLookback: '30d',
-        });
-        const extraSourcesRaw = await ask(rl, 'Extra connectors (comma-separated, e.g. firebase-crashlytics,app-store-reviews,play-console)', '');
-        const extraSources = extraSourcesRaw
-            .split(',')
-            .map((value) => value.trim())
-            .filter(Boolean)
-            .map((service) => {
-            const defaultCommand = getDefaultSourceCommand(service);
-            return buildExtraSourceConfig(service, defaultCommand ? {} : { mode: 'file', path: getDefaultSourcePath(service) });
+        let config = await loadEditableConfig(configPath);
+        config.version = Number(config.version || 7);
+        config.generatedAt = new Date().toISOString();
+        const inputSetup = await askInputSourceConfig(rl, config, configPath);
+        config = inputSetup.config;
+        await ensureDirForFile(configPath);
+        await writeJsonFile(configPath, config);
+        const connectorsOk = await runConnectorSetupSteps({
+            rl,
+            args: { ...args, config: configPath },
+            selected: inputSetup.selected,
+            healthByConnector: inputSetup.healthByConnector,
+            allowIsolationPrompt: false,
         });
-        const autoCreateIssues = actionMode === 'issue'
-            ? await askYesNo(rl, 'Create GitHub issues automatically when new ideas are found?', false)
-            : false;
-        const autoCreatePullRequests = actionMode === 'pull_request'
-            ? await askYesNo(rl, 'Create draft pull requests with implementation proposal files automatically?', false)
-            : false;
-        const enableCharting = await askYesNo(rl, 'Generate matplotlib charts from analytics signals and include them in generated GitHub artifacts?', false);
-        const chartCommand = enableCharting
-            ? await ask(rl, 'Optional chart command override (leave empty for default python script)', '')
-            : '';
-        const config = {
-            version: 1,
-            generatedAt: new Date().toISOString(),
-            project: {
-                githubRepo,
-                repoRoot: '.',
-                outFile: 'data/openclaw-growth-engineer/issues.generated.json',
-                maxIssues,
-                titlePrefix: '[Growth]',
-                labels,
-            },
-            sources: {
-                analytics,
-                revenuecat,
-                sentry,
-                feedback,
-                extra: extraSources,
-            },
-            schedule: {
-                intervalMinutes,
-                connectorHealthCheckIntervalMinutes: 720,
-                skipIfNoDataChange: true,
-                skipIfIssueSetUnchanged: true,
-                cadences,
-            },
-            actions: {
-                autoCreateIssues,
-                autoCreatePullRequests,
-                mode: actionMode,
-                usageMode,
-                draftPullRequests: true,
-                proposalBranchPrefix: 'openclaw/proposals',
-            },
-            deliveries: {
-                openclawChat: {
-                    enabled: true,
-                    markdownPath: '.openclaw/chat/latest.md',
-                    jsonPath: '.openclaw/chat/latest.json',
-                },
-                github: {
-                    enabled: autoCreateIssues || autoCreatePullRequests,
-                    mode: actionMode,
-                    autoCreate: autoCreateIssues || autoCreatePullRequests,
-                    draftPullRequests: true,
-                    proposalBranchPrefix: 'openclaw/proposals',
-                },
-                slack: {
-                    enabled: false,
-                    webhookEnv: 'SLACK_WEBHOOK_URL',
-                },
-                webhook: {
-                    enabled: false,
-                    urlEnv: 'OPENCLAW_WEBHOOK_URL',
-                    method: 'POST',
-                    headers: {},
-                },
-                discord: {
-                    enabled: false,
-                    command: 'node scripts/discord-openclaw-bridge.mjs send --stdin',
-                },
-            },
-            charting: {
-                enabled: enableCharting,
-                command: chartCommand || null,
-            },
-            notifications: {
-                connectorHealth: {
-                    enabled: true,
-                    channels: [
-                        {
-                            type: 'openclaw-chat',
-                            enabled: true,
-                            markdownPath: '.openclaw/chat/connector-health.md',
-                            jsonPath: '.openclaw/chat/connector-health.json',
-                        },
-                    ],
-                },
-                growthRun: {
-                    enabled: true,
-                    channels: [
-                        {
-                            type: 'openclaw-chat',
-                            enabled: true,
-                            markdownPath: '.openclaw/chat/growth-summary.md',
-                            jsonPath: '.openclaw/chat/growth-summary.json',
-                        },
-                    ],
-                },
-            },
-            secrets: {
-                githubTokenEnv: 'GITHUB_TOKEN',
-                githubTokenRef: { source: 'env', provider: 'default', id: 'GITHUB_TOKEN' },
-                analyticsTokenEnv: 'ANALYTICSCLI_ACCESS_TOKEN',
-                analyticsTokenRef: { source: 'env', provider: 'default', id: 'ANALYTICSCLI_ACCESS_TOKEN' },
-                revenuecatTokenEnv: 'REVENUECAT_API_KEY',
-                revenuecatTokenRef: { source: 'env', provider: 'default', id: 'REVENUECAT_API_KEY' },
-                sentryTokenEnv: 'SENTRY_AUTH_TOKEN',
-                sentryTokenRef: { source: 'env', provider: 'default', id: 'SENTRY_AUTH_TOKEN' },
-            },
-        };
+        if (!connectorsOk) {
+            return;
+        }
+        config = await loadEditableConfig(configPath);
+        config.version = Number(config.version || 7);
+        config.generatedAt = new Date().toISOString();
+        config = await askIntervalConfig(rl, config);
+        config = await askOutputConfig(rl, config);
+        config = await askGitHubArtifactDetails(rl, config);
         const secretAccess = await askSecretAccessModel(rl, configPath, config);
         await ensureDirForFile(configPath);
         await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
@@ -3499,14 +3574,8 @@ async function main() {
         printSecretRunnerKitInstructions(secretAccess.kit);
         process.stdout.write('\nNext steps:\n');
         process.stdout.write(`1) Set secrets in OpenClaw secret store (env var names in config.secrets)\n`);
-        if (extraSources.length > 0) {
-            process.stdout.write(`2) Fill each extra connector under \`sources.extra[]\` with the final file path or command and optional \`secretEnv\`\n`);
-            process.stdout.write(`3) Run once: node scripts/openclaw-growth-runner.mjs --config ${configPath}\n`);
-            process.stdout.write(`4) Run interval loop: node scripts/openclaw-growth-runner.mjs --config ${configPath} --loop\n`);
-            return;
-        }
-        process.stdout.write(`2) Run once: node scripts/openclaw-growth-runner.mjs --config ${configPath}\n`);
-        process.stdout.write(`3) Run interval loop: node scripts/openclaw-growth-runner.mjs --config ${configPath} --loop\n`);
+        process.stdout.write(`2) Run once: ${growthEngineerPackageCommand(`run --config ${quote(configPath)}`)}\n`);
+        process.stdout.write(`3) Run interval loop: ${growthEngineerPackageCommand(`run --config ${quote(configPath)} --loop`)}\n`);
     }
     finally {
         rl.close();
@@ -3514,6 +3583,6 @@ async function main() {
 }
 main().catch((error) => {
     process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-    process.exitCode = 1;
+    process.exitCode = error instanceof WizardAbortError ? error.exitCode : 1;
 });
 //# sourceMappingURL=openclaw-growth-wizard.mjs.map