@analyticscli/growth-engineer 0.1.0-preview.4 → 0.1.0-preview.6

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

@@ -1011,16 +1011,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.';
@@ -1796,12 +1796,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)) {
@@ -2404,13 +2398,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
@@ -2420,15 +2414,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`);
                 }
             }
         }
@@ -2441,7 +2434,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) {
@@ -2792,20 +2784,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();
@@ -2920,12 +2898,11 @@ function printWizardHeader() {
     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,
@@ -3044,6 +3021,35 @@ async function buildDefaultWizardConfig() {
         },
     };
 }
+function buildRecommendedSourceConfig() {
+    return {
+        analytics: {
+            enabled: true,
+            mode: 'command',
+            command: getDefaultSourceCommand('analytics'),
+        },
+        revenuecat: {
+            enabled: false,
+            mode: 'command',
+            command: getDefaultSourceCommand('revenuecat'),
+        },
+        sentry: {
+            enabled: true,
+            mode: 'command',
+            command: getDefaultSourceCommand('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: getDefaultSourceCommand('asc') }),
+        ],
+    };
+}
 async function loadEditableConfig(configPath) {
     const existing = await readJsonIfPresent(configPath).catch(() => null);
     if (existing && typeof existing === 'object')
@@ -3091,10 +3097,13 @@ async function askNotificationChannels(rl, config) {
     return channels;
 }
 async function askOutputConfig(rl, config) {
-    process.stdout.write('\nOutput type\n');
-    process.stdout.write('  1) OpenClaw chat plus automatic GitHub issue fallback when repo + token allow it\n');
-    process.stdout.write('  2) GitHub issues: create issues automatically when new findings are found\n');
-    process.stdout.write('  3) GitHub pull requests: create draft 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.',
+    ]);
+    process.stdout.write('  1) OpenClaw chat only, with GitHub left as runtime fallback\n');
+    process.stdout.write('  2) Auto-create GitHub issues for concrete findings\n');
+    process.stdout.write('  3) Auto-create draft PR proposals for implementation-ready fixes\n');
     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';
@@ -3107,12 +3116,7 @@ async function askOutputConfig(rl, config) {
             ? 'Automatically create draft pull requests when new findings are found?'
             : 'Automatically create GitHub issues when new findings are found?', currentAutoCreate);
     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) => {
@@ -3183,11 +3187,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 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 usageMode = await askToolUsage(rl);
     const cadences = await askCadencePlan(rl);
     config.schedule = {
         ...currentSchedule,
@@ -3205,7 +3259,79 @@ async function askIntervalConfig(rl, config) {
 }
 async function askOutputsAndIntervalsConfig(rl, config) {
     const withIntervals = await askIntervalConfig(rl, config);
-    return await askOutputConfig(rl, withIntervals);
+    const withOutput = await askOutputConfig(rl, withIntervals);
+    return await askGitHubArtifactDetails(rl, withOutput);
+}
+async function askInputSourceConfig(rl, config) {
+    printSection('Input channels', [
+        'These are the data streams Growth Engineer will read during scheduled runs.',
+        'Connector credentials are configured through the connector setup; this section only chooses which inputs are enabled and how the runner fetches them.',
+    ]);
+    process.stdout.write('Recommended defaults: AnalyticsCLI product analytics, Sentry-compatible production stability, and feedback are enabled. RevenueCat and App Store Connect are ready to enable once their connectors are configured.\n\n');
+    const useRecommended = await askYesNo(rl, 'Use recommended input channels and default fetch commands?', true);
+    if (useRecommended) {
+        config.sources = {
+            ...buildRecommendedSourceConfig(),
+            ...(config.sources || {}),
+            analytics: {
+                ...buildRecommendedSourceConfig().analytics,
+                ...(config.sources?.analytics || {}),
+                enabled: config.sources?.analytics?.enabled !== false,
+            },
+            sentry: {
+                ...buildRecommendedSourceConfig().sentry,
+                ...(config.sources?.sentry || {}),
+                enabled: config.sources?.sentry?.enabled !== false,
+            },
+            feedback: {
+                ...buildRecommendedSourceConfig().feedback,
+                ...(config.sources?.feedback || {}),
+                enabled: config.sources?.feedback?.enabled !== false,
+            },
+            revenuecat: {
+                ...buildRecommendedSourceConfig().revenuecat,
+                ...(config.sources?.revenuecat || {}),
+            },
+            extra: Array.isArray(config.sources?.extra)
+                ? config.sources.extra
+                : buildRecommendedSourceConfig().extra,
+        };
+        return config;
+    }
+    process.stdout.write('\nAdvanced input setup\n');
+    process.stdout.write('Only change these when the default CLI exporters do not match this host.\n');
+    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'), {
+        defaultEnabled: true,
+        defaultCommand: getDefaultSourceCommand('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 input connectors to define now', '');
+    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) });
+    });
+    config.sources = {
+        analytics,
+        revenuecat,
+        sentry,
+        feedback,
+        extra: extraSources,
+    };
+    return config;
 }
 async function writeOpenClawJobManifest(configPath, config) {
     const manifestPath = path.resolve('.openclaw/jobs/openclaw-growth-engineer.json');
@@ -3295,156 +3421,13 @@ async function main() {
             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, 'Growth runner wake-up interval in minutes', String(DEFAULT_GROWTH_INTERVAL_MINUTES)), 10) ||
-            DEFAULT_GROWTH_INTERVAL_MINUTES;
-        const connectorHealthCheckIntervalMinutes = Number.parseInt(await ask(rl, 'Connector health check interval in minutes', String(DEFAULT_CONNECTOR_HEALTH_INTERVAL_MINUTES)), 10) || DEFAULT_CONNECTOR_HEALTH_INTERVAL_MINUTES;
-        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'), {
-            defaultEnabled: true,
-            defaultCommand: getDefaultSourceCommand('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) });
-        });
-        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,
-                skipIfNoDataChange: true,
-                skipIfIssueSetUnchanged: true,
-                cadences,
-            },
-            actions: {
-                autoCreateIssues,
-                autoCreatePullRequests,
-                autoCreateWhenGitHubWriteAccess: true,
-                disableAutoCreateGitHubArtifacts: false,
-                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' },
-            },
-        };
+        let config = await loadEditableConfig(configPath);
+        config.version = Number(config.version || 7);
+        config.generatedAt = new Date().toISOString();
+        config = await askInputSourceConfig(rl, config);
+        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');
@@ -3454,12 +3437,6 @@ 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`);
     }