@ttfw/envoi 1.0.0

package/dist/commands/onboard.js

@@ -0,0 +1,743 @@
+/**
+ * Guided onboarding flow for Envoi.
+ *
+ * Goals:
+ * - Ensure workspace is initialized
+ * - Capture project brief (PRD)
+ * - Configure execution mode + builder + optional reviewer
+ * - Validate role connectivity
+ * - Generate initial roadmap snapshot
+ * - Optionally start execution immediately
+ */
+import { mkdir, writeFile, readFile } from 'node:fs/promises';
+import { dirname, resolve, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { atomicReadJson, atomicWriteJson } from '../lib/fs.js';
+import { CONFIG_FILE_NAME, findConfigFile, loadConfig, validateConfig, ConfigError } from '../lib/config.js';
+import { checkCursorAgent, checkCodexCli } from '../lib/doctor.js';
+import { getGitTopLevel, isGitRepo, getHeadCommit } from '../lib/git.js';
+import { CLI_NAME, PRODUCT_NAME, PACKAGE_NAME } from '../lib/branding.js';
+import { createInitialState } from '../lib/state.js';
+import { initCommand } from './init.js';
+const NON_INTERACTIVE_START_EXAMPLES = [
+    `npx -y ${PACKAGE_NAME}@latest start --mode milestone --builder cursor --prd-file ./PRD.md --no-auto-run`,
+    `cat ./PRD.md | npx -y ${PACKAGE_NAME}@latest start --mode milestone --builder cursor --no-auto-run`,
+];
+export function validateNonInteractiveOptions(options) {
+    const missing = [];
+    if (!options.mode || options.mode.trim() === '') {
+        missing.push('--mode <task|milestone|autonomous>');
+    }
+    if (!options.builder || options.builder.trim() === '') {
+        missing.push('--builder <cursor|claude_code>');
+    }
+    if (missing.length === 0)
+        return;
+    throw new Error([
+        'Non-interactive onboarding requires explicit flags.',
+        `Missing: ${missing.join(', ')}`,
+        'Run one of:',
+        ...NON_INTERACTIVE_START_EXAMPLES.map((example) => `  ${example}`),
+    ].join('\n'));
+}
+export function validateNonInteractivePrdCapture(prdCapture) {
+    const validSource = prdCapture.source === 'file' || prdCapture.source === 'stdin';
+    if (validSource && isNonEmptyContent(prdCapture.text))
+        return;
+    throw new Error([
+        'Non-interactive onboarding requires PRD input via --prd-file or stdin.',
+        'Run one of:',
+        ...NON_INTERACTIVE_START_EXAMPLES.map((example) => `  ${example}`),
+    ].join('\n'));
+}
+function withDefaultCursorConfig(existing) {
+    const defaultArgs = ['agent', '--print', '--output-format', 'text', '--workspace', '.', '--force'];
+    return {
+        driver_kind: (existing?.driver_kind ?? 'cursor_agent'),
+        command: existing?.command ?? 'cursor',
+        args: existing?.args?.length ? existing.args : defaultArgs,
+        timeout_seconds: existing?.timeout_seconds ?? 300,
+        output_file: existing?.output_file ?? 'BUILDER_RESULT.json',
+    };
+}
+function withDefaultReviewerConfig(workspaceDir, existing) {
+    return {
+        enabled: true,
+        engine: existing?.engine ?? 'codex',
+        command: existing?.command ?? 'codex',
+        model: existing?.model ?? 'gpt-5',
+        max_turns: existing?.max_turns ?? 2,
+        max_budget_usd: existing?.max_budget_usd ?? 0.6,
+        auth: {
+            mode: existing?.auth?.mode ?? 'auto',
+            ci_requires_api_key: existing?.auth?.ci_requires_api_key ?? true,
+            api_key_env: existing?.auth?.api_key_env ?? 'CODEX_API_KEY',
+        },
+        trigger: {
+            on_verify_fail: existing?.trigger?.on_verify_fail ?? true,
+            on_repeated_stop: existing?.trigger?.on_repeated_stop ?? true,
+            stop_window_ticks: existing?.trigger?.stop_window_ticks ?? 5,
+            max_stops_in_window: existing?.trigger?.max_stops_in_window ?? 2,
+            on_high_risk_paths: existing?.trigger?.on_high_risk_paths ?? true,
+            high_risk_globs: existing?.trigger?.high_risk_globs ?? ['src/**', 'app/**', 'packages/**', 'infra/**', '**/*.sql'],
+            diff_fraction_threshold: existing?.trigger?.diff_fraction_threshold ?? 0.25,
+        },
+        schema_file: existing?.schema_file ?? `${workspaceDir}/schemas/reviewer_result.schema.json`,
+        system_prompt_file: existing?.system_prompt_file ?? `${workspaceDir}/prompts/reviewer.system.txt`,
+        user_prompt_file: existing?.user_prompt_file ?? `${workspaceDir}/prompts/reviewer.user.txt`,
+    };
+}
+function isNonEmptyContent(value) {
+    return value.trim().length > 0;
+}
+export function isMeaningfulPrdText(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return false;
+    const compact = trimmed
+        .replace(/^#\s*PRD\s*$/im, '')
+        .replace(/\(Paste the user PRD here\. This is the source of truth\.\)/gi, '')
+        .trim();
+    return compact.length >= 30;
+}
+function normalizeReviewerChoice(value) {
+    if (!value || value.trim() === '')
+        return 'none';
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'none' || normalized === 'off' || normalized === 'disabled' || normalized === 'no') {
+        return 'none';
+    }
+    if (normalized === 'codex' || normalized === 'on' || normalized === 'enabled' || normalized === 'yes') {
+        return 'codex';
+    }
+    throw new Error(`Invalid reviewer value: ${value}. Must be 'none' or 'codex'.`);
+}
+async function ensureRepoRootCwd() {
+    if (isGitRepo()) {
+        const top = getGitTopLevel();
+        if (top)
+            process.chdir(top);
+    }
+}
+async function resolveConfigPath(configPath) {
+    if (configPath)
+        return resolve(configPath);
+    const found = await findConfigFile();
+    if (!found) {
+        throw new ConfigError(`Configuration file not found. Expected ${CONFIG_FILE_NAME} in current directory or parent directories.`);
+    }
+    return found;
+}
+async function ensureInitialized(forceInit) {
+    const existing = await findConfigFile();
+    if (existing && !forceInit)
+        return;
+    await initCommand({ force: forceInit, showNextSteps: false });
+}
+async function promptMultiline(label) {
+    const rl = readline.createInterface({ input, output });
+    try {
+        console.log(`\nPaste ${label} now. End input with a line containing only: END\n`);
+        const lines = [];
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const line = await rl.question('');
+            if (line.trim() === 'END')
+                break;
+            lines.push(line);
+        }
+        return lines.join('\n').trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptYesNo(question, defaultValue) {
+    if (!input.isTTY)
+        return defaultValue;
+    const rl = readline.createInterface({ input, output });
+    try {
+        const hint = defaultValue ? 'Y/n' : 'y/N';
+        const answer = (await rl.question(`${question} [${hint}]: `)).trim().toLowerCase();
+        if (!answer)
+            return defaultValue;
+        if (answer === 'y' || answer === 'yes')
+            return true;
+        if (answer === 'n' || answer === 'no')
+            return false;
+        return defaultValue;
+    }
+    finally {
+        rl.close();
+    }
+}
+export const PRD_DISCOVERY_CANDIDATES = [
+    'PRD.md',
+    'prd.md',
+    'docs/PRD.md',
+    'docs/prd.md',
+    'specs/PRD.md',
+    'product/PRD.md',
+];
+export async function discoverLocalPrdCandidates(repoRoot) {
+    const existing = [];
+    const seen = new Set();
+    for (const relativePath of PRD_DISCOVERY_CANDIDATES) {
+        const fullPath = join(repoRoot, relativePath);
+        try {
+            const content = (await readFile(fullPath, 'utf-8')).trim();
+            if (content.length > 0) {
+                const key = fullPath.toLowerCase();
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    existing.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // Ignore missing/unreadable candidates.
+        }
+    }
+    return existing;
+}
+async function choosePrdCandidate(paths, defaultPath) {
+    if (paths.length === 0)
+        return null;
+    if (!input.isTTY || paths.length === 1)
+        return paths[0];
+    const rl = readline.createInterface({ input, output });
+    try {
+        console.log('\nFound multiple PRD files:');
+        paths.forEach((path, index) => {
+            console.log(`  ${index + 1}. ${path}`);
+        });
+        console.log(`  ${paths.length + 1}. Open ${defaultPath} in editor instead`);
+        const answer = (await rl.question(`Select [1-${paths.length + 1}] (default 1): `)).trim();
+        if (answer === '')
+            return paths[0];
+        const index = Number.parseInt(answer, 10);
+        if (index >= 1 && index <= paths.length) {
+            return paths[index - 1];
+        }
+        if (index === paths.length + 1) {
+            return null;
+        }
+        throw new Error('Invalid selection');
+    }
+    finally {
+        rl.close();
+    }
+}
+function getEditorCommand() {
+    const editor = (process.env.VISUAL ?? process.env.EDITOR ?? '').trim();
+    return editor.length > 0 ? editor : null;
+}
+async function openEditorForPrd(prdPath) {
+    const editor = getEditorCommand();
+    if (!editor) {
+        return {
+            ok: false,
+            content: '',
+            reason: 'No $VISUAL or $EDITOR configured.',
+        };
+    }
+    const parts = editor.split(/\s+/).filter(Boolean);
+    const [editorCmd, ...editorArgs] = parts;
+    if (!editorCmd) {
+        return {
+            ok: false,
+            content: '',
+            reason: 'Invalid editor command.',
+        };
+    }
+    const result = spawnSync(editorCmd, [...editorArgs, prdPath], { stdio: 'inherit' });
+    if (result.status !== 0) {
+        return {
+            ok: false,
+            content: '',
+            reason: `Editor exited with code ${result.status ?? 'unknown'}`,
+        };
+    }
+    const content = (await readFile(prdPath, 'utf-8')).trim();
+    return { ok: true, content };
+}
+async function readPipedStdin() {
+    const chunks = [];
+    for await (const chunk of input)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf-8').trim();
+}
+async function promptChoice(question, options, defaultValue) {
+    const rl = readline.createInterface({ input, output });
+    try {
+        console.log(`\n${question}`);
+        options.forEach((option, index) => {
+            const suffix = defaultValue === option.value ? ' (default)' : '';
+            console.log(`  ${index + 1}. ${option.label}${suffix}`);
+            if (option.desc)
+                console.log(`     ${option.desc}`);
+        });
+        const answer = (await rl.question(`Select [1-${options.length}]${defaultValue ? ` (Enter for ${defaultValue})` : ''}: `)).trim();
+        if (answer === '' && defaultValue)
+            return defaultValue;
+        const index = Number.parseInt(answer, 10);
+        if (index >= 1 && index <= options.length)
+            return options[index - 1].value;
+        const direct = options.find((option) => option.value === answer);
+        if (direct)
+            return direct.value;
+        throw new Error('Invalid selection');
+    }
+    finally {
+        rl.close();
+    }
+}
+async function capturePrdFromInteractiveMenu(workspacePrdPath) {
+    const repoRoot = process.cwd();
+    const discovered = await discoverLocalPrdCandidates(repoRoot);
+    const sourceChoiceOptions = [
+        {
+            value: 'paste',
+            label: 'Paste PRD inline',
+            desc: 'Fastest when you already have the brief in chat or clipboard.',
+        },
+    ];
+    if (discovered.length > 0) {
+        sourceChoiceOptions.push({
+            value: 'existing',
+            label: `Use existing PRD file (${discovered.length} found)`,
+            desc: 'Reuses your local PRD document.',
+        });
+    }
+    sourceChoiceOptions.push({
+        value: 'editor',
+        label: 'Open editor for envoi/PRD.md',
+        desc: 'Writes directly to workspace source-of-truth.',
+    });
+    sourceChoiceOptions.push({
+        value: 'skip',
+        label: 'Skip for now',
+        desc: 'Setup continues; planner will wait for your brief.',
+    });
+    const sourceChoice = await promptChoice('How do you want to describe your project?', sourceChoiceOptions, discovered.length > 0 ? 'existing' : 'paste');
+    if (sourceChoice === 'existing') {
+        const selected = await choosePrdCandidate(discovered, workspacePrdPath);
+        if (selected) {
+            const content = (await readFile(selected, 'utf-8')).trim();
+            return { text: content, source: 'existing' };
+        }
+    }
+    if (sourceChoice === 'editor') {
+        console.log(`\nOpening ${workspacePrdPath}...`);
+        const editorResult = await openEditorForPrd(workspacePrdPath);
+        if (editorResult.ok)
+            return { text: editorResult.content, source: 'editor' };
+        console.log(`\n[WARN] Could not open editor: ${editorResult.reason}`);
+        const fallback = await promptMultiline('your PRD (markdown)');
+        return { text: fallback, source: 'paste' };
+    }
+    if (sourceChoice === 'skip') {
+        return { text: '', source: 'skip' };
+    }
+    return {
+        text: await promptMultiline('your PRD (markdown)'),
+        source: 'paste',
+    };
+}
+async function collectPrdText(options, workspacePrdPath) {
+    if (options.prdFile) {
+        return {
+            text: (await readFile(resolve(options.prdFile), 'utf-8')).trim(),
+            source: 'file',
+        };
+    }
+    if (!input.isTTY) {
+        const piped = await readPipedStdin();
+        if (isNonEmptyContent(piped)) {
+            return { text: piped, source: 'stdin' };
+        }
+        return { text: '', source: 'skip' };
+    }
+    return await capturePrdFromInteractiveMenu(workspacePrdPath);
+}
+async function promptStartIntentIfNeeded(showTourPrompt) {
+    if (!showTourPrompt || !input.isTTY)
+        return 'setup';
+    const choice = await promptChoice('How would you like to begin?', [
+        { value: 'tour', label: 'Tour first', desc: 'Quick walkthrough of roles, commands, and flow.' },
+        { value: 'setup', label: 'Setup now', desc: 'Go straight to project onboarding.' },
+    ], 'setup');
+    return choice === 'tour' ? 'tour' : 'setup';
+}
+function printTour() {
+    console.log(`\n${PRODUCT_NAME} tour`);
+    console.log('- You decide direction, approve, and unblock.');
+    console.log('- Planner sequences milestones and budgets.');
+    console.log('- Builder implements scoped tasks.');
+    console.log('- Checker verifies and blocks unsafe output.');
+    console.log('- One tick = plan -> edit -> verify -> stop.');
+    console.log(`- Main commands: ${CLI_NAME} tick, ${CLI_NAME} loop, ${CLI_NAME} status, ${CLI_NAME} undo.`);
+}
+function checkCommandVersion(command) {
+    const first = spawnSync(command, ['--version'], { stdio: 'pipe' });
+    if (first.status === 0) {
+        const version = `${first.stdout ?? ''}`.trim() || undefined;
+        return { available: true, version };
+    }
+    const second = spawnSync(command, ['-v'], { stdio: 'pipe' });
+    if (second.status === 0) {
+        const version = `${second.stdout ?? ''}`.trim() || undefined;
+        return { available: true, version };
+    }
+    return { available: false };
+}
+export function extractRoadmapMilestones(prompt) {
+    const lines = prompt
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const milestones = [];
+    const seen = new Set();
+    for (const line of lines) {
+        const normalized = line.replace(/^[-*]\s+/, '').replace(/^\d+[.)]\s+/, '').trim();
+        const tagged = normalized.match(/^(M\d+[A-Za-z0-9_-]*)\s*[:\-]\s*(.+)$/i);
+        if (tagged) {
+            const entry = `${tagged[1].toUpperCase()}: ${tagged[2].trim()}`;
+            if (!seen.has(entry.toLowerCase())) {
+                seen.add(entry.toLowerCase());
+                milestones.push(entry);
+            }
+            continue;
+        }
+        if (/^milestone\b/i.test(normalized) && normalized.includes(':')) {
+            if (!seen.has(normalized.toLowerCase())) {
+                seen.add(normalized.toLowerCase());
+                milestones.push(normalized);
+            }
+        }
+    }
+    return milestones.slice(0, 7);
+}
+export function extractRoadmapQuestions(prompt) {
+    const lines = prompt
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const questions = [];
+    const seen = new Set();
+    for (const line of lines) {
+        const normalized = line.replace(/^[-*]\s+/, '').replace(/^\d+[.)]\s+/, '').trim();
+        if (!normalized.endsWith('?'))
+            continue;
+        if (!seen.has(normalized.toLowerCase())) {
+            seen.add(normalized.toLowerCase());
+            questions.push(normalized);
+        }
+    }
+    return questions.slice(0, 8);
+}
+async function generateRoadmapDraft(config, mode) {
+    const baseCommit = (() => {
+        try {
+            return getHeadCommit();
+        }
+        catch {
+            return '0000000000000000000000000000000000000000';
+        }
+    })();
+    const state = createInitialState(config, baseCommit);
+    const { runOrchestrator } = await import('../runner/orchestrator.js');
+    const orchestratorResult = await runOrchestrator(state);
+    if (!orchestratorResult.success || !orchestratorResult.task) {
+        return {
+            reason: orchestratorResult.error ?? 'orchestrator returned no task',
+        };
+    }
+    const task = orchestratorResult.task;
+    const prompt = task.question?.prompt?.trim() || task.intent;
+    const milestones = extractRoadmapMilestones(prompt);
+    const clarifyingQuestions = extractRoadmapQuestions(prompt);
+    return {
+        draft: {
+            generated_at: new Date().toISOString(),
+            source: task.task_kind === 'question' ? 'orchestrator_question' : 'orchestrator_execute',
+            task_id: task.task_id,
+            milestone_id: task.milestone_id,
+            mode,
+            milestones,
+            clarifying_questions: clarifyingQuestions,
+            prompt,
+            choices: task.question?.choices ?? [],
+            token_usage: orchestratorResult.tokenUsage ?? null,
+        },
+    };
+}
+function printRoadmapPreview(roadmap) {
+    console.log('\nPlanner snapshot (ROADMAP.json):');
+    console.log(`- Source: ${roadmap.source}`);
+    console.log(`- Task: ${roadmap.task_id} (${roadmap.milestone_id})`);
+    if (roadmap.milestones.length > 0) {
+        console.log('- Proposed milestones:');
+        for (const milestone of roadmap.milestones) {
+            console.log(`  - ${milestone}`);
+        }
+    }
+    if (roadmap.clarifying_questions.length > 0) {
+        console.log('- Clarifying questions:');
+        for (const question of roadmap.clarifying_questions) {
+            console.log(`  - ${question}`);
+        }
+    }
+    if (roadmap.choices.length > 0) {
+        console.log('- Suggested choices:');
+        for (const choice of roadmap.choices) {
+            console.log(`  - ${choice}`);
+        }
+    }
+    if (roadmap.token_usage) {
+        const promptTokens = roadmap.token_usage.input_tokens ?? 'n/a';
+        const completionTokens = roadmap.token_usage.output_tokens ?? 'n/a';
+        const totalTokens = roadmap.token_usage.total_tokens ?? 'n/a';
+        console.log(`- Orchestrator tokens: in=${promptTokens} out=${completionTokens} total=${totalTokens}`);
+    }
+}
+async function runConnectivityChecks(config) {
+    console.log('\nRole connectivity checks:');
+    const plannerCli = checkCommandVersion(config.claude_code_cli.command);
+    if (plannerCli.available) {
+        console.log(`- planner: CLEARED (${config.claude_code_cli.command}${plannerCli.version ? ` ${plannerCli.version}` : ''})`);
+    }
+    else {
+        console.log(`- planner: BLOCKED (${config.claude_code_cli.command} not available)`);
+    }
+    if (config.builder.default_mode === 'cursor') {
+        const cursor = await checkCursorAgent(config);
+        if (!cursor.cli_available) {
+            console.log(`- builder: BLOCKED (cursor CLI '${cursor.command}' missing)`);
+        }
+        else if (!cursor.agent_available) {
+            console.log(`- builder: BLOCKED ('${cursor.command} agent' unavailable)`);
+        }
+        else if (cursor.auth_status === 'unauthenticated') {
+            console.log(`- builder: STANDBY (cursor agent not authenticated)`);
+        }
+        else {
+            console.log(`- builder: CLEARED (cursor agent ready)`);
+        }
+    }
+    else {
+        const builderCli = checkCommandVersion(config.claude_code_cli.command);
+        if (builderCli.available) {
+            console.log(`- builder: CLEARED (${config.claude_code_cli.command}${builderCli.version ? ` ${builderCli.version}` : ''})`);
+        }
+        else {
+            console.log(`- builder: BLOCKED (${config.claude_code_cli.command} not available)`);
+        }
+    }
+    if (config.reviewer?.enabled) {
+        if (config.reviewer.command === 'codex') {
+            const codex = await checkCodexCli(config);
+            if (!codex.cli_available) {
+                console.log('- checker: BLOCKED (codex CLI not available)');
+            }
+            else if (codex.auth_status === 'api_key_present') {
+                console.log('- checker: CLEARED (codex CLI + API key detected)');
+            }
+            else {
+                console.log('- checker: STANDBY (codex CLI available; auth status unknown)');
+            }
+        }
+        else {
+            const reviewerCli = checkCommandVersion(config.reviewer.command);
+            if (reviewerCli.available) {
+                console.log(`- checker: CLEARED (${config.reviewer.command}${reviewerCli.version ? ` ${reviewerCli.version}` : ''})`);
+            }
+            else {
+                console.log(`- checker: BLOCKED (${config.reviewer.command} not available)`);
+            }
+        }
+    }
+    else {
+        console.log('- checker: STANDBY (optional reviewer disabled)');
+    }
+}
+async function maybeStartRun(config, mode, autoRun) {
+    if (!autoRun) {
+        console.log('\nSetup complete. Waiting for you.');
+        console.log(`- Run '${CLI_NAME} tick' for one bounded cycle`);
+        console.log(`- Or run '${CLI_NAME} loop --mode ${mode}'`);
+        return;
+    }
+    console.log(`\nStarting now using mode '${mode}'...`);
+    if (mode === 'task') {
+        const { runTick } = await import('../runner/tick.js');
+        const report = await runTick(config);
+        console.log(`- First tick verdict: ${report.verdict.toUpperCase()} (${report.code})`);
+        return;
+    }
+    const { runLoop } = await import('../runner/loop.js');
+    const loopResult = await runLoop(config, { mode });
+    console.log(`- Loop finished: ${loopResult.final_verdict} (${loopResult.stop_reason})`);
+}
+export async function onboardCommand(options) {
+    await ensureRepoRootCwd();
+    await ensureInitialized(Boolean(options.forceInit));
+    const configPath = await resolveConfigPath(options.configPath);
+    const config = await loadConfig(configPath);
+    const raw = await atomicReadJson(configPath);
+    const nonInteractive = !input.isTTY;
+    if (nonInteractive) {
+        validateNonInteractiveOptions({ mode: options.mode, builder: options.builder });
+    }
+    const intent = await promptStartIntentIfNeeded(Boolean(options.showTourPrompt));
+    if (intent === 'tour') {
+        printTour();
+        const continueSetup = await promptYesNo('Continue with setup now?', true);
+        if (!continueSetup) {
+            console.log('Setup paused. Run envoi start again when ready.');
+            return;
+        }
+    }
+    // 1) Capture PRD
+    const prdPath = join(config.workspace_dir, 'PRD.md');
+    await mkdir(config.workspace_dir, { recursive: true });
+    const prdCapture = await collectPrdText({ prdFile: options.prdFile }, prdPath);
+    if (nonInteractive) {
+        validateNonInteractivePrdCapture(prdCapture);
+    }
+    if (isNonEmptyContent(prdCapture.text)) {
+        await writeFile(prdPath, `${prdCapture.text.trim()}\n`, 'utf-8');
+    }
+    // 2) Ask mode
+    const mode = options.mode ??
+        (input.isTTY
+            ? (await promptChoice('How should Envoi run by default?', [
+                { value: 'task', label: 'task', desc: 'One bounded cycle each time (lowest drift).' },
+                { value: 'milestone', label: 'milestone (recommended)', desc: 'Runs until milestone boundary, then pauses.' },
+                { value: 'autonomous', label: 'autonomous', desc: 'Runs continuously until blocked or limited.' },
+            ], raw.runner.default_loop_mode ?? 'milestone'))
+            : (raw.runner.default_loop_mode ?? 'milestone'));
+    raw.runner = { ...raw.runner, default_loop_mode: mode };
+    // 3) Ask builder
+    const builderChoice = options.builder ??
+        (input.isTTY
+            ? (await promptChoice('Which builder should implement code changes?', [
+                { value: 'cursor', label: 'cursor agent (recommended)', desc: 'Fast iterative execution, low token pressure.' },
+                { value: 'claude_code', label: 'claude code', desc: 'Single CLI stack with simpler setup.' },
+            ], raw.builder.default_mode === 'cursor' ? 'cursor' : 'claude_code'))
+            : (raw.builder.default_mode === 'cursor' ? 'cursor' : 'claude_code'));
+    // 4) Role model defaults (kept inside currently supported model set)
+    const orchestratorModel = input.isTTY
+        ? await promptChoice('Planner model?', [
+            { value: 'opus', label: 'opus (recommended)', desc: 'Best planning quality.' },
+            { value: 'sonnet', label: 'sonnet', desc: 'Balanced speed/cost.' },
+            { value: 'haiku', label: 'haiku', desc: 'Fastest/lowest cost.' },
+        ], raw.models.orchestrator_model || 'opus')
+        : (raw.models.orchestrator_model || 'opus');
+    const builderModel = builderChoice === 'claude_code'
+        ? (input.isTTY
+            ? await promptChoice('Builder model?', [
+                { value: 'sonnet', label: 'sonnet (recommended)', desc: 'Strong coding throughput.' },
+                { value: 'opus', label: 'opus', desc: 'Higher quality, higher cost.' },
+                { value: 'haiku', label: 'haiku', desc: 'Lower cost for simpler edits.' },
+            ], raw.models.builder_model || 'sonnet')
+            : (raw.models.builder_model || 'sonnet'))
+        : (raw.models.builder_model || 'sonnet');
+    raw.models = {
+        ...raw.models,
+        orchestrator_model: orchestratorModel,
+        orchestrator_fallback_model: raw.models.orchestrator_fallback_model || 'sonnet',
+        builder_model: builderModel,
+        builder_fallback_model: raw.models.builder_fallback_model || 'haiku',
+    };
+    // 5) Builder config application
+    if (builderChoice === 'cursor') {
+        const cursor = withDefaultCursorConfig(raw.builder.cursor);
+        raw.builder = {
+            ...raw.builder,
+            default_mode: 'cursor',
+            cursor: {
+                driver_kind: cursor.driver_kind ?? 'cursor_agent',
+                command: cursor.command,
+                args: cursor.args,
+                timeout_seconds: cursor.timeout_seconds,
+                output_file: cursor.output_file,
+            },
+        };
+    }
+    else {
+        raw.builder = { ...raw.builder, default_mode: 'claude_code' };
+    }
+    // 6) Optional reviewer
+    const reviewerChoice = options.reviewer !== undefined
+        ? normalizeReviewerChoice(options.reviewer)
+        : (input.isTTY
+            ? normalizeReviewerChoice(await promptChoice('Optional reviewer?', [
+                { value: 'none', label: 'No reviewer (recommended to start)', desc: 'Less friction, fastest onboarding.' },
+                { value: 'codex', label: 'Use Codex reviewer', desc: 'Adds second-pass checks for risky changes.' },
+            ], raw.reviewer?.enabled ? 'codex' : 'none'))
+            : 'none');
+    if (reviewerChoice === 'codex') {
+        const reviewerModel = input.isTTY
+            ? await promptChoice('Reviewer model?', [
+                { value: 'gpt-5', label: 'gpt-5 (recommended)', desc: 'Strong review quality for complex diffs.' },
+                { value: 'o3', label: 'o3', desc: 'Reasoning-heavy fallback.' },
+                { value: 'gpt-5-mini', label: 'gpt-5-mini', desc: 'Lower-cost reviewer option.' },
+            ], raw.reviewer?.model || 'gpt-5')
+            : (raw.reviewer?.model || 'gpt-5');
+        raw.reviewer = {
+            ...withDefaultReviewerConfig(config.workspace_dir, raw.reviewer),
+            enabled: true,
+            command: raw.reviewer?.command || 'codex',
+            model: reviewerModel,
+        };
+    }
+    else if (raw.reviewer) {
+        raw.reviewer = { ...raw.reviewer, enabled: false };
+    }
+    // Ensure PRD is runner-owned (protects from builder edits)
+    if (Array.isArray(raw.runner.runner_owned_globs) && !raw.runner.runner_owned_globs.includes(`${config.workspace_dir}/PRD.md`)) {
+        raw.runner.runner_owned_globs = [...raw.runner.runner_owned_globs, `${config.workspace_dir}/PRD.md`];
+    }
+    if (!validateConfig(raw)) {
+        throw new Error('Updated config is invalid (validateConfig failed).');
+    }
+    await atomicWriteJson(configPath, raw);
+    console.log(`\n${PRODUCT_NAME} onboarding complete.`);
+    console.log(`- Workspace: ${config.workspace_dir}`);
+    console.log(`- PRD source: ${prdCapture.source}`);
+    console.log(`- Default mode: ${mode}`);
+    console.log(`- Builder: ${builderChoice}`);
+    console.log(`- Reviewer: ${raw.reviewer?.enabled ? 'enabled' : 'disabled'}`);
+    await runConnectivityChecks(raw);
+    const roadmapPath = join(dirname(configPath), 'ROADMAP.json');
+    let existingPrdContent = '';
+    try {
+        existingPrdContent = (await readFile(prdPath, 'utf-8')).trim();
+    }
+    catch {
+        existingPrdContent = '';
+    }
+    const shouldAttemptRoadmap = isMeaningfulPrdText(prdCapture.text) || isMeaningfulPrdText(existingPrdContent);
+    if (shouldAttemptRoadmap) {
+        const draftResult = await generateRoadmapDraft(raw, mode);
+        if (draftResult.draft) {
+            await writeFile(roadmapPath, `${JSON.stringify(draftResult.draft, null, 2)}\n`, 'utf-8');
+            printRoadmapPreview(draftResult.draft);
+            console.log(`- Saved: ${roadmapPath}`);
+        }
+        else {
+            console.log(`\n[WARN] Could not generate roadmap snapshot: ${draftResult.reason}`);
+        }
+    }
+    else {
+        console.log('\nNeeds you: add a meaningful project brief (PRD) to generate roadmap guidance.');
+        console.log(`- Add context in ${prdPath}`);
+    }
+    const autoRunRequested = options.autoRun ?? input.isTTY;
+    const shouldRunNow = input.isTTY ? await promptYesNo(`Start now with mode '${mode}'?`, autoRunRequested) : false;
+    await maybeStartRun(raw, mode, shouldRunNow);
+}
+//# sourceMappingURL=onboard.js.map